inklusive Header-Datei-Pfad in VC ++ Erste

Question

Umwelt: Ich bin mit MS-VC ++ 6.0,

• I umfassen eine Gruppe von Header-Datei mit einige Daten.
• Die Header-Dateien ändern sich oft, usw. jede Änderung wechsle ich den Weg Einstellung und Wieder Compiler
• wird eine Protokolldatei auf dem erzeugten basierend enthalten Header-Dateien

• Für Nachführung der Header-Datei aus die Protokolldatei, ich wünschte, das drucken Header-Datei Pfad innerhalb des Protokolls

• Frage-1: ist immer den Kopf Dateipfad aus dem Programm möglich?

• Frage-2: Ich bin mit VC ++, aber wenn es ist in gcc möglich, dann kann ich leicht Port, so, lass es mich wissen, wenn es möglich ist, in einem anderen Umgebung wie gcc

Answer 1

In VC ++, mit der Option /FC Kompilierung wird die aktuell bearbeiteten Datei gesamten Pfad setzt in der __FILE__ Makro.

Das wird auf den Suchpfad für die Änderungen berücksichtigen.

Einzelheiten hier.

Answer 2

Sicher - innerhalb der Header-Datei Put:

static const char *header_path = __FILE__;

.. dann drucken nur der String, auf den header_path in Ihr Protokoll.

Answer 3

Haben Sie bedeuten, dass #include "path/to/header.h" mit, die Sie drucken möchten "path / to / header.h" aus dem Programm selbst?

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

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

Answer 4

Sie können die Liste der Include bekommen Dateien wie diese.

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

Exportieren Sie die make-Dateien, welche Dateien und DEP-Dateien .mak erstellt. Die Include-Dateien werden in den DEP-Dateien aufgelistet.

In Bezug auf die Idee des Erhaltens den vollständigen Pfad zu den Include-Dateien aus dem laufenden Programm. Man könnte in der Lage verwendet das msvc 6-Objektmodell zu verwenden, um die Liste zu ziehen von Dateipfade aus der IDE enthält. Sobald diese Liste bekannt. Man könnte find Datei verwenden, dass die Liste der Pfade für die Include-Dateien von Interesse zu suchen.

Answer 5

Ok, hier ist eine Lösung (jetzt ich hoffe, dass ich Dich richtig verstanden).

Es verwendet rekursive Vorlagen, die __FILE__ Makro, und das __COUNTER__ Makro. Eine spezielle headerlisting.h Header-Datei enthält die Logik für die Vorlage Rekursion und enthält zwei nützliche Makros (plus einige Helfer Makro)

1. ADD_HEADER_FILE, fügen Sie einfach diese Zeile in jedem Header-Datei Sie in der Liste enthalten sein sollen.
2. LIST_HEADER(headers), die Sie in Ihrer Quelle setzen kann zur Laufzeit eine Liste aller enthaltenen Header-Dateien
abrufen

Ich bin sicher, dass es ein einfacherer Weg, dies zu tun, vielleicht mit Boost-dem Templating p0werz, bitte kommentieren.

Im Folgenden finden Sie erste headerlisting.h, und dann ein Beispielprogramm, das zwei Beispiel-Header und eine main () Quelldatei. Dies funktioniert unter Linux mit g ++, hofft, dass es auch in Visual Studio arbeitet (kann jetzt nicht testen).

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__

Jetzt für das Beispielprogramm:

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

Die erzeugte Ausgabe sollte wie folgt aussehen (wenn Sie nicht über die head1.h oder head2.h von headertest.cpp auszuschließen, das ist):

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

Bitte sagen Sie mir, das funktioniert.