¿Cómo uso __FILE__ y __LINE__ como parámetros predeterminados en un constructor en C++?

Question

Estoy tratando de usar las macros __FILE__ y __LINE__ en un constructor como parámetros predeterminados, pero parece que no puedo obtener las macros para usar los archivos correctos. Siguen expandiéndose desde mi archivo de encabezado.

Más detalladamente: me gustaría tener el archivo y el número de línea desde donde se crea una instancia de un objeto como miembros de mi clase. Pero no quiero tener que ir y poner los parámetros a mano cada vez que quiero usar los objetos. Sé que hay una manera de hacer esto, pero no puedo por la vida de mí resolverlo. Lo que estoy haciendo actualmente es el siguiente:

En mi archivo de cabecera:

mnNumber(float x, const char* filename = __FILE__, int linenumber = __LINE__): 
      value(x), mFileName(filename), mFunctionName(nullptr), mLineNumber( linenumber), mID(0) 

Pero, ARCHIVO y LÍNEA conseguir ampliada como si fueran de mi archivo de cabecera, no el real ubicación que uso el mnNumber.

Para responder a la pregunta de por qué me gustaría hacer esto, quiero que el código lea su propia página de códigos. Los valores particulares que utilizo se registran en un administrador y el usuario final puede editar su valor. Cuando el usuario final termina de editar el valor, el valor se vuelve a escribir en la página de códigos. Entonces, necesito saber de dónde vino el valor. También le permito al usuario final decir que nunca más necesitarán editar este valor, y cuando hacen clic en ese botón, el valor se convierte de un mnNumber nuevamente en un flotante, y el tipo en la página de códigos se reescribe como un flotador . O, será ... con suerte.

¿Algún consejo para mí?

Answer 1

No puede hacer esto: estas dos macros son sustituidas por el preprocesador cuando las encuentra, por lo que se intercambiarán con el nombre del archivo de encabezado y el número de lienzo.

Answer 2

Puede hacerlo con el preprocesador. Crear una macro que se expande a __LINE__ y utilizarla:

struct S { 
    S(int line, const std::string& file) : 
    line(line), file(file) { 
    } 
    std::string file; 
    int line; 
}; 

#define SCons() S(__LINE__, __FILE__) 

int main() { 

    S s1 = SCons(); 
    S s2 = SCons(); 
    std::cout << s1.line << "\n"; 
    std::cout << s2.line << "\n"; 
}  

Answer 3

La OP escribió en una edición:

No fue fácil, pero R. Martinho Fernandes me puso en el camino correcto. Y no creo que sea seguro, pero funciona hasta ahora.

Lo que quería era la capacidad de rastrear y actualizar carrozas simplemente cambiando el tipo a mnFloat. Y configuré una definición que llama a una función en mi administrador para agregar el archivo, la línea y los nombres de las funciones, luego cambia el flotador a mi tipo especial. Dentro del administrador están todos vinculados con una identificación. Cuando llamo a la función de registro, creo un objeto internamente que almaceno. En la misma línea, también se crea mi tipo especial y se registra con el administrador. Ambos objetos usan el mismo tipo de sistema de identificación (los IDs se generan al copiar desde un número estático que incremente cada vez que se crea un nuevo objeto). Como aparecen en la misma página de códigos, los ID siempre son los mismos y nunca se desincronizan. Asumiendo que no voy multiproceso, supongo. Se siente como hacer trampa, pero funciona :)

Así es como funciona.Tomo esto:

float test = 0.5; 

Y lo cambio a esto:

mnFloat test = 0.5; 

En mi archivo de cabecera, mnFloat se define así:

#define mnFloat myManager::getInstance()->register(__FILE__,__FUNCTION__,__LINE__);mnNumber 

así, los cambios de página de códigos a dos instrucciones en esa línea, y el número de línea no aumenta. ¡Y funciona!