Compter les lignes du fichier source à l'aide de macros?

Est-il possible, en utilisant le préprocesseur C / C ++, de compter les lignes d'un fichier source, dans une macro ou une sorte de valeur disponible au moment de la compilation? Par exemple, puis-je remplacer MAGIC1, MAGIC2et MAGIC3dans ce qui suit, et obtenir la valeur 4 en quelque sorte lors de l'utilisation MAGIC3?

MAGIC1 // can be placed wherever you like before the relevant 
       // lines - either right before them, or in global scope etc.
foo(); MAGIC2
bar(); MAGIC2
baz(); MAGIC2
quux(); MAGIC2
// ... possibly a bunch of code here; not guaranteed to be in same scope ...
MAGIC3

Remarques:

• Les extensions spécifiques au compilateur des capacités du préprocesseur sont acceptables mais indésirables.
• Si cela n'est possible qu'avec l'aide d'une partie du C ++, par opposition à la construction C, c'est également acceptable mais indésirable (c'est-à-dire que j'aimerais quelque chose qui fonctionnerait pour C).
• Évidemment, cela peut être fait en exécutant le fichier source via un script de processeur externe, mais ce n'est pas ce que je demande.

Il y a la __LINE__macro du préprocesseur qui vous donne un entier pour la ligne qui apparaît. Vous pouvez prendre sa valeur sur une ligne, puis sur une ligne ultérieure, et comparer.

static const int BEFORE = __LINE__;
foo();
bar();
baz();
quux();
static const int AFTER = __LINE__;
static const int COUNT = AFTER - BEFORE - 1; // 4

Si vous souhaitez compter les occurrences de quelque chose plutôt que des lignes source, il __COUNTER__peut s'agir d'une option non standard, prise en charge par certains compilateurs tels que GCC et MSVC.

#define MAGIC2_2(c)
#define MAGIC2(c) MAGIC2_2(c)
static const int BEFORE = __COUNTER__;
void foo(); MAGIC2(__COUNTER__);
void bar(
    int multiple,
    float lines); MAGIC2(__COUNTER__);
void baz(); MAGIC2(__COUNTER__);
void quux(); MAGIC2(__COUNTER__);
static const int AFTER = __COUNTER__;
static const int COUNT = AFTER - BEFORE - 1; // 4

J'ai pris la valeur initiale de __COUNTER__car elle aurait pu être utilisée précédemment dans le fichier source ou dans certains en-têtes inclus.

En C plutôt qu'en C ++, il y a des limitations sur les variables constantes, donc un enumpourrait être utilisé à la place.

enum MyEnum
{
    FOO = COUNT // C: error: enumerator value for ‘FOO’ is not an integer constant
};

Remplacer la const par enum:

enum {BEFORE = __LINE__};
foo();
bar();
baz();
quux();
enum { COUNT = __LINE__ - BEFORE - 1};
enum MyEnum
{
    FOO = COUNT // OK
};

Je sais que la demande de l'OP est d'utiliser des macros, mais je voudrais ajouter une autre façon de faire qui n'implique pas l'utilisation de macros.

C ++ 20 présente la source_locationclasse qui représente certaines informations sur le code source, telles que les noms de fichier, les numéros de ligne et les noms de fonction. Nous pouvons l'utiliser assez facilement dans ce cas.

#include <iostream>
#include <source_location>

static constexpr auto line_number_start = std::source_location::current().line();
void foo();
void bar();
static constexpr auto line_number_end = std::source_location::current().line();

int main() {
    std::cout << line_number_end - line_number_start - 1 << std::endl; // 2

    return 0;
}

Et l'exemple vivant ici .

Pour être complet: si vous êtes prêt à ajouter MAGIC2après chaque ligne, vous pouvez utiliser __COUNTER__:

#define MAGIC2 static_assert(__COUNTER__ + 1, "");

/* some */     MAGIC2
void source(); MAGIC2
void lines();  MAGIC2

constexpr int numberOfLines = __COUNTER__;

int main()
{
    return numberOfLines;
}

https://godbolt.org/z/i8fDLx (renvoie 3)

Vous pouvez le rendre réutilisable en stockant les valeurs de début et de fin de __COUNTER__.

Dans l'ensemble, c'est cependant très lourd. Vous ne pourrez pas non plus compter les lignes qui contiennent des directives de préprocesseur ou qui se terminent par des //commentaires. J'utiliserais à la __LINE__place, voir l'autre réponse.

Une solution un peu plus robuste, permettant différents compteurs (tant qu'ils ne se mélangent pas, et il n'y a pas d'utilisation de __COUNTER__ pour d'autres tâches):

#define CONCATENATE(s1, s2) s1##s2
#define EXPAND_THEN_CONCATENATE(s1, s2) CONCATENATE(s1, s2)

#define COUNT_THIS_LINE static_assert(__COUNTER__ + 1, "");
#define START_COUNTING_LINES(count_name) \
  enum { EXPAND_THEN_CONCATENATE(count_name, _start) = __COUNTER__ };
#define FINISH_COUNTING_LINES(count_name) \
  enum { count_name = __COUNTER__ - EXPAND_THEN_CONCATENATE(count_name, _start) - 1 };

Cela masque les détails de l'implémentation (bien qu'il les cache à l'intérieur des macros ...). C'est une généralisation de la réponse de @ MaxLanghof. Notez que __COUNTER__peut avoir une valeur non nulle lorsque nous commençons un comptage.

Voici comment il est utilisé:

START_COUNTING_LINES(ze_count)

int hello(int x) {
    x++;
    /* some */     COUNT_THIS_LINE
    void source(); COUNT_THIS_LINE
    void lines();  COUNT_THIS_LINE
    return x;
}

FINISH_COUNTING_LINES(ze_count)

int main()
{
    return ze_count;
}

En outre, il s'agit d'un C valide - si votre préprocesseur le prend en charge __COUNTER__, c'est-à-dire.

Fonctionne sur GodBolt .

Si vous utilisez C ++, vous pouvez modifier cette solution pour ne même pas polluer l'espace de noms global - en plaçant les compteurs à l'intérieur namespace macro_based_line_counts { ... }, ou namespace detailetc.)

Sur la base de votre commentaire, si vous souhaitez spécifier une taille de tableau (au moment de la compilation) en C ou C ++, vous pouvez faire

int array[]; //incomplete type
enum{ LINE0 = __LINE__ }; //enum constants are integer constant expressions
/*lines to be counted; may use array (though not sizeof(array)) */
/*...*/
int array[ __LINE__ - LINE0 ]; //complete the definition of int array[]

Si vous sizeof(array)en avez besoin dans les lignes intermédiaires, vous pouvez la remplacer par une référence de variable statique (sauf si elle doit absolument être une expression constante entière) et un compilateur d'optimisation devrait la traiter de la même manière (éliminer le besoin de placer la variable statique en mémoire)

int array[]; static int count;
enum{ LINE0 = __LINE__ }; //enum constants are integer constant expressions
//... possibly use count here
enum { LINEDIFF = __LINE__ - LINE0 }; 
int array[ LINEDIFF ]; /*complete the definition of int array[]*/ 
static int count = LINEDIFF; //fill the count in later

Une __COUNTER__solution basée sur le système (si cette extension est disponible) par opposition à une solution basée sur __LINE__le même fonctionnement.

constexprs en C ++ devrait fonctionner aussi bien enum, mais enumfonctionnera également en C simple (ma solution ci-dessus est une solution en C simple).