En ce qui concerne le préprocesseur C++ en utilisant #define pour exclure conditionnellement une fonction principale

Question

Voici la situation: J'ai trois fichiers, Test1.cpp et Test2.cpp. Test1.cpp peut être compilé tel quel dans une application autonome. Test1.cpp contient également certaines fonctions que je voudrais réutiliser dans Test2.cpp. J'utilise un #endifef #endif pour exclure conditionnellement la fonction principale de Test1.cpp afin que lorsque je compile Test2.cpp, la fonction principale de Test2.cpp puisse appeler les fonctions définies dans Test1.cpp. Exemple de code:

-------------------------------------------- 
//File: Test1.h 
#include <iostream> 
void do_something(); 
-------------------------------------------- 
//File: Test1.h 
#include "Test1.h" 
void do_something(); 
{ 
    std::cout<<"Done"<<std::endl; 
} 
#ifndef FN_MAIN 
int main() 
{ 
    do_something(); 
    return 0; 
} 
#endif 
-------------------------------------- 
//File: Test2.cpp 
#define FN_MAIN 
#include "Test1.h" 
int main() 
{ 
    do_something(); 
    return 0; 
} 
-------------------------------------- 

Appel g ++ avec test1.cpp fonctionne très bien et se comporte comme prévu, mais appeler g ++ avec test2.cpp et test1.cpp échoue parce que principal obtient défini plusieurs fois. Cependant, appeler g ++ avec -DFN_MAIN et les deux fichiers sources résout ce problème. Y a-t-il un moyen de contourner cela? Je pense que ce problème provient de ma compréhension incomplète du préprocesseur C++.

Remarque: Ma motivation pour ce faire est de réduire la taille du code sur le projet sur lequel je travaille. Le projet réel inclut à la fois une version autonome de Test1.cpp et plusieurs autres programmes qui utilisent des fonctions de Test1.cpp.

Answer 1

Le préprocesseur s'exécute séquentiellement dans chaque fichier source. Les macros définies dans un fichier .cpp n'affectent pas les macros définies dans un autre fichier .cpp.

Une option consiste à définir FN_MAIN dans l'en-tête: alors lorsque Test1.cpp inclut cet en-tête, la macro sera toujours définie. Cependant, je pense qu'il est probablement plus propre de définir la macro sur la ligne de commande; Cela dépend de votre cas d'utilisation spécifique.

Une autre option consiste à déplacer le Test1.cppmain() dans un fichier .cpp distinct et de générer un exécutable distinct avec celui-ci.

Answer 2

Pour résoudre votre problème de cette façon vous devez utiliser #include "Test1.cpp" dans Test2.cpp au lieu d'inclure Test1.h, puis seulement appeler g ++ avec Test2.cpp. De cette façon, vous ne compilerez qu'une seule unité de compilation composée de toutes les sources de Test1.cpp et de Test2.cpp.

Cependant - c'est une très mauvaise idée, alors ne le faites pas. Ce que vous devez faire à la place est d'organiser vos fonctions utilitaires dans des fichiers individuels, disons, d'abord juste dans un seul fichier Common.cpp avec le fichier d'en-tête Common.h pour garder les choses très simples. Ensuite, vous compilez et liez ces fichiers dans chaque exécutable que vous allez créer. C'est la bonne façon de le faire, c'est beaucoup plus facile à comprendre et à utiliser, et l'utilisation de plusieurs fichiers source ne vous rend pas plus grand.

Dans votre cas, après avoir déplacé vos méthodes communes en dire Common.cpp/h, vous faire quelque chose comme ceci:

g++ Test1.cpp Common.cpp # to build Test1.exe 
g++ Test2.cpp Common.cpp # to build Test2.exe