Obtener ruta del archivo de cabecera incluida en VC ++

Question

Medio Ambiente: estoy usando MS-VC ++ 6.0,

• incluyo un grupo de archivo de cabecera con algunos datos.
• Los archivos de cabecera cambian a menudo, etc. cada cambio de cambio de la trayectoria configuración y re-compilador
• Un archivo de registro se genera en base a la incluidos los archivos de cabecera

• Para el seguimiento del archivo de cabecera de el archivo de registro, deseo para imprimir el ruta del archivo de cabecera dentro del registro

• Pregunta-1: está recibiendo la cabecera ruta del archivo desde el programa posible?

• Pregunta-2: Estoy utilizando VC ++, pero si Es posible en gcc, entonces no puedo fácilmente el puerto, por lo que, por favor, hágamelo saber, si es posible en cualquier otra ambiente como gcc

Answer 1

En VC ++, compilar con la opción /FC pondrá del archivo que se está procesando ruta entera en la macro __FILE__.

Eso cuenta de los cambios en la ruta de inclusión.

detalles aquí.

Answer 2

Claro - dentro de la opción de venta archivo de cabecera:

static const char *header_path = __FILE__;

.. a continuación, sólo se imprime la cadena apuntada por header_path en su registro.

Answer 3

¿Quiere decir que el tener #include "path/to/header.h", que desea imprimir "ruta / a / header.h" desde el propio programa?

#define INCLUDE_FILE "path/to/header.h"
#include INCLUDE_FILE

printf("Included: %s\n", INCLUDE_FILE);

Answer 4

Puede obtener la lista de archivos de inclusión de esta manera.

(project)
(export makefile)
(write dependencies when writing make files)

exportar los archivos de maquillaje, lo que crea .mak archivos y archivos .dep. Los archivos de inclusión se enumeran en los archivos .dep.

En cuanto a la idea de obtener la ruta completa de los archivos de inclusión dentro del programa en ejecución. Uno podría ser capaz de utilizar el uso del modelo de objetos msvc 6, para tirar de la lista de incluir las rutas de archivos fuera del IDE. Una vez que se sabe que la lista. Se podría usar el archivo hallazgo, para buscar esa lista de rutas de los archivos de inclusión de interés.

Answer 5

La autorización, aquí es una solución (ahora espero que le he entendido bien).

Utiliza plantillas recursivas, la macro __FILE__, y la macro __COUNTER__. Un archivo especial encabezado headerlisting.h contiene la lógica para la recursividad plantilla, e incluye dos macros útiles (más algún ayudante de macro)

1. ADD_HEADER_FILE, sólo tiene que añadir esta línea para cada archivo de cabecera que desea incluir en su lista.
2. LIST_HEADER(headers), que se puede poner en su fuente para recuperar en tiempo de ejecución una lista de todos los archivos de cabecera incluidos

Estoy seguro de que hay una manera fácil de hacer esto, tal vez con p0werz de plantillas de Boost, por favor comentar.

A continuación se muestra primero headerlisting.h y, a continuación un programa de ejemplo que contiene dos cabeceras de ejemplo y un archivo de origen main (). Esto funciona en Linux con g ++, espero que funcione en Visual Studio también (no se puede probar en este momento).

headerlogic.h

#ifndef __HEADERLOGIC_H__
#define __HEADERLOGIC_H__

// By catchmeifyoutry, 2009-12-08
//  See http://stackoverflow.com/questions/1863995/getting-included-header-file-path-in-vc

#include <vector>
#include <string>

namespace HeaderListing
{

// Recursive templates to store header files, templatized by a header index I.
// Header files will be stored by template specialization, adding new specializations
// for every new header.
//
// The recursive headers depend on the assumption that the for the previous index I-1
// there is a HeaderFile<I-1> defined which contains a method
//   void HeaderFile<I-1>::list_headers(std::vector<std::string> &headers)
// to list all I-1 previous header files.
// The I-th HeaderFile then defines it's own list_header(...) to add one name
// to the list.

// -------------------------------------
// Recursive case
//    By default, list_headers() adds no name to the list, but if this default case
//    is specialized with c-string for name, it will add to the list
template <int I>
class HeaderFile
{
public:
    typedef HeaderFile<I-1> PrevHeader;

    // in the specalization, this will store the name of header file;
    // but if no header with index I is given, name will be NULL by default
    static const char * name;

    // in the recursive case
    static inline void list_headers(std::vector<std::string> &headers)
    {
        PrevHeader::list_headers(headers);
        if (name != NULL) {
            headers.push_back(name);
        }
    }
};
template <int I> const char * HeaderFile<I>::name = NULL;

// -------------------------------------
// Base case
//    Ensures recursion ends, implements dummy list_headers()
template <>
class HeaderFile<-1>
{
public:
    static inline void list_headers(std::vector<std::string> &headers)
    { /* end of recursion, do nothing! */ }
};

}; // namespace HeaderListing

// -------------------------------------
// Macros to add header files

// Add n-th header file name (as a string) to the list
#define ADD_HEADER_FILE_NAME_N(n, file) template <> const char * HeaderListing::HeaderFile<n>::name = __FILE__; \

// Add a given string (e.g. a header filename) to the to the list
//   Uses built-in __COUNTER__ macro to track the current header count.
//   NOTE: it doesn't matter if count was used in between since there can be gaps in between the header indices
#define ADD_HEADER_FILE_NAME(file) ADD_HEADER_FILE_NAME_N(__COUNTER__, file)

// Add the current (header) file to the list
//   Uses the built-in __FILE__ macro.
#define ADD_HEADER_FILE ADD_HEADER_FILE_NAME(__FILE__)

// List all defined header files
//   The "headers" argument should be a std::vector<std::string>
#define LIST_HEADERS(headers) HeaderListing::HeaderFile<__COUNTER__>::list_headers(headers);

#endif // __HEADERLOGIC_H__

Ahora, para el programa de ejemplo:

head1.h

#ifndef __HEAD1__
#define __HEAD1__

#include "headerlisting.h"
ADD_HEADER_FILE

#endif // __HEAD1__

head2.h

#ifndef __HEAD2__
#define __HEAD2__

#include "headerlisting.h"
ADD_HEADER_FILE

#endif // __HEAD2__

headertest.cpp

#include <iostream>
#include <vector>
#include <string>

#include "headerlisting.h"
#include "head1.h" // <-- TRY COMMENTING THESE OUT!
#include "head2.h" // <-- TRY COMMENTING THESE OUT!

using namespace std;

int main()
{
    // list included header files
    vector<string> headers;
    LIST_HEADERS(headers);

    // display included header files
    size_t n = headers.size();
    cout << "Found " << n << " headers" << endl;
    for (size_t h = 0; h < n; ++h)
    {
        cout << "header " << h << " :\t" << headers[h] << endl;
    }

    return 0;
}

La salida generada debe ser similar a esto (si no se excluye la head1.h o head2.h de headertest.cpp, se entiende):

Found 2 headers
header 0 :  head1.h
header 1 :  head2.h

Por favor, dime que esto funciona.