¿Contar líneas de archivo fuente usando macros?

¿Es posible, utilizando el preprocesador C / C ++, contar líneas dentro de un archivo fuente, ya sea en una macro o en algún tipo de valor disponible en tiempo de compilación? Por ejemplo, ¿puedo reemplazar MAGIC1, MAGIC2y MAGIC3en lo siguiente, y obtener el valor 4 de alguna manera cuando lo uso 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

Notas:

• Las extensiones específicas del compilador a las capacidades del preprocesador son aceptables pero indeseables.
• Si esto es posible solo con la ayuda de algunos de C ++, a diferencia de C, construir, eso también es aceptable pero indeseable (es decir, me gustaría algo que funcione para C).
• Obviamente, esto se puede hacer ejecutando el archivo fuente a través de un script de procesador externo, pero eso no es lo que estoy preguntando.

Existe la __LINE__macro de preprocesador que le da un número entero para que aparezca la línea. Puede tomar su valor en alguna línea, y luego en una línea posterior, y comparar.

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

Si desea contar las ocurrencias de algo en lugar de las líneas de origen, __COUNTER__podría ser una opción no estándar, compatible con algunos compiladores como GCC y 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

Tomé el valor inicial de __COUNTER__porque podría haber sido utilizado previamente en el archivo de origen, o algún encabezado incluido.

En C en lugar de C ++, existen limitaciones en las variables constantes, por lo enumque se podría usar una en su lugar.

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

Reemplazando el const con enum:

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

Sé que la solicitud del OP es utilizar macros, pero me gustaría agregar otra forma de hacerlo que no implique el uso de macros.

C ++ 20 presenta la source_locationclase que representa cierta información sobre el código fuente, como nombres de archivos, números de línea y nombres de funciones. Podemos usar eso con bastante facilidad en este caso.

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

Y vivir ejemplo aquí .

Para completar: si está dispuesto a agregar MAGIC2después de cada línea, puede usar __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 (devoluciones 3)

Puede hacerlo reutilizable almacenando los valores inicial y final de __COUNTER__.

En general, esto es realmente engorroso. Tampoco podrá contar líneas que contengan directivas de preprocesador o que terminen con //comentarios. En su __LINE__lugar, usaría , ver la otra respuesta.

Una solución algo más robusta, que permite diferentes contadores (siempre que no se entremezclen y no sirvan __COUNTER__para otras tareas):

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

Esto oculta los detalles de implementación (aunque los oculta dentro de las macros ...). Es una generalización de la respuesta de @ MaxLanghof. Tenga en cuenta que __COUNTER__puede tener un valor distinto de cero cuando comenzamos un conteo.

Así es como se usa:

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

Además, esto es válido C, si su preprocesador es compatible __COUNTER__, eso es.

Funciona en GodBolt .

Si está utilizando C ++, puede modificar esta solución para ni siquiera contaminar el espacio de nombres global, colocando los contadores dentro namespace macro_based_line_counts { ... }, o namespace detailetc.)

Según su comentario, si desea especificar un tamaño de matriz (tiempo de compilación) en C o C ++, puede hacer

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 necesita sizeof(array)en las líneas intermedias, puede reemplazarlo con una referencia de variable estática (a menos que sea absolutamente necesario que sea una expresión constante entera) y un compilador optimizador debe tratarlo de la misma manera (eliminar la necesidad de colocar la variable estática) en memoria)

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

Una __COUNTER__solución basada en (si esa extensión está disponible) en lugar de una __LINE__basada en la base funcionará igual.

constexprs en C ++ debería funcionar tan bien como enum, pero enumtambién funcionará en C simple (mi solución anterior es una solución de C simple).