Ottenere il percorso del file di intestazione incluso nel VC ++

Question

Ambiente: sto utilizzando MS-VC ++ 6.0,

• includo un gruppo di file di intestazione con alcuni dati.
• I file di intestazione cambiano spesso, così via ogni cambio a cambiare il percorso impostazione e ri-compilatore
• Un file di registro viene generato in base alla file di intestazione inclusi

• Per il monitoraggio del file di intestazione da il file di log, desidero stampare il percorso del file di intestazione all'interno del registro

• Domanda-1: è sempre l'intestazione percorso del file dall'interno del programma possibile?

• Domanda-2: Sto usando VC ++, ma se E 'possibile in gcc, allora posso facilmente la porta, quindi, per favore fatemelo sapere, se è possibile in qualsiasi altra ambiente come gcc

Answer 1

In VC ++, compilazione con l'opzione /FC metterà intero percorso del file attualmente elaborato nella macro __FILE__.

Che spiegare le modifiche apportate al percorso di inclusione.

dettagli qui.

Answer 2

Certo - all'interno del file di intestazione messo:

static const char *header_path = __FILE__;

.. poi basta stampare la stringa puntata da header_path nel vostro log.

Answer 3

Vuoi dire che avere #include "path/to/header.h", si desidera stampare "path / to / header.h" dal programma stesso?

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

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

Answer 4

È possibile ottenere l'elenco dei file include come questo.

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

esportare i file di make, che crea file e file di DEP .mak. I file include sono elencati nei file DEP.

Per quanto riguarda l'idea di ottenere il percorso completo dei file di includere all'interno del programma in esecuzione. Si potrebbe essere in grado di utilizzare l'uso del modello di oggetti msvc 6, per tirare l'elenco dei includere percorsi di file fuori dal IDE. Una volta che è noto che la lista. Si potrebbe utilizzare il file find, per cercare quella lista di percorsi per i file di inclusione di interesse.

Answer 5

Ok, ecco una soluzione (ora spero ho capito bene).

Si utilizza i modelli ricorsivi, la macro __FILE__, e la macro __COUNTER__. Un file di intestazione speciale headerlisting.h contiene la logica per il modello ricorsione, e comprende due macro utili (più di qualche macro helper)

1. ADD_HEADER_FILE, è sufficiente aggiungere questa linea a tutti i file di intestazione che si desidera includere nella vostra lista.
2. LIST_HEADER(headers), che si può mettere nella vostra fonte per recuperare a tempo di esecuzione un elenco di tutti i file di intestazione inclusi

Sono sicuro che c'è un modo più semplice per fare questo, magari con p0werz template di Boost, si prega di commentare.

Di seguito è riportato prima headerlisting.h, e poi un programma di esempio che contiene due intestazioni di esempio e un file sorgente principale (). Questo funziona su Linux con g ++, spero che funziona in Visual Studio troppo (non si può provare in questo 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__

Ora, per il programma di esempio:

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

L'output generato dovrebbe essere così (se non si esclude l'head1.h o head2.h da headertest.cpp, che è):

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

Ti prego, dimmi questo funziona.