¿Cómo puedo usar la constante de tiempo de compilación __LINE__ en una cadena?

Question

Puedo usar __LINE__ como un parámetro de método muy bien, pero me gustaría una manera fácil de usarlo en una función que utiliza cadenas.

Por ejemplo decir que tengo esto:

11 string myTest() 
12 { 
13  if(!testCondition) 
14  return logError("testcondition failed"); 
15 } 

Y quiero que el resultado de la función de ser:

"myTest línea 14: testcondition falló"

Cómo puedo escribir logError? ¿Tiene que ser una monstruosidad de una macro?

Answer 1

¿Por qué incluso lo necesita como cuerda? ¿Qué pasa con un número entero? Aquí hay dos formas en las que podría escribir logError():

#define logError(str) fprintf(stderr, "%s line %d: %s\n", __FILE__, __LINE__, str) 

// Or, forward to a more powerful function 
#define logError(str) logError2(__FILE__, __LINE__, str) 
void logError2(const char *file, int line, const char *str); 

Si realmente necesita la línea como una cadena, puede utilizar el operador stringizing #, pero debido a la forma en que funcionan las macros, que necesitará para envolverlo en dos macros:

#define STRINGIZE(x) STRINGIZE2(x) 
#define STRINGIZE2(x) #x 
#define LINE_STRING STRINGIZE(__LINE__) 

Y ahora LINE_STRING es una macro que se expandirá a una cadena que contiene el número de línea actual donde quiera que se expande. Si solo tenía un nivel de macros (es decir, si tenía #define STRINGIZE(x) #x), obtendría la cadena literal "__LINE__" cada vez que la expandiera, que no es lo que desea.

Answer 2

Las opciones habituales para dar formato a un número en una cadena aplican: lexical_cast Boost, ostringstream, sprintf o snprintf, etc.

Aquí está uno de mis enlaces favoritos sobre el tema: http://www.gotw.ca/publications/mill19.htm

Answer 3

sprintf(newStringBuffer, "myTest line %d: testcondition failed\n", __LINE__); 

debería hacerlo c estilo. Sé que hay formas y maneras de hacerlo con las librerías de cadenas C++.

También podría usar strcat() o strncat o cualquier otra cantidad de bibliotecas C para hacer esto.

cout <<"String" + __LINE__ + " another string" 

funcionarán también.

Answer 4

Sí, es feo. Necesitas una combinación de macros. La conversión de un entero a una cadena es un proceso de dos pasos - aquí está la implementación de Boost:

#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X) 
#define BOOST_DO_STRINGIZE(X) #X 

Ahora puede generar una cadena:

logError(__FILE__ BOOST_STRINGIZE(__LINE__) "testcondition failed"); 

Answer 5

No hay razón para hacer cualquier trabajo en tiempo de ejecución para este :

#include <iostream> 

// two macros ensures any macro passed will 
// be expanded before being stringified 
#define STRINGIZE_DETAIL(x) #x 
#define STRINGIZE(x) STRINGIZE_DETAIL(x) 

// test 
void print(const char* pStr) 
{ 
    std::cout << pStr << std::endl; 
} 

int main(void) 
{ 
    // adjacent strings are concatenated 
    print("This is on line #" STRINGIZE(__LINE__) "."); 
} 

---

O:

#define STOP_HAMMER_TIME(x) #x 
#define STRINGIFICATE(x) STOP_HAMMER_TIME(x) 

Si eres una persona genial como James.

Answer 6

std::string logError(const char* file, int line, const char* msg) 
{ 
    std::ostringstream os; 
    os << file << ' ' << line << ':' << msg; 
    return os.str(); 
} 

Uso:

return logError(__FILE__, __LINE__, "my error message"); 

A continuación, puede hacer una macro para esto si gastronómica así:

#define LOG_ERROR(x) logError(__FILE__, __LINE__, (x)) 

Y a continuación, el uso sería:

return LOG_ERROR("my error message"); 

Answer 7

¿Probar esto?

string myTest(const int lineno) 
{ 
    if(!testCondition) 
    return logError ("testcondition failed", lineno); 
} 

void logError (string msg, const int lineno) 
{ 
    clog << "line " << lineno << ": " << msg << endl; 
} 

Answer 8

Su objetivo es crear una macro (llamado logError) que incluirá automáticamente los símbolos necesarios y hacer la concatenación de cadenas dentro del preprocesador, utilizando sólo los literales de cadena.

Por lo tanto, la combinación de las respuestas básicamente-respuestas correctas hasta el momento, vamos a escribir la macro:

#define STRINGIZE_DETAIL(x) #x 
#define STRINGIZE(x) STRINGIZE_DETAIL(x) 
#define logError(msg) (__FILE__ " line " STRINGIZE(__LINE__) ": " msg) 

A continuación, puede utilizar esta macro en cualquier lugar para crear un código de mensaje de error genérico en formato literal de cadena en tiempo de compilación.

Nota: También puede usar __FUNCTION__ (o un equivalente, varía según el compilador) en lugar de __FILE__, si lo prefiere, para realizar un seguimiento del nombre de la función en lugar del nombre del archivo.