définition de macro contenant de la directive #include

Donc, comme le disent les autres, non, vous ne pouvez pas avoir de #inclure des instructions à l'intérieur d'une macro, depuis le préprocesseur ne fait qu'une seule passe. Cependant, vous pouvez faire le préprocesseur faire quasiment la même chose avec une gnarly truc que j'ai trouvé moi-même à l'aide récemment.

Réaliser que les directives de préprocesseur ne rien faire à l'intérieur d'une macro, mais ils VONT faire quelque chose dans un fichier. Donc, vous pouvez coller un bloc de code que vous souhaitez muter dans un fichier, la penser comme une définition de macro (avec des morceaux qui peuvent être modifiés par d'autres macros), et puis le #inclure cette pseudo-fichier de macro dans différents endroits (assurez-vous qu'il n'a pas d'inclure gardes!). Il ne se comporte pas exactement comme une macro, mais il peut atteindre quelques jolies macro-comme résultats, depuis #include fondamentalement juste vide le contenu d'un fichier à l'autre.

Par exemple, envisager d'inclure des lots de même nom en-têtes de groupes. Il est fastidieux de les écrire, ou peut-être même qu'ils sont auto-générés. Vous pouvez automatiser en partie leur inclusion en faisant quelque chose comme ceci:

Les macros d'assistance en-tête:

/* tools.hpp */

#ifndef __TOOLS_HPP__
#def __TOOLS_HPP__

//Macro for adding quotes
#define STRINGIFY(X) STRINGIFY2(X)    
#define STRINGIFY2(X) #X

//Macros for concatenating tokens
#define CAT(X,Y) CAT2(X,Y)
#define CAT2(X,Y) X##Y
#define CAT_2 CAT
#define CAT_3(X,Y,Z) CAT(X,CAT(Y,Z))
#define CAT_4(A,X,Y,Z) CAT(A,CAT_3(X,Y,Z))
//etc...

#endif

Pseudo-fichier de macro

/* pseudomacro.hpp */

#include "tools.hpp"
//NO INCLUDE GUARD ON PURPOSE
//Note especially FOO, which we can #define before #include-ing this file,
//in order to alter which files it will in turn #include.
//FOO fulfils the role of "parameter" in this pseudo-macro.

#define INCLUDE_FILE(HEAD,TAIL) STRINGIFY( CAT_3(HEAD,FOO,TAIL) )

#include INCLUDE_FILE(head1,tail1.hpp) //expands to #head1FOOtail1.hpp
#include INCLUDE_FILE(head2,tail2.hpp)
#include INCLUDE_FILE(head3,tail3.hpp)
#include INCLUDE_FILE(head4,tail4.hpp)
//etc..

#undef INCLUDE_FILE

Fichier Source

/* mainfile.cpp */

//Here we automate the including of groups of similarly named files

#define FOO _groupA_
#include "pseudomacro.hpp"
//"expands" to: 
//#include "head1_groupA_tail1.hpp"
//#include "head2_groupA_tail2.hpp"
//#include "head3_groupA_tail3.hpp"
//#include "head4_groupA_tail4.hpp"
#undef FOO

#define FOO _groupB_
#include "pseudomacro.hpp"
//"expands" to: 
//#include "head1_groupB_tail1.hpp"
//#include "head2_groupB_tail2.hpp"
//#include "head3_groupB_tail3.hpp"
//#include "head4_groupB_tail4.hpp"
#undef FOO

#define FOO _groupC_
#include "pseudomacro.hpp"
#undef FOO

//etc.

Ces inclut pourrait même être dans le milieu de codes de blocs que vous souhaitez répéter (avec FOO modifié), comme la réponse par Bing Jian demandes: définition de macro contenant de la directive #include

Je n'ai pas utilisé cette astuce largement, mais c'est mon travail. Il peut évidemment être étendue à autant de "paramètres" en tant que de besoin, et vous pouvez exécuter n'importe quelle préprocesseur commandes vous là-dedans, ainsi que de générer le code réel. Vous ne pouvez pas utiliser les trucs qu'il crée comme l'entrée dans une autre macro, comme vous le pouvez avec la normale macros, puisque vous ne pouvez pas coller l'inclure à l'intérieur d'une macro. Mais il peut aller à l'intérieur un autre pseudo-macro :).

Autres pourraient avoir certains commentaires sur d'autres limitations, et de ce qui pourrait aller mal :).

Langages C et C++ interdire explicitement formant les directives de préprocesseur comme le résultat de l'expansion des macros. Cela signifie que vous ne pouvez pas inclure une directive de préprocesseur dans une macro liste de remplacement. Et si vous essayez de tromper le préprocesseur par "construire" une nouvelle directive de préprocesseur par concaténation (et des trucs comme ça), le comportement est indéfini.

J'ai aussi voulu faire cela, et en voici la raison:

Certains fichiers d'en-tête (notamment mpi.h dans OpenMPI) fonctionnent différemment si vous êtes à la compilation en C ou C++. Je suis un lien vers un C MPI le code de mon programme en C++. Inclure l'en-tête, je ne l'habituel:

extern "C" {
#include "blah.h"
}

Mais cela ne fonctionne pas parce que __cplusplus est encore défini, même dans une liaison C. Cela signifie que mpi.h, qui est inclus par bla.h, commence à la définition de modèles et le compilateur meurt en disant: vous ne pouvez pas utiliser des modèles avec une liaison C.

Donc, ce que j'ai à faire dans bla.h est à remplacer

#include <mpi.h>

avec

#ifdef __cplusplus
#undef __cplusplus
#include <mpi.h>
#define __cplusplus
#else
#include <mpi.h>
#endif

Remarquablement ce n'est pas seulement mpi.h n'est ce pathologique chose. Donc, je veux définir une macro INCLUDE_AS_C qui ne le ci-dessus pour le fichier spécifié. Mais je suppose que ça ne fonctionne pas.

Si quelqu'un peut comprendre d'une autre façon d'accomplir ceci, s'il vous plaît laissez-moi savoir.

Pourquoi la macro besoin d'avoir un #include? si vous êtes à la #include avec tout fichier de la macro, tu pourrais juste mettre le #include au-dessus de la macro avec tout le reste des instructions #include, et tout doit être beau et élégant.

Je ne vois pas de raison d'avoir de la macro d'inclure tout ce qui ne pouvait pas juste être inclus dans le fichier.

Contagieuse est juste, si vous êtes en train de faire:

myFile.c:

#include "standardAppDefs.h"
#myStandardIncludeMacro

standardAppDefs.h:

#define myStandardIncludeMacro #include <foo.h>

Pourquoi ne pas simplement dire:

myFile.c:

#include "standardAppDefs.h"

standardAppDefs.h:

#include <foo.h>

Et d'oublier les macros?