Считать строки исходного файла, используя макросы?

Возможно ли с помощью препроцессора C / C ++ подсчитать строки в исходном файле либо в макросе, либо в некотором виде, доступном во время компиляции? Например, я могу заменить MAGIC1, MAGIC2и MAGIC3в следующем, и получить значение 4 как-то при использовании 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

Ноты:

• Специфичные для компилятора расширения возможностей препроцессора приемлемы, но нежелательны.
• Если это возможно только с помощью некоторого C ++, в отличие от C, конструкции, это также приемлемо, но нежелательно (то есть я хотел бы что-то, что будет работать для C).
• Очевидно, что это можно сделать, запустив исходный файл через сценарий внешнего процессора, но я не об этом.

Есть __LINE__макрос препроцессора, который дает вам целое число для строки, в которой он появился. Вы можете взять его значение в какой-то строке, а затем в более поздней строке и сравнить.

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

Если вы хотите посчитать вхождения чего-то, а не исходные строки, это __COUNTER__может быть нестандартным вариантом, поддерживаемым некоторыми компиляторами, такими как GCC и 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

Я взял начальное значение, __COUNTER__потому что оно могло быть использовано ранее в исходном файле или в каком-то заголовке.

В C, а не в C ++ существуют ограничения на постоянные переменные, поэтому enumвместо них можно использовать.

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

Замена конста с помощью enum:

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

Я знаю, что запрос OP - использовать макросы, но я хотел бы добавить другой способ сделать это, не связанный с использованием макросов.

C ++ 20 представляет source_locationкласс, который представляет определенную информацию об исходном коде, такую ​​как имена файлов, номера строк и имена функций. Мы можем использовать это довольно легко в этом случае.

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

И живой пример здесь .

Для полноты: если вы хотите добавить MAGIC2после каждой строки, вы можете использовать __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 (возвращается 3)

Вы можете сделать его многоразовым, сохранив начальные и конечные значения __COUNTER__.

В целом это действительно громоздко, хотя. Вы также не сможете сосчитать строки, содержащие директивы препроцессора или заканчивающиеся //комментариями. Я бы использовал __LINE__вместо этого, увидеть другой ответ.

Несколько более надежное решение, позволяющее использовать разные счетчики (если они не смешиваются и не используются __COUNTER__для других задач):

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

Это скрывает детали реализации (хотя и скрывает их внутри макросов ...). Это обобщение ответа @ MaxLanghof. Обратите внимание, что __COUNTER__может иметь ненулевое значение, когда мы начинаем подсчет.

Вот как это используется:

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

Кроме того, это действительно C - если ваш препроцессор поддерживает __COUNTER__, то есть.

Работает на GodBolt .

Если вы используете C ++, вы можете изменить это решение, чтобы оно даже не загрязняло глобальное пространство имен - путем размещения счетчиков внутри namespace macro_based_line_counts { ... }и namespace detailт. Д.)

Исходя из вашего комментария, если вы хотите указать размер массива (во время компиляции) в C или C ++, вы можете сделать

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

Если вам нужны sizeof(array)промежуточные строки, вы можете заменить его ссылкой на статическую переменную (если это не обязательно должно быть целочисленное константное выражение), а оптимизирующий компилятор должен обрабатывать его точно так же (исключая необходимость размещения статической переменной в памяти)

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

Решение на __COUNTER__основе (если это расширение доступно) в отличие от решения на __LINE__основе будет работать так же.

constexprs в C ++ должен работать так же хорошо enum, но enumбудет работать и в простом C (мое решение выше - простое решение C).