Obtenir inclus chemin du fichier d'en-tête dans VC ++

Question

Environnement: J'utilise MS-VC ++ 6.0,

• j'inclure un groupe de fichier d'en-tête avec certaines données.
• Les fichiers d'en-tête changent souvent, etc. chaque changement que je change le chemin réglage et re-compilateur
• Un fichier journal est généré en fonction du fichiers d'en-tête inclus

• Pour le suivi du fichier d'en-tête de le fichier journal, je souhaite imprimer la Chemin du fichier d'en-tête dans le journal

• Question-1: devient l'en-tête chemin du fichier à l'intérieur du programme possible?

• Question 2: J'utilise VC ++, mais si il est possible de gcc, alors je peux facilement le port, donc, s'il vous plaît laissez-moi savoir, s'il est possible dans tout autre environnement comme gcc

Answer 1

Dans VC ++, la compilation avec l'option /FC mettra l'ensemble du fichier en cours de traitement chemin dans la macro __FILE__.

Cela compte pour vos modifications au chemin d'inclusion.

Détails ici.

Answer 2

Bien sûr - dans le fichier d'en-tête mis:

static const char *header_path = __FILE__;

.. puis juste imprimer la chaîne pointée par header_path dans votre journal.

Answer 3

Voulez-vous dire que d'avoir #include "path/to/header.h", vous voulez imprimer « chemin / vers / header.h » du programme lui-même?

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

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

Answer 4

Vous pouvez obtenir la liste des fichiers à inclure comme celui-ci.

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

exporter les fichiers make, qui crée des fichiers .mak et fichiers .dep. Les fichiers include sont répertoriés dans les fichiers .dep.

Quant à l'idée d'obtenir le chemin complet vers les inclure des fichiers dans le programme en cours. On pourrait être en mesure d'utiliser l'utilisation du modèle d'objet msvc 6, pour tirer la liste des chemins d'inclusion de fichiers sur l'IDE. Une fois que cette liste est connue. On pourrait utiliser le fichier de trouver, pour rechercher cette liste de chemins pour les inclure des fichiers d'intérêt.

Answer 5

Ok, voici une solution (maintenant j'espère que je vous ai bien compris).

Il utilise des modèles récursifs, la macro __FILE__ et la macro __COUNTER__. Un fichier d'en-tête spécial headerlisting.h contient la logique pour la récursion modèle, et comprend deux macros utiles (ainsi que certains de macro d'aide)

1. ADD_HEADER_FILE, il suffit d'ajouter cette ligne à chaque fichier d'en-tête que vous souhaitez inclure dans votre liste.
2. LIST_HEADER(headers), que vous pouvez mettre dans votre source pour récupérer à l'exécution d'une liste de tous les fichiers d'en-tête inclus

Je suis sûr qu'il ya un moyen plus facile de le faire, peut-être avec le templating p0werz Boost, s'il vous plaît commentaire.

est inférieure à l'headerlisting.h, puis un exemple de programme contenant deux têtes d'exemple et un fichier source principale (). Cela fonctionne sous Linux avec g ++, espérons que cela fonctionne dans Visual Studio trop (ne peut pas tester en ce moment).

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__

pour le programme exemple:

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 sortie générée devrait ressembler à ceci (si vous ne l'excluez pas head1.h ou head2.h de headertest.cpp, qui est):

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

S'il vous plaît dites-moi cela fonctionne.