Debugging yang tepat dengan __line__, __file__, dan __function__

Trik debugging yang paling berkesan dalam C/C menggunakan makro terbina dalam __file__, __line__, dan __function__ untuk mendapatkan konteks kesilapan yang tepat. 1. __File__ Menyediakan laluan fail sumber semasa sebagai rentetan. 2. __LINE__ memberikan nombor baris semasa sebagai integer. 3. __Function__ (tidak standard tetapi disokong secara meluas) atau __func__ (Standard C 11) Mengembalikan nama fungsi yang melampirkan. Pemalar masa kompilasi ini membolehkan pembalakan terperinci tanpa overhead runtime, menjadikannya mudah untuk mengesan kemalangan atau negara-negara yang tidak sah. Mereka amat berguna apabila menulis pernyataan adat, debugging tanpa debugger, atau bekerja dalam sistem warisan atau tertanam. Untuk penggunaan semula yang lebih baik, bungkusnya dalam makro seperti debug_log () atau menegaskan (). Berhati -hati dengan inlining, kerana ia boleh menjejaskan ketepatan __function __, dan lebih suka __func__ untuk mudah alih yang lebih ketat. Menggunakan alat ini secara konsisten menjimatkan masa debugging dan tidak memerlukan kebergantungan luaran.

Apabila debugging C (atau C) kod, salah satu helah yang paling mudah tetapi paling berkesan adalah memanfaatkan makro preprocessor terbina dalam __LINE__ , __FILE__ , dan __FUNCTION__ . Ini bukan fungsi atau pembolehubah-mereka adalah pemalar masa kompilasi secara automatik diisi oleh pengkompil, memberikan anda konteks yang jelas tentang sesuatu yang salah.

Mengapa makro ini penting

Bayangkan anda mengesan kemalangan, pernyataan yang gagal, atau keadaan yang tidak dijangka dalam kod anda. Mencetak mesej generik seperti "Error occurred" tidak banyak membantu. Tetapi jika anda log:

 std :: cerr << "ralat di" << __file__ << ":" << __line__ 
          << "dalam" << __function__ << std :: endl;

Tiba -tiba, anda tahu dengan tepat fail mana, garis, dan fungsi yang mencetuskan masalah itu - tidak meneka, tidak memburu melalui balak.

Makro ini sangat berguna apabila:

• Anda menulis log debug peringkat rendah
• Anda membina pernyataan tersuai
• Anda bekerja di persekitaran tanpa debugger
• Anda mengekalkan sistem warisan atau tertanam

Bagaimana setiap makro berfungsi

• __FILE__ → berkembang ke literal rentetan laluan penuh fail sumber semasa (misalnya, "src/utils.cpp" )
• __LINE__ → Memperluas ke pemalar integer yang mewakili nombor baris semasa
• __FUNCTION__ → Pengenal pasti tidak standard tetapi disokong secara meluas yang memegang nama fungsi yang dilampirkan (nota: ia bukan makro, tetapi const statik char [] dalam c)

Contoh:

 void ProcessData (nilai int) {
    jika (nilai <0) {
        std :: Cerr << "Input tidak sah dikesan \ n"
                  << "Fail:" << __file__ << "\ n"
                  << "baris:" << __line__ << "\ n"
                  << "func:" << __function__ << std :: endl;
    }
}

Output:

 Input tidak sah dikesan
  Fail: src/main.cpp
  Baris: 42
  Func: ProcessData

Petua praktikal untuk debugging yang lebih baik

• Balut makro untuk digunakan semula:

   #define debug_log () \
      std :: cerr << "debug:" << __file__ << ":" << __line__ \
                << "in" << __function__ << std :: endl

  Kemudian taburkannya di mana diperlukan:

   Debug_log (); // titik jejak cepat

• Bergabung dengan pernyataan:

   #define menegaskan (cond) \
      lakukan {\
          jika (! (cond)) {\
              std :: Cerr << "Penegasan gagal:" #cond "\ n" \
                        << "at" << __file__ << ":" << __line__ \
                        << "dalam" << __function__ << std :: endl; \
              std :: abort (); \
          } \
      } sementara (0)

  Sekarang anda mendapat konteks yang kaya dengan kegagalan.

• Berhati -hati untuk merenung:
  Sekiranya fungsi disusuli, __FUNCTION__ akan mencerminkan fungsi pemanggil dalam beberapa konteks - sedar apabila debugging kod yang sangat bersarang atau dioptimumkan.

• Perbezaan pengkompil:
  Walaupun __FILE__ dan __LINE__ adalah standard, __FUNCTION__ adalah pelaksanaan khusus. Untuk mudah alih yang lebih ketat, pertimbangkan __func__ (c 11), yang merupakan pemboleh ubah statik tempatan yang terdapat dalam setiap fungsi:

   void foo () {
      std :: cout << "Sekarang dalam:" << __func__ << std :: endl; // standard c 11
  }

  Nota: __func__ bukan makro, jadi anda tidak boleh merentasnya dengan # , tetapi ia boleh dipercayai dan standard.

  Bottom line

  Anda tidak memerlukan rangka kerja pembalakan mewah untuk mendapatkan maklumat debug yang boleh dilakukan. Dengan __LINE__ , __FILE__ , dan __FUNCTION__ (atau __func__ ), anda menambah kos sifar, tepat untuk diagnostik. Mereka sentiasa tersedia, tidak memerlukan persediaan, dan menjimatkan jam apabila menjejaki pepijat.

  Pada asasnya, jika anda tidak menggunakannya - mulakan sekarang. Ia menyahpepijat 101, tetapi sering diabaikan.

  Atas ialah kandungan terperinci Debugging yang tepat dengan __line__, __file__, dan __function__. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!