Déboggage précis avec __line__, __file__ et __function__

L'astuce de débogage la plus efficace en C / C consiste à utiliser les macros intégrés __File__, __line__ et __Function__ pour obtenir un contexte d'erreur précis. 1. __File__ fournit le chemin du fichier source actuel en tant que chaîne. 2. __Line__ donne le numéro de ligne actuel comme un entier. 3. __Function__ (non standard mais largement pris en charge) ou __func__ (standard C 11) renvoie le nom de la fonction entoirée. Ces constantes de temps de compilation permettent une journalisation détaillée sans frais généraux d'exécution, ce qui facilite la trace de placages ou les états non valides. Ils sont particulièrement utiles lors de la rédaction d'assutions personnalisées, de débogage sans débogueur ou de travail dans des systèmes hérités ou intégrés. Pour une meilleure réutilisation, enveloppez-les dans des macros comme Debug_Log () ou Assert (). Soyez prudent avec l'inclinaison, car il peut affecter la précision de __fonction __ et préférez __func__ pour la portabilité plus stricte. L'utilisation de ces outils permet systématiquement de débogage du temps et ne nécessite aucune dépendance externe.

Lors du débogage du code C (ou C), l'une des astuces les plus simples et les plus efficaces consiste à tirer parti des macros préprocesseurs intégrés __LINE__ , __FILE__ et __FUNCTION__ . Ce ne sont pas des fonctions ou des variables - ce sont des constantes de compilation de temps remplies automatiquement par le compilateur, vous donnant un contexte identique sur l'endroit où quelque chose s'est mal passé.

Pourquoi ces macros comptent

Imaginez que vous tracer un crash, une affirmation ratée ou un état inattendu au plus profond de votre code. L'impression de messages génériques comme "Error occurred" n'aide pas beaucoup. Mais si vous vous connectez:

 Std :: Cerr << "Erreur à" << __file__ << ":" << __line__ 
          << "In" << __Function__ << std :: endl;

Soudain, vous savez exactement quel fichier, quelle ligne et quelle fonction a déclenché le problème - pas de supposition, pas de chasse à travers des journaux.

Ces macros sont particulièrement utiles lorsque:

• Vous écrivez des journaux de débogage de bas niveau
• Vous construisez des affirmations personnalisées
• Vous travaillez dans des environnements sans débogueur
• Vous maintenez des systèmes hérités ou intégrés

Comment fonctionne chaque macro

• __FILE__ → se développe à un littéral de chaîne du chemin complet du fichier source actuel (par exemple, "src/utils.cpp" )
• __LINE__ → s'étend à une constante entière représentant le numéro de ligne actuel
• __FUNCTION__ → Un identifiant non standard mais largement pris en charge qui contient le nom de la fonction d'enclosage (Remarque: Ce n'est pas une macro, mais un const statique [] en c)

Exemple:

 void processData (int value) {
    if (valeur <0) {
        std :: cerr << "entrée non valide détectée \ n"
                  << "Fichier:" << __file__ << "\ n"
                  << "Line:" << __line__ << "\ n"
                  << "Func:" << __Function__ << std :: endl;
    }
}

Sortir:

 Entrée non valide détectée
  Fichier: src / main.cpp
  Ligne: 42
  Func: processData

Conseils pratiques pour un meilleur débogage

• Envelopper dans une macro pour réutiliser:

   #define debug_log () \
      std :: cerr << "Debug:" << __file__ << ":" << __line__ \
                << "dans" << __function__ << std :: endl

  Puis saupoudrez-le si nécessaire:

   Debug_log (); // Point de trace rapide

• Combinez avec des affirmations:

   #define assert (cond) \
      faire { \
          if (! (cond)) {\
              std :: cerr << "Assertion a échoué:" #cond "\ n" \
                        << "à" << __file__ << ":" << __line__ \
                        << "In" << __Function__ << std :: endl; \
              std :: abort (); \
          } \
      } tandis que (0)

  Vous obtenez maintenant un contexte riche en échec.

• Attention à l'inclinaison:
  Si une fonction est inclinée, __FUNCTION__ reflétera la fonction de l'appelant dans certains contextes - sachez lors du débogage du code profondément imbriqué ou optimisé.

• Différences du compilateur:
  Alors que __FILE__ et __LINE__ sont standard, __FUNCTION__ est spécifique à l'implémentation. Pour une portabilité plus stricte, considérez __func__ (c 11), qui est une variable statique locale disponible dans chaque fonction:

   void foo () {
      std :: cout << "maintenant dans:" << __func__ << std :: endl; // Standard C 11
  }

  Remarque: __func__ n'est pas une macro, vous ne pouvez donc pas le corriger avec # , mais il est fiable et standard.

  Fin de compte

  Vous n'avez pas besoin d'un cadre de journalisation fantaisie pour obtenir des informations de débogage exploitables. Avec __LINE__ , __FILE__ et __FUNCTION__ (ou __func__ ), vous ajoutez un contexte précis et précis aux diagnostics. Ils sont toujours disponibles, ne nécessitent aucune configuration et économisent des heures lors du retrait des bogues.

  Fondamentalement, si vous ne les utilisez pas déjà - commencez maintenant. C'est déboguer 101, mais souvent négligé.

  Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!