Zliczać wiersze pliku źródłowego za pomocą makr?

Czy za pomocą preprocesora C / C ++ można policzyć wiersze w pliku źródłowym do makra lub innej wartości dostępnej w czasie kompilacji? Np. Czy mogę zamienić MAGIC1, MAGIC2i MAGIC3poniżej, i jakoś uzyskać wartość 4 podczas używania 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

Uwagi:

• Specyficzne dla kompilatora rozszerzenia możliwości preprocesora są dopuszczalne, ale niepożądane.
• Jeśli jest to możliwe tylko przy pomocy części C ++, w przeciwieństwie do C, konstruuj, jest to również dopuszczalne, ale niepożądane (tzn. Chciałbym coś, co działałoby dla C).
• Oczywiście można to zrobić, uruchamiając plik źródłowy za pomocą zewnętrznego skryptu procesora, ale nie o to pytam.

Istnieje __LINE__makro preprocesora, które podaje liczbę całkowitą, na której pojawi się linia. Możesz wziąć jego wartość w pewnym wierszu, a następnie w późniejszym wierszu i porównać.

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

Jeśli chcesz policzyć wystąpienia czegoś, a nie linii źródłowych, __COUNTER__może być niestandardową opcją obsługiwaną przez niektóre kompilatory, takie jak GCC i 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

Wziąłem wartość początkową, __COUNTER__ponieważ mogła być wcześniej użyta w pliku źródłowym lub w dołączonym nagłówku.

W C zamiast w C ++ istnieją ograniczenia zmiennych stałych, więc enumzamiast tego można zastosować

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

Zamiana stałej na enum:

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

Wiem, że żądanie OP dotyczy użycia makr, ale chciałbym dodać inny sposób, który nie wymaga użycia makr.

C ++ 20 wprowadza source_locationklasę reprezentującą pewne informacje o kodzie źródłowym, takie jak nazwy plików, numery linii i nazwy funkcji. W tym przypadku możemy to łatwo wykorzystać.

#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;
}

I przykład na żywo tutaj .

Dla kompletności: jeśli chcesz dodać MAGIC2po każdej linii, możesz użyć __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 (zwraca3 )

Możesz ustawić go jako wielokrotnego użytku, przechowując wartości początkowe i końcowe __COUNTER__ .

Ogólnie jest to jednak bardzo uciążliwe. Nie będziesz też mógł liczyć wierszy zawierających dyrektywy preprocesora lub zakończonych //komentarzami. Użyłbym __LINE__zamiast tego, zobacz inną odpowiedź.

Trochę bardziej niezawodne rozwiązanie, pozwalające na różne liczniki (o ile nie łączą się i nie można ich używać __COUNTER__do innych zadań):

#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 };

Ukrywa to szczegóły implementacji (chociaż ukrywa je w makrach ...). Jest to uogólnienie odpowiedzi @ MaxLanghof. Zauważ, że __COUNTER__może mieć niezerową wartość, gdy zaczynamy odliczanie.

Oto jak jest używany:

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;
}

Jest to również poprawne C - jeśli twój preprocesor obsługuje __COUNTER__, to znaczy.

Działa na GodBolt .

Jeśli używasz C ++, można zmodyfikować to rozwiązanie nawet nie zanieczyszczać globalnej przestrzeni nazw - poprzez umieszczenie liczniki wewnątrz namespace macro_based_line_counts { ... }lub namespace detailitd.)

Na podstawie komentarza, jeśli chcesz określić rozmiar tablicy (czas kompilacji) w C lub C ++, możesz to zrobić

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[]

Jeśli potrzebujesz sizeof(array)w interweniujących liniach, możesz zastąpić je odwołaniem do zmiennej statycznej (chyba że absolutnie musi to być wyrażenie całkowite stałe), a kompilator optymalizujący powinien traktować go tak samo (eliminując potrzebę umieszczania zmiennej statycznej w pamięci)

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

Rozwiązanie __COUNTER__oparte na bazie (jeśli to rozszerzenie jest dostępne), w przeciwieństwie do rozszerzenia __LINE__opartego na zasadach , będzie działać tak samo.

constexprs w C ++ powinien działać równie dobrze enum, ale enumbędzie również działał w zwykłym C (moje powyższe rozwiązanie jest zwykłym C).