dbg macro

dbg(…)

Une macro pour les fans de débogage de style printf .

Les débogueurs sont géniaux. Mais parfois, vous n'avez tout simplement pas le temps ni la patience de tout configurer correctement et vous souhaitez simplement un moyen rapide d'inspecter certaines valeurs au moment de l'exécution.

Ce projet fournit un seul fichier d'en-tête avec une macro dbg(…) qui peut être utilisée dans toutes les circonstances où vous écririez généralement printf("…", …) ou std::cout << … . Mais il comporte quelques extras.

Exemples

# include < dbg.h >
# include < cstdint >
# include < vector >

// You can use "dbg(..)" in expressions:
int32_t factorial ( int32_t n) {
  if ( dbg (n <= 1 )) {
    return dbg ( 1 );
  } else {
    return dbg (n * factorial (n - 1 ));
  }
}

int32_t main () {
  std::string message = " hello " ;
  dbg (message);  // [example.cpp:15 (main)] message = "hello" (std::string)

  const int32_t a = 2 ;
  const int32_t b = dbg ( 3 * a) + 1 ;  // [example.cpp:18 (main)] 3 * a = 6 (int32_t)

  std::vector< int32_t > numbers{b, 13 , 42 };
  dbg (numbers);  // [example.cpp:21 (main)] numbers = {7, 13, 42} (std::vector<int32_t>)

  dbg ( " this line is executed " );  // [example.cpp:23 (main)] this line is executed

  factorial ( 4 );

  return 0 ;
}

Le code ci-dessus produit cette sortie (essayez-le vous-même) :

Caractéristiques

• Sortie colorisée facile à lire (les couleurs se désactivent automatiquement lorsque la sortie n'est pas un terminal interactif)
• Imprime le nom du fichier, le numéro de ligne, le nom de la fonction et l'expression originale
• Ajoute des informations de type pour la valeur imprimée
• Jolies imprimantes spécialisées pour les conteneurs, les pointeurs, les chaînes littérales, les énumérations, std::optional , etc.
• Peut être utilisé dans des expressions (en passant par la valeur d'origine)
• L'en-tête dbg.h émet un avertissement du compilateur lorsqu'il est inclus (n'oubliez donc pas de le supprimer).
• Compatible et testé avec C++11, C++14 et C++17.

Installation

Pour rendre cela pratique, l'en-tête dbg.h doit être facilement disponible à partir de toutes sortes d'endroits différents et dans toutes sortes d'environnements. La méthode rapide et sale consiste à copier le fichier d'en-tête dans /usr/local/include ou à cloner le référentiel et à créer un lien symbolique dbg.h vers /usr/local/include/dbg.h .

git clone https://github.com/sharkdp/dbg-macro
sudo ln -s $( readlink -f dbg-macro/dbg.h ) /usr/local/include/dbg.h

Si vous ne souhaitez pas apporter de modifications non suivies à votre système de fichiers, vérifiez ci-dessous s'il existe un package pour votre système d'exploitation ou votre gestionnaire de packages.

Sur Arch Linux

Vous pouvez installer dbg-macro depuis l'AUR :

yay -S dbg-macro

Avec vcpkg

Vous pouvez installer le port dbg-macro via :

vcpkg install dbg-macro

Avec cmake

CMakeLists.txt

 cmake_minimum_required ( VERSION 3.11) # FetchContent added in cmake 3.11
project (app) # name of executable

set (CMAKE_CXX_STANDARD 17)

# dbg-macro
include (FetchContent)

FetchContent_Declare(dbg_macro GIT_REPOSITORY https://github.com/sharkdp/dbg-macro)
FetchContent_MakeAvailable(dbg_macro)

add_executable ( ${PROJECT_NAME} main.cpp) # your source files goes here
target_link_libraries ( ${PROJECT_NAME} PRIVATE dbg_macro) # make dbg.h available

main.cpp

# include < dbg.h >

int main () {
  dbg ( 42 , " hello world " , false );
  return 0 ;
}

Configuration

• Définissez l'indicateur DBG_MACRO_DISABLE pour désactiver la macro dbg(…) (c'est-à-dire pour en faire une non-opération).
• Définissez l'indicateur DBG_MACRO_NO_WARNING pour désactiver les avertissements « l'en-tête 'dbg.h' est inclus dans votre base de code » .
• Définissez l'indicateur DBG_MACRO_FORCE_COLOR pour forcer la sortie colorée et ignorer les vérifications TTY.

Fonctionnalités avancées

Arguments multiples

Vous pouvez transmettre plusieurs arguments à la macro dbg(…) . La sortie de dbg(x, y, z) est la même que celle dbg(x); dbg(y); dbg(z); :

 dbg ( 42 , " hello world " , false );

Notez que vous devez mettre les « virgules non protégées » entre parenthèses :

 dbg ( " a vector: " , (std::vector< int >{ 2 , 3 , 4 }));

Format hexadécimal, octal et binaire

Si vous souhaitez formater des entiers en représentation hexadécimale, octale ou binaire, vous pouvez simplement les envelopper dans dbg::hex(…) , dbg::oct(…) ou dbg::bin(…) :

 const uint32_t secret = 12648430 ;
dbg (dbg::hex(secret));

Noms des types d'impression

dbg(…) imprime déjà le type de chaque valeur entre parenthèses (voir capture d'écran ci-dessus). Mais parfois, vous souhaitez simplement imprimer un type (peut-être parce que vous n'avez pas de valeur pour ce type). Dans ce cas, vous pouvez utiliser l'assistant dbg::type<T>() pour imprimer joliment un type T donné. Par exemple:

 template < typename T>
void my_function_template () {
  using MyDependentType = typename std::remove_reference<T>::type&&;
  dbg (dbg::type<MyDependentType>());
}

Imprimer l'heure actuelle

Pour imprimer un horodatage, vous pouvez utiliser l'assistant dbg::time() :

 dbg (dbg::time());

Personnalisation

Si vous souhaitez que dbg(…) fonctionne pour votre type de données personnalisé, vous pouvez simplement surcharger operator<< pour std::ostream& :

std::ostream& operator <<(std::ostream& out, const user_defined_type& v) {
  out << " … " ;
  return out;
}

Si vous souhaitez modifier le nom du type imprimé par dbg(…) , vous pouvez ajouter une surcharge get_type_name personnalisée :

 // Customization point for type information
namespace dbg {
    std::string get_type_name (type_tag< bool >) {
        return " truth value " ;
    }
}

Développement

Si vous souhaitez contribuer à dbg-macro , voici comment créer les tests et les démos :

Assurez-vous que le(s) sous-module(s) sont à jour :

git submodule update --init

Ensuite, utilisez le flux de travail cmake typique. L'utilisation de -DCMAKE_CXX_STANDARD=17 est facultative, mais recommandée afin d'activer le plus grand ensemble de fonctionnalités :

mkdir build
cd build
cmake .. -DCMAKE_CXX_STANDARD=17
make

Pour exécuter les tests, appelez simplement :

make test

Vous pouvez trouver les tests unitaires dans tests/basic.cpp .

Reconnaissance

Ce projet est inspiré de la macro Rusts dbg!(…) .