Obtendo o caminho arquivo de cabeçalho incluído no VC ++

Question

Ambiente: Estou usando MS-VC ++ 6.0,

• I incluem um grupo de arquivo de cabeçalho com alguns dados.
• Os arquivos de cabeçalho mudam com freqüência, etc. cada mudança que eu alterar o caminho configuração e re-compilador
• arquivo de log A é gerado com base no arquivos de cabeçalho incluídos

• Para rastreamento do arquivo de cabeçalho de o arquivo de log, quero imprimir o cabeçalho de caminho de arquivo dentro do log

• Pergunta 1: está recebendo o cabeçalho caminho de arquivo de dentro do programa possível?

• Pergunta-2: Eu estou usando VC ++, mas se é possível no gcc, então eu posso facilmente porta, por isso, por favor me avise, se é possível em qualquer outra ambiente como gcc

Answer 1

No VC ++, compilação com o /FC opção irá colocar caminho inteiro do arquivo atualmente processado na macro __FILE__.

Isso vai contabilizar as alterações no caminho de inclusão.

detalhes aqui.

Answer 2

Claro - dentro da put arquivo de cabeçalho:

static const char *header_path = __FILE__;

.. em seguida, basta imprimir a string apontada por header_path em seu log.

Answer 3

Você quer dizer que ter #include "path/to/header.h", que deseja imprimir "path / to / header.h" a partir do próprio programa?

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

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

Answer 4

Você pode obter a lista de arquivos de inclusão assim.

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

exportar os arquivos make, que cria arquivos .MAK e arquivos .dep. Os arquivos incluem são listados nos arquivos .dep.

Quanto à idéia de obter o caminho completo para os arquivos de inclusão de dentro do programa em execução. Um pode ser capaz de usar usar o modelo objeto msvc 6, para puxar a lista de incluir caminhos de arquivo fora do IDE. Uma vez que a lista é conhecida. Pode-se usar arquivo de descoberta, para procurar essa lista de caminhos para os arquivos de inclusão de interesse.

Answer 5

Ok, aqui está uma solução (agora eu espero que eu entendi bem).

Ele usa recursiva modelos, a macro __FILE__, ea macro __COUNTER__. Um arquivo especial cabeçalho headerlisting.h contém a lógica para a recursividade modelo, e inclui duas macros úteis (e mais um pouco de macro helper)

1. ADD_HEADER_FILE, basta adicionar esta linha para cada arquivo de cabeçalho que você deseja incluir em sua lista.
2. LIST_HEADER(headers), que você pode colocar em sua fonte para recuperar em tempo de execução uma lista de todos os arquivos de cabeçalho incluídos

Eu tenho certeza que existe uma maneira mais fácil de fazer isso, talvez com p0werz de templates do Boost, por favor comentário.

A seguir é o primeiro headerlisting.h, e, em seguida, um exemplo de programa que contém dois exemplos de cabeçalhos e um arquivo de origem principal (). Isso funciona em Linux com g ++, espero que funcione no Visual Studio também (não é possível testar agora).

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__

Agora, para o programa de exemplo:

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

A saída gerada deve ficar assim (se você não excluir a head1.h ou head2.h de headertest.cpp, que é):

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

Por favor me diga isso funciona.