Das Makro __FILE__ zeigt den vollständigen Pfad an

Das __FILE__in C verfügbare vordefinierte Standardmakro zeigt den vollständigen Pfad zur Datei an. Gibt es eine Möglichkeit, den Weg zu verkürzen? Ich meine statt

/full/path/to/file.c

Aha

to/file.c

oder

file.c

Versuchen

#include <string.h>

#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)

Verwenden Sie für Windows '\\' anstelle von '/'.

Hier ist ein Tipp, wenn Sie cmake verwenden. Von: http://public.kitware.com/pipermail/cmake/2013-January/053117.html

Ich kopiere den Tipp, damit alles auf dieser Seite steht:

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__FILENAME__='\"$(subst
  ${CMAKE_SOURCE_DIR}/,,$(abspath $<))\"'")

Wenn Sie GNU make verwenden, sehe ich keinen Grund, warum Sie dies nicht auf Ihre eigenen Makefiles ausweiten können. Zum Beispiel könnten Sie eine Zeile wie diese haben:

CXX_FLAGS+=-D__FILENAME__='\"$(subst $(SOURCE_PREFIX)/,,$(abspath $<))\"'"

Wo $(SOURCE_PREFIX)ist das Präfix, das Sie entfernen möchten?

Dann __FILENAME__anstelle von verwenden __FILE__.

Ich habe gerade an eine großartige Lösung gedacht, die sowohl mit Quell- als auch mit Header-Dateien funktioniert, sehr effizient ist und die Kompilierungszeit auf allen Plattformen ohne compilerspezifische Erweiterungen unterstützt. Diese Lösung behält auch die relative Verzeichnisstruktur Ihres Projekts bei, sodass Sie wissen, in welchem ​​Ordner sich die Datei befindet und nur relativ zum Stammverzeichnis Ihres Projekts.

Die Idee ist, die Größe des Quellverzeichnisses mit Ihrem Build-Tool zu ermitteln und es einfach dem __FILE__Makro hinzuzufügen , das Verzeichnis vollständig zu entfernen und nur den Dateinamen anzuzeigen, der in Ihrem Quellverzeichnis beginnt.

Das folgende Beispiel wird mit CMake implementiert, aber es gibt keinen Grund, warum es mit anderen Build-Tools nicht funktionieren würde, da der Trick sehr einfach ist.

Definieren Sie in der Datei CMakeLists.txt ein Makro mit der Länge des Pfads zu Ihrem Projekt in CMake:

# The additional / is important to remove the last character from the path.
# Note that it does not matter if the OS uses / or \, because we are only
# saving the path size.
string(LENGTH "${CMAKE_SOURCE_DIR}/" SOURCE_PATH_SIZE)
add_definitions("-DSOURCE_PATH_SIZE=${SOURCE_PATH_SIZE}")

Definieren Sie in Ihrem Quellcode ein __FILENAME__Makro, das dem Makro nur die Quellpfadgröße hinzufügt __FILE__:

#define __FILENAME__ (__FILE__ + SOURCE_PATH_SIZE)

Verwenden Sie dann einfach dieses neue Makro anstelle des __FILE__Makros. Dies funktioniert, da der __FILE__Pfad immer mit dem Pfad zu Ihrem CMake-Quellverzeichnis beginnt. Durch Entfernen aus der __FILE__Zeichenfolge übernimmt der Präprozessor die Angabe des richtigen Dateinamens und alles relativ zum Stammverzeichnis Ihres CMake-Projekts.

Wenn Sie sich für die Leistung interessieren, ist dies genauso effizient wie die Verwendung __FILE__, da beide __FILE__und SOURCE_PATH_SIZEbekannte Kompilierungszeitkonstanten bekannt sind, sodass sie vom Compiler optimiert werden können.

Der einzige Ort, an dem dies fehlschlagen würde, ist, wenn Sie dies für generierte Dateien verwenden und diese sich in einem Off-Source-Build-Ordner befinden. Dann müssen Sie wahrscheinlich ein anderes Makro mit der CMAKE_BUILD_DIRVariablen anstelle von erstellen CMAKE_SOURCE_DIR.

Zeitlösung hier rein kompilieren. Es basiert auf der Tatsache, dass sizeof()ein String-Literal seine Länge + 1 zurückgibt.

#define STRIPPATH(s)\
    (sizeof(s) > 2 && (s)[sizeof(s)-2] == '/' ? (s) + sizeof(s) - 1 : \
    sizeof(s) > 3 && (s)[sizeof(s)-3] == '/' ? (s) + sizeof(s) - 2 : \
    sizeof(s) > 4 && (s)[sizeof(s)-4] == '/' ? (s) + sizeof(s) - 3 : \
    sizeof(s) > 5 && (s)[sizeof(s)-5] == '/' ? (s) + sizeof(s) - 4 : \
    sizeof(s) > 6 && (s)[sizeof(s)-6] == '/' ? (s) + sizeof(s) - 5 : \
    sizeof(s) > 7 && (s)[sizeof(s)-7] == '/' ? (s) + sizeof(s) - 6 : \
    sizeof(s) > 8 && (s)[sizeof(s)-8] == '/' ? (s) + sizeof(s) - 7 : \
    sizeof(s) > 9 && (s)[sizeof(s)-9] == '/' ? (s) + sizeof(s) - 8 : \
    sizeof(s) > 10 && (s)[sizeof(s)-10] == '/' ? (s) + sizeof(s) - 9 : \
    sizeof(s) > 11 && (s)[sizeof(s)-11] == '/' ? (s) + sizeof(s) - 10 : (s))

#define __JUSTFILE__ STRIPPATH(__FILE__)

Sie können die bedingte Operatorkaskade auch auf den maximal sinnvollen Dateinamen im Projekt erweitern. Die Pfadlänge spielt keine Rolle, solange Sie weit genug vom Ende der Zeichenfolge entfernt prüfen.

Ich werde sehen, ob ich ein ähnliches Makro ohne fest codierte Länge mit Makrorekursion erhalten kann ...

Zumindest für gcc ist der Wert von __FILE__der Dateipfad, wie in der Befehlszeile des Compilers angegeben . Wenn Sie so kompilieren file.c:

gcc -c /full/path/to/file.c

das __FILE__wird sich erweitern auf "/full/path/to/file.c". Wenn Sie stattdessen Folgendes tun:

cd /full/path/to
gcc -c file.c

dann __FILE__wird auf nur erweitert "file.c".

Dies kann praktisch sein oder auch nicht.

Der C-Standard erfordert dieses Verhalten nicht. Alles, worüber es sagt, __FILE__ist, dass es auf "Der vermutete Name der aktuellen Quelldatei (ein Zeichenfolgenliteral)" erweitert wird.

Eine Alternative ist die Verwendung der #lineRichtlinie. Es überschreibt die aktuelle Zeilennummer und optional den Namen der Quelldatei. Wenn Sie den Dateinamen überschreiben möchten, aber die Zeilennummer in Ruhe lassen möchten, verwenden Sie das __LINE__Makro.

Zum Beispiel können Sie dies oben hinzufügen file.c:

#line __LINE__ "file.c"

Das einzige Problem dabei ist, dass die angegebene Zeilennummer der folgenden Zeile zugewiesen wird und das erste Argument #lineeine Ziffernfolge sein muss, damit Sie so etwas nicht tun können

#line (__LINE__-1) "file.c"  // This is invalid

Es #linewird als Übung belassen, sicherzustellen, dass der Dateiname in der Direktive mit dem tatsächlichen Namen der Datei übereinstimmt.

Zumindest für gcc wirkt sich dies auch auf den in Diagnosemeldungen angegebenen Dateinamen aus.

Ein bisschen spät zur Party, aber für GCC schauen Sie sich die -ffile-prefix-map=old=newOption an:

Wenn Sie Dateien kompilieren, die sich im alten Verzeichnis befinden , notieren Sie im Ergebnis der Kompilierung alle Verweise darauf, als ob sich die Dateien stattdessen im neuen Verzeichnis befinden würden . Die Angabe dieser Option entspricht der Angabe aller einzelnen -f*-prefix-mapOptionen. Dies kann verwendet werden, um reproduzierbare Builds zu erstellen, die ortsunabhängig sind. Siehe auch -fmacro-prefix-mapund -fdebug-prefix-map.

Also werde ich für meine Jenkins- Builds ein -ffile-prefix-map=${WORKSPACE}/=/weiteres hinzufügen , um das lokale Entwicklungspaket-Installationspräfix zu entfernen.

HINWEIS Leider ist die -ffile-prefix-mapOption nur ab GCC 8 verfügbar, ebenso wie -fmacro-prefix-mapdas, was meiner Meinung nach den __FILE__Teil ausmacht . Zum Beispiel für GCC 5 haben wir nur das, -fdebug-prefix-mapwas nicht (anscheinend) beeinflusst __FILE__.

• C ++ 11

• msvc2015u3, gcc5.4, clang3.8.0

  template <typename T, size_t S>
  inline constexpr size_t get_file_name_offset(const T (& str)[S], size_t i = S - 1)
  {
      return (str[i] == '/' || str[i] == '\\') ? i + 1 : (i > 0 ? get_file_name_offset(str, i - 1) : 0);
  }
  
  template <typename T>
  inline constexpr size_t get_file_name_offset(T (& str)[1])
  {
      return 0;
  }

  '

  int main()
  {
       printf("%s\n", &__FILE__[get_file_name_offset(__FILE__)]);
  }

Code generiert einen Kompilierungszeitversatz, wenn:

• gcc: mindestens gcc6.1 + -O1

• msvc: Ergebnis in constexpr Variable setzen:

    constexpr auto file = &__FILE__[get_file_name_offset(__FILE__)];
    printf("%s\n", file);

• clang: bleibt bei der Auswertung der Kompilierungszeit bestehen

Es gibt einen Trick, um zu erzwingen, dass alle 3 Compiler die Kompilierungszeitbewertung auch in der Debug-Konfiguration mit deaktivierter Optimierung durchführen:

    namespace utility {

        template <typename T, T v>
        struct const_expr_value
        {
            static constexpr const T value = v;
        };

    }

    #define UTILITY_CONST_EXPR_VALUE(exp) ::utility::const_expr_value<decltype(exp), exp>::value

    int main()
    {
         printf("%s\n", &__FILE__[UTILITY_CONST_EXPR_VALUE(get_file_name_offset(__FILE__))]);
    }

https://godbolt.org/z/u6s8j3

In VC, bei der Verwendung /FC, __FILE__erweitert auf den vollständigen Pfad, ohne die /FCOption __FILE__Dateinamen erweitert. ref: hier

Es gibt keine Möglichkeit zur Kompilierung, um dies zu tun. Natürlich können Sie dies zur Laufzeit mit der C-Laufzeit tun, wie einige der anderen Antworten gezeigt haben, aber zur Kompilierungszeit, wenn der Präprozessor einschaltet, haben Sie kein Glück.

Verwenden Sie die Funktion basename () oder unter Windows _splitpath () .

#include <libgen.h>

#define PRINTFILE() { char buf[] = __FILE__; printf("Filename:  %s\n", basename(buf)); }

Versuchen Sie es auch man 3 basenamein einer Shell.

Wenn Sie CMAKEmit dem GNU-Compiler arbeiten global, funktioniert diese Definition einwandfrei:

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__MY_FILE__='\"$(notdir $(abspath $<))\"'")

Ich verwende seit Jahren dieselbe Lösung mit @Patricks Antwort .

Es gibt ein kleines Problem, wenn der vollständige Pfad eine Symbolverknüpfung enthält.

Bessere Lösung.

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-builtin-macro-redefined -D'__FILE__=\"$(subst $(realpath ${CMAKE_SOURCE_DIR})/,,$(abspath $<))\"'")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-builtin-macro-redefined -D'__FILE__=\"$(subst $(realpath ${CMAKE_SOURCE_DIR})/,,$(abspath $<))\"'")

Warum sollte man das benutzen?

• -Wno-builtin-macro-redefinedum die Compiler-Warnungen für die Neudefinition des __FILE__Makros stummzuschalten.

  Informationen zu Compilern, die dies nicht unterstützen, finden Sie im Abschnitt Robust .

• Das Entfernen des Projektpfads vom Dateipfad ist Ihre eigentliche Anforderung. Sie möchten nicht die Zeit verschwenden, um herauszufinden, wo sich eine header.hDatei befindet, src/foo/header.hoder src/bar/header.h.

• Wir sollten das __FILE__Makro in der cmakeKonfigurationsdatei entfernen.

  Dieses Makro wird in den meisten vorhandenen Codes verwendet. Definieren Sie es einfach neu, um frei zu werden.

  Compiler wie gccdefinieren dieses Makro anhand der Befehlszeilenargumente vor. Und der vollständige Pfad wird in makefiles geschrieben, das von generiert wird cmake.

• Hardcode in CMAKE_*_FLAGSist erforderlich.

  Es gibt einige Befehle zum Hinzufügen von Compileroptionen oder -definitionen in einer neueren Version, wie z . B. add_definitions()und add_compile_definitions(). Diese Befehle analysieren die make-Funktionen wie substzuvor für Quelldateien. Das wollen wir nicht.

Robuster Weg für -Wno-builtin-macro-redefined.

include(CheckCCompilerFlag)
check_c_compiler_flag(-Wno-builtin-macro-redefined SUPPORT_C_WNO_BUILTIN_MACRO_REDEFINED)
if (SUPPORT_C_WNO_BUILTIN_MACRO_REDEFINED)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-builtin-macro-redefined")
endif (SUPPORT_C_WNO_BUILTIN_MACRO_REDEFINED)
include(CheckCXXCompilerFlag)
check_cxx_compiler_flag(-Wno-builtin-macro-redefined SUPPORT_CXX_WNO_BUILTIN_MACRO_REDEFINED)
if (SUPPORT_CXX_WNO_BUILTIN_MACRO_REDEFINED)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-builtin-macro-redefined")
endif (SUPPORT_CXX_WNO_BUILTIN_MACRO_REDEFINED)

Denken Sie daran, diese Compileroption aus der set(*_FLAGS ... -D__FILE__=...)Zeile zu entfernen .

Eine geringfügige Abweichung von dem, was @ red1ynx vorgeschlagen hat, wäre das Erstellen des folgenden Makros:

#define SET_THIS_FILE_NAME() \
    static const char* const THIS_FILE_NAME = \
        strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__;

Fügen Sie in jeder Ihrer .c (pp) -Dateien Folgendes hinzu:

SET_THIS_FILE_NAME();

Dann können Sie sich beziehen THIS_FILE_NAMEstatt __FILE__:

printf("%s\n", THIS_FILE_NAME);

Dies bedeutet, dass die Konstruktion einmal pro .c (pp) -Datei ausgeführt wird, anstatt jedes Mal, wenn auf das Makro verwiesen wird.

Es ist auf die Verwendung nur aus .c (pp) -Dateien beschränkt und kann aus Header-Dateien nicht verwendet werden.

Ich habe ein Makro erstellt __FILENAME__, das es vermeidet, jedes Mal den vollen Pfad zu schneiden. Das Problem besteht darin, den resultierenden Dateinamen in einer cpp-lokalen Variablen zu speichern.

Dies kann einfach durch Definieren einer statischen globalen Variablen in der .h- Datei erfolgen. Diese Definition enthält separate und unabhängige Variablen in jeder CPP- Datei, die die .h- Datei enthält . Um ein Multithreading-Proof zu sein, lohnt es sich, die Variablen auch threadlokal (TLS) zu machen.

Eine Variable speichert den Dateinamen (verkleinert). Ein anderer enthält den nicht geschnittenen Wert, __FILE__der angegeben wurde. Die h-Datei:

static __declspec( thread ) const char* fileAndThreadLocal_strFilePath = NULL;
static __declspec( thread ) const char* fileAndThreadLocal_strFileName = NULL;

Das Makro selbst ruft eine Methode mit der gesamten Logik auf:

#define __FILENAME__ \
    GetSourceFileName(__FILE__, fileAndThreadLocal_strFilePath, fileAndThreadLocal_strFileName)

Und die Funktion wird folgendermaßen implementiert:

const char* GetSourceFileName(const char* strFilePath, 
                              const char*& rstrFilePathHolder, 
                              const char*& rstrFileNameHolder)
{
    if(strFilePath != rstrFilePathHolder)
    {
        // 
        // This if works in 2 cases: 
        // - when first time called in the cpp (ordinary case) or
        // - when the macro __FILENAME__ is used in both h and cpp files 
        //   and so the method is consequentially called 
        //     once with strFilePath == "UserPath/HeaderFileThatUsesMyMACRO.h" and 
        //     once with strFilePath == "UserPath/CPPFileThatUsesMyMACRO.cpp"
        //
        rstrFileNameHolder = removePath(strFilePath);
        rstrFilePathHolder = strFilePath;
    }
    return rstrFileNameHolder;
}

Das removePath () kann auf verschiedene Arten implementiert werden, aber das schnelle und einfache scheint mit strrchr zu sein:

const char* removePath(const char* path)
{
    const char* pDelimeter = strrchr (path, '\\');
    if (pDelimeter)
        path = pDelimeter+1;

    pDelimeter = strrchr (path, '/');
    if (pDelimeter)
        path = pDelimeter+1;

    return path;
}

Der aktuelle Clang-Compiler verfügt über ein __FILE_NAME__Makro (siehe hier ).

Ich hoffe nur, das FILE-Makro ein wenig zu verbessern:

#define FILE (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)

Dies fängt / und \, wie Czarek Tomczak es verlangt hat, und dies funktioniert großartig in meiner gemischten Umgebung.

Versuchen

#pragma push_macro("__FILE__")
#define __FILE__ "foobar.c"

nach den include-Anweisungen in Ihre Quelldatei und fügen Sie hinzu

#pragma pop_macro("__FILE__")

am Ende Ihrer Quelldatei.

Hier ist eine tragbare Funktion, die sowohl für Linux (Pfad '/') als auch für Windows (Mischung aus '\' und '/') funktioniert.
Kompiliert mit gcc, clang und vs.

#include <string.h>
#include <stdio.h>

const char* GetFileName(const char *path)
{
    const char *name = NULL, *tmp = NULL;
    if (path && *path) {
        name = strrchr(path, '/');
        tmp = strrchr(path, '\\');
        if (tmp) {
             return name && name > tmp ? name + 1 : tmp + 1;
        }
    }
    return name ? name + 1 : path;
}

int main() {
    const char *name = NULL, *path = NULL;

    path = __FILE__;
    name = GetFileName(path);
    printf("path: %s, filename: %s\n", path, name);

    path ="/tmp/device.log";
    name = GetFileName(path);
    printf("path: %s, filename: %s\n", path, name);

    path = "C:\\Downloads\\crisis.avi";
    name = GetFileName(path);
    printf("path: %s, filename: %s\n", path, name);

    path = "C:\\Downloads/nda.pdf";
    name = GetFileName(path);
    printf("path: %s, filename: %s\n", path, name);

    path = "C:/Downloads\\word.doc";
    name = GetFileName(path);
    printf("path: %s, filename: %s\n", path, name);

    path = NULL;
    name = GetFileName(NULL);
    printf("path: %s, filename: %s\n", path, name);

    path = "";
    name = GetFileName("");
    printf("path: %s, filename: %s\n", path, name);

    return 0;
}

Standardausgabe:

path: test.c, filename: test.c
path: /tmp/device.log, filename: device.log
path: C:\Downloads\crisis.avi, filename: crisis.avi
path: C:\Downloads/nda.pdf, filename: nda.pdf
path: C:/Downloads\word.doc, filename: word.doc
path: (null), filename: (null)
path: , filename: 

Hier ist die Lösung, die die Berechnung der Kompilierungszeit verwendet:

constexpr auto* getFileName(const char* const path)
{
    const auto* startPosition = path;
    for (const auto* currentCharacter = path;*currentCharacter != '\0'; ++currentCharacter)
    {
        if (*currentCharacter == '\\' || *currentCharacter == '/')
        {
            startPosition = currentCharacter;
        }
    }

    if (startPosition != path)
    {
        ++startPosition;
    }

    return startPosition;
}

std::cout << getFileName(__FILE__);

Wenn Sie auf dieser Seite nach einer Möglichkeit gesucht haben, den absoluten Quellpfad, der auf einen hässlichen Build-Speicherort verweist, aus der von Ihnen gelieferten Binärdatei zu entfernen, entspricht dies möglicherweise Ihren Anforderungen.

Obwohl dies nicht genau die Antwort liefert, die der Autor gewünscht hat , da es die Verwendung von CMake voraussetzt , kommt es ziemlich nahe. Schade, dass dies zuvor von niemandem erwähnt wurde, da es mir viel Zeit gespart hätte.

OPTION(CMAKE_USE_RELATIVE_PATHS "If true, cmake will use relative paths" ON)

Wenn Sie die obige Variable auf setzen, ONwird ein Build-Befehl im folgenden Format generiert:

cd /ugly/absolute/path/to/project/build/src && 
    gcc <.. other flags ..> -c ../../src/path/to/source.c

Infolgedessen wird das __FILE__Makro in aufgelöst../../src/path/to/source.c

CMake-Dokumentation

Beachten Sie jedoch die Warnung auf der Dokumentationsseite:

Verwenden Sie relative Pfade (funktioniert möglicherweise nicht!).

Es ist nicht garantiert, dass es in allen Fällen funktioniert, aber es funktioniert in meinem - CMake 3.13 + gcc 4.5

Da Sie GCC verwenden, können Sie Vorteil nehmen von

__BASE_FILE__Dieses Makro wird auf den Namen der Haupteingabedatei in Form einer C-String-Konstante erweitert. Dies ist die Quelldatei, die in der Befehlszeile des Präprozessors oder C-Compilers angegeben wurde

und steuern Sie dann, wie Sie den Dateinamen anzeigen möchten, indem Sie die Darstellung der Quelldatei (vollständiger Pfad / relativer Pfad / Basisname) zur Kompilierungszeit ändern.

Hier ist eine Lösung, die für Umgebungen funktioniert, in denen die Zeichenfolgenbibliothek nicht vorhanden ist (Linux-Kernel, eingebettete Systeme usw.):

#define FILENAME ({ \
    const char* filename_start = __FILE__; \
    const char* filename = filename_start; \
    while(*filename != '\0') \
        filename++; \
    while((filename != filename_start) && (*(filename - 1) != '/')) \
        filename--; \
    filename; })

Jetzt einfach FILENAMEanstelle von verwenden __FILENAME__. Ja, es ist immer noch eine Laufzeitsache, aber es funktioniert.

#include <algorithm>
#include <string>
using namespace std;
string f( __FILE__ );
f = string( (find(f.rbegin(), f.rend(), '/')+1).base() + 1, f.end() );

// searches for the '/' from the back, transfers the reverse iterator 
// into a forward iterator and constructs a new sting with both

Eine kurze, funktionierende Antwort für Windows und * nix:

#define __FILENAME__ std::max<const char*>(__FILE__,\
    std::max(strrchr(__FILE__, '\\')+1, strrchr(__FILE__, '/')+1))