Número de línea C / C ++

En aras de la depuración, ¿puedo obtener el número de línea en los compiladores C / C ++? (forma estándar o formas específicas para ciertos compiladores)

p.ej

if(!Logical)
    printf("Not logical value at line number %d \n",LineNumber);
    // How to get LineNumber without writing it by my hand?(dynamic compilation)

Debería utilizar la macro del preprocesador __LINE__y __FILE__. Son macros predefinidas y forman parte del estándar C / C ++. Durante el preprocesamiento, se reemplazan respectivamente por una cadena constante que contiene un número entero que representa el número de línea actual y por el nombre del archivo actual.

Otras variables de preprocesador:

• __func__: nombre de la función (esto es parte de C99 , no todos los compiladores de C ++ lo admiten)
• __DATE__ : una cadena de formato "Mmm dd aaaa"
• __TIME__ : una cadena de formato "hh: mm: ss"

Tu código será:

if(!Logical)
  printf("Not logical value at line number %d in file %s\n", __LINE__, __FILE__);

Como parte del estándar C ++, existen algunas macros predefinidas que puede utilizar. La sección 16.8 del estándar C ++ define, entre otras cosas, la __LINE__macro.

__LINE__: El número de línea de la línea fuente actual (una constante decimal).
__FILE__: El nombre presunto del archivo de origen (una cadena de caracteres literal).
__DATE__: La fecha de traducción del archivo de origen (una cadena de caracteres literal ...)
__TIME__: La hora de la traducción del archivo de origen (una cadena de caracteres literal ...)
__STDC__: Si __STDC__está predefinido
__cplusplus: El nombre __cplusplusse define con el valor 199711L cuando compilar una unidad de traducción de C ++

Entonces tu código sería:

if(!Logical)
  printf("Not logical value at line number %d \n",__LINE__);

Puede usar una macro con el mismo comportamiento que printf () , excepto que también incluye información de depuración como el nombre de la función, la clase y el número de línea:

#include <cstdio>  //needed for printf
#define print(a, args...) printf("%s(%s:%d) " a,  __func__,__FILE__, __LINE__, ##args)
#define println(a, args...) print(a "\n", ##args)

Estas macros deberían comportarse de manera idéntica a printf () , mientras que incluyen información similar a la de Java stacktrace. Aquí hay un ejemplo de main:

void exampleMethod() {
    println("printf() syntax: string = %s, int = %d", "foobar", 42);
}

int main(int argc, char** argv) {
    print("Before exampleMethod()...\n");
    exampleMethod();
    println("Success!");
}

Lo que da como resultado la siguiente salida:

main (main.cpp: 11) Antes exampleMethod () ...
exampleMethod (main.cpp: 7) printf () sintaxis: string = foobar, int = 42
main (main.cpp: 13) ¡Éxito!

Use __LINE__(que es doble subrayado LINE doble subrayado), el preprocesador lo reemplazará con el número de línea en el que se encuentra.

Checkout __FILE__y __LINE__macros

C ++ 20 ofrece una nueva forma de lograr esto usando std :: source_location . Esto es actualmente accesible en gcc an clang como std::experimental::source_locationcon #include <experimental/source_location>.

El problema con las macros como __LINE__es que si desea crear, por ejemplo, una función de registro que muestre el número de línea actual junto con un mensaje, siempre debe pasar __LINE__como un argumento de función, porque se expande en el sitio de la llamada. Algo como esto:

void log(const std::string msg) {
    std::cout << __LINE__ << " " << msg << std::endl;
}

Siempre generará la línea de la declaración de función y no la línea desde donde logse llamó realmente. Por otro lado, con std::source_locationpuedes escribir algo como esto:

#include <experimental/source_location>
using std::experimental::source_location;

void log(const std::string msg, const source_location loc = source_location::current())
{
    std::cout << loc.line() << " " << msg << std::endl;
}

Aquí, locse inicializa con el número de línea apuntando a la ubicación donde logse llamó. Puedes probarlo en línea aquí.

Prueba __FILE__y __LINE__.
También puede encontrar __DATE__y __TIME__útil.
Aunque, a menos que tenga que depurar un programa en el lado del cliente y, por lo tanto, necesite registrar esta información, debe utilizar la depuración normal.

Dado que ahora también estoy enfrentando este problema y no puedo agregar una respuesta a una pregunta diferente pero también válida hecha aquí , proporcionaré una solución de ejemplo para el problema de: obtener solo el número de línea donde se ha llamado a la función C ++ usando plantillas.

Antecedentes: en C ++ se pueden utilizar valores enteros que no sean de tipo como argumento de plantilla. Esto es diferente al uso típico de tipos de datos como argumentos de plantilla. Entonces, la idea es usar tales valores enteros para una llamada de función.

#include <iostream>

class Test{
    public:
        template<unsigned int L>
        int test(){
            std::cout << "the function has been called at line number: " << L << std::endl;
            return 0;
        }
        int test(){ return this->test<0>(); }
};

int main(int argc, char **argv){
    Test t;
    t.test();
    t.test<__LINE__>();
    return 0;
}

Salida:

la función ha sido llamada en el número de línea: 0

la función ha sido llamada en el número de línea: 16

Una cosa a mencionar aquí es que en C ++ 11 Standard es posible dar valores de plantilla predeterminados para funciones usando template. En pre C ++ 11, los valores predeterminados para argumentos que no son de tipo parecen funcionar solo para argumentos de plantilla de clase. Por lo tanto, en C ++ 11, no sería necesario tener definiciones de función duplicadas como se indicó anteriormente. En C ++ 11 también es válido tener argumentos de plantilla const char * pero no es posible usarlos con literales como __FILE__o __func__como se menciona aquí .

Entonces, al final, si está usando C ++ o C ++ 11, esta podría ser una alternativa muy interesante que usar macro para obtener la línea de llamada.

Uso __LINE__, pero ¿cuál es su tipo?

LÍNEA El supuesto número de línea (dentro del archivo fuente actual) de la línea fuente actual (una constante entera).

Como una constante entera , el código a menudo puede asumir que el valor es __LINE__ <= INT_MAXy, por tanto, el tipo int.

Para imprimir en C, printf()necesita el especificador de juego: "%d". Esta es una preocupación mucho menor en C ++ con cout.

Preocupación pedante: si el número de línea excede INT_MAX¹ (algo concebible con 16 bits int), es de esperar que el compilador produzca una advertencia. Ejemplo:

format '%d' expects argument of type 'int', but argument 2 has type 'long int' [-Wformat=]

Alternativamente, el código podría obligar a tipos más amplios a evitar tales advertencias.

printf("Not logical value at line number %ld\n", (long) __LINE__);
//or
#include <stdint.h>
printf("Not logical value at line number %jd\n", INTMAX_C(__LINE__));

Evitar printf()

Para evitar todas las limitaciones de enteros: stringify . El código podría imprimirse directamente sin una printf()llamada: algo bueno para evitar en el manejo de errores ² .

#define xstr(a) str(a)
#define str(a) #a

fprintf(stderr, "Not logical value at line number %s\n", xstr(__LINE__));
fputs("Not logical value at line number " xstr(__LINE__) "\n", stderr);

¹ Ciertamente una mala práctica de programación para tener un archivo tan grande, sin embargo, quizás el código generado por la máquina puede ser alto.

² En la depuración, a veces el código simplemente no funciona como se esperaba. Llamar a funciones complejas como *printf()puede generar problemas en sí mismo frente a un simple fputs().

Para aquellos que puedan necesitarlo, una macro "FILE_LINE" para imprimir fácilmente archivos y líneas:

#define STRINGIZING(x) #x
#define STR(x) STRINGIZING(x)
#define FILE_LINE __FILE__ ":" STR(__LINE__)