__FILE__ 宏显示完整路径

Question

C 中可用的标准预定义宏 __FILE__ 显示文件的完整路径。有什么方法可以缩短路径并仅获取文件名吗？我的意思是，而不是

/full/path/to/file.c

我看到

to/file.c

或

file.c

Answer 1

使用 basename() 函数，或者，如果您使用的是 Windows，_splitpath()。

#include <libgen.h>

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

还可以在 shell 中尝试 man 3 basename 。

Answer 2

如果您将 CMAKE 与 GNU 编译器一起使用，则此 global 定义可以正常工作：

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

Answer 3

@red1ynx 建议的稍有变化是创建以下宏：

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

在每个 .c(pp) 文件中添加：

SET_THIS_FILE_NAME();

然后您可以引用 THIS_FILE_NAME 而不是 __FILE__：

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

这意味着每个 .c(pp) 文件都会执行一次构造，而不是每次引用宏时执行一次。

它仅限于从 .c(pp) 文件使用，并且无法从头文件中使用。

Answer 4

只是希望稍微改进一下 FILE 宏：

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

这会捕获 / 和 \，就像 Czarek Tomczak 所要求的那样，这在我的混合环境。

Answer 5

我做了一个宏 __FILENAME__ 以避免每次都剪切完整路径。问题是将生成的文件名保存在 cpp 局部变量中。

通过在 .h 文件中定义静态全局变量可以轻松完成此操作。
此定义在包含 .h 的每个 .cpp 文件中给出了单独且独立的变量。
为了成为多线程证明，值得使变量也成为线程本地（TLS）。

一个变量存储文件名（已缩小）。另一个保存 __FILE__ 给出的非剪切值。 h 文件：

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

宏本身调用带有所有逻辑的方法：

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

函数是这样实现的：

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

removePath() 可以用不同的方式实现，但快速和简单的似乎是使用 strrchr：

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

Answer 6

尝试

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

在源文件中的 include 语句之后添加，并添加

#pragma pop_macro("__FILE__")

到源文件的末尾。

Answer 7

这是一个可移植函数，适用于 Linux（路径“/”）和 Windows（“\”和“/”的混合）。
使用 gcc、clang 和

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

标准输出进行编译：

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: 

Answer 8

如果您最终在此页面上寻找一种方法来从您正在发送的二进制文件中删除指向难看的构建位置的绝对源路径，那么下面的内容可能会满足您的需求。

虽然这并不能准确地给出作者所表达的愿望的答案，因为它假设使用 CMake，但它已经非常接近了。遗憾的是，没有人早些时候提到这一点，因为它可以节省我大量的时间。

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

将上述变量设置为 ON 将生成以下格式的构建命令：

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

因此，__FILE__ 宏将解析为 ../../src/path/to /source.c

CMake 文档

注意文档页面上的警告：

使用相对路径（可能不起作用！）。

不能保证在所有情况下都有效，但在我的情况下有效 - CMake 3.13 + gcc 4.5

Answer 9

适用于 Windows 和 *nix 的简短有效答案：

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

Answer 10

在 MSVC 中，将 FILENAME 宏作为 FILENAME=%(FileName)%(Extension) 添加到 C++ 项目的预处理器定义中。恐怕这完全就是一个编译器杀手。不知怎的，它破坏了并行构建。

Answer 11

这是一个适用于没有字符串库的环境（Linux 内核、嵌入式系统等）的解决方案：

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

现在只需使用 FILENAME 而不是 __FILENAME__。是的，这仍然是一个运行时的事情，但它确实有效。

Answer 12

red1ynx 的答案经过调整，甚至更加“臃肿”：

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

如果我们找到反斜杠，我们就会根据反斜杠进行拆分。否则，按正斜杠分割。够简单的。

几乎任何替代方案都会更干净（在我看来，C++ constexpr 实际上是这里的黄金标准）。但是，如果您使用的某些编译器中 __BASE_FILE__ 不可用，这可能会有所帮助。

Answer 13

我认为这比使用 strrchr 函数更好。
strfnchr 将搜索最后一个 delemeter '/' 并从 __FILE__ 获取文件名
您可以使用 __FILE__NAME__ 代替 __FILE__ 来获取没有完整文件路径的文件名。
strrchr 解决方案每次使用都会搜索文件名两次。但这段代码只是搜索1次。
即使 __FILE__ 中没有分隔符“/”，它也能有效地工作。
您可以根据需要将其替换为 \ 来使用它。
使用下面的strrchr源代码改进了strfnchr源代码。我认为它会比 strrchr 更有效。
https://code.woboq.org/userspace/glibc/string/ strrchr.c.html

inline const char* strfnchr(const char* s, int c) {
  const char* found = s;
  while (*(s++)) {
    if (*s == c)
      found = s;
  }
  if (found != s)
    return found + 1;
  return s;
}

#define __FILE_NAME__ strfnchr(__FILE__, '/')

Answer 14

最上面的答案不够好，因为它不是编译时 const 表达式
这是一个非常简单的解决方案：

 #define FILESTEM(x)                                                        \
  std::string_view(x).substr(std::string_view(x).rfind(OS_PATH_SLASH) + 1, \
                             std::string_view(x).rfind('.') -              \
                                 std::string_view(x).rfind(OS_PATH_SLASH) - 1)

它是一个 constexpr，可以在头文件中使用。

Answer 15

#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

Answer 16

该解决方案基于 @RenatoUtsch 答案：

CMake list:

string(LENGTH "${PROJECT_SOURCE_DIR}/" SOURCE_PATH_SIZE)
add_definitions("-DSOURCE_PATH_SIZE=${SOURCE_PATH_SIZE}")
add_definitions("-DSOURCE_PATH=\"${PROJECT_SOURCE_DIR}\"")

C/C++ header

#define __FILENAME__ strstr(__FILE__, SOURCE_PATH) + SOURCE_PATH_SIZE

Answer 17

对于 Windows，请尝试

#include <string.h>

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

使用“\\”而不是“/”。

Answer 18

如果您使用 cmake，这里有一个提示。从：
http://public.kitware.com/pipermail/cmake/2013-January /053117.html

我正在复制提示，因此所有内容都在此页面上：

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

如果您使用 GNU make，我认为您没有理由不能扩展此内容到你自己的 makefile。例如，您可能有这样的行：

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

其中 $(SOURCE_PREFIX) 是您要删除的前缀。

然后使用 __FILENAME__ 代替 __FILE__。

Answer 19

GCC 8 现在具有 -fmacro-prefix-map 和 -ffile-prefix-map 选项：

-fmacro-prefix-map=旧=新

当预处理驻留在目录old中的文件时，展开__FILE__和__BASE_FILE__宏，就像文件驻留在目录new<中一样/em> 相反。这可用于通过使用 . for new 将绝对路径更改为相对路径，这可以导致与位置无关的更可重现的构建。此选项还会影响编译期间的__builtin_FILE()。另请参阅-ffile-prefix-map。

-ffile-prefix-map=旧=新

编译位于old目录中的文件时，记录所有引用
在编译结果中对它们进行处理，就好像文件驻留在
目录new代替。指定该选项相当于
指定所有单独的 -f*-prefix-map 选项。这个可以用
进行与位置无关的可重复构建。参见
-fmacro-prefix-map 和 -fdebug-prefix-map。

为 -ffile-prefix-map (-fdebug-prefix-map) 设置无效路径将中断调试，除非您告诉调试器如何映射回来。 （gdb：设置替换路径，vscode：“sourceFileMap”）。

如果您的目的只是清理__FILE__，则只需使用-fmacro-prefix-map。

例子：
因此，对于我的 Jenkins 版本，我将添加 -ffile-prefix-map=${WORKSPACE}/=/ 和另一个以删除本地开发包安装前缀。

注意 不幸的是，-ffile-prefix-map 和 -fmacro-prefix-map 选项仅在 GCC 8 及以后版本中可用。例如，对于 GCC 5，我们只有 -fdebug-prefix-map，它不会影响 __FILE__。

Answer 20

我刚刚想到了一个很好的解决方案，它可以与源文件和头文件一起使用，非常高效，并且可以在所有平台上的编译时工作，而无需特定于编译器的扩展。此解决方案还保留项目的相对目录结构，因此您知道文件位于哪个文件夹中，并且仅相对于项目的根目录。

这个想法是使用构建工具获取源目录的大小，然后将其添加到 __FILE__ 宏中，完全删除该目录并仅显示从源目录开始的文件名。

以下示例是使用 CMake 实现的，但它没有理由不能与任何其他构建工具一起使用，因为技巧非常简单。

在 CMakeLists.txt 文件中，定义一个宏，其中包含 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}")

在源代码中，定义一个 __FILENAME__ 宏，该宏仅将源路径大小添加到 __FILE__ 宏：

#define __FILENAME__ (__FILE__ + SOURCE_PATH_SIZE)

然后只需使用这个新宏而不是 __FILE__ 宏。这是有效的，因为 __FILE__ 路径始终以 CMake 源目录的路径开头。通过从 __FILE__ 字符串中删除它，预处理器将负责指定正确的文件名，并且它将全部相对于 CMake 项目的根目录。

如果您关心性能，这与使用 __FILE__ 一样高效，因为 __FILE__ 和 SOURCE_PATH_SIZE 都是已知的编译时常量，因此它可以被编译器优化掉。

唯一会失败的地方是，如果您在生成的文件上使用它，并且它们位于非源构建文件夹中。然后，您可能需要使用 CMAKE_BUILD_DIR 变量而不是 CMAKE_SOURCE_DIR 创建另一个宏。

Answer 21

• C++11

• msvc2015u3，gcc5.4，clang3.8.0

• https://github.com/search?q=repo%3Aandry81%2Ftacklelib%20content%3A%22get_file_name_constexpr_offset%22&type=code

   模板 
    内联 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);
    }
  
    模板 <类型名称 T>
    内联 constexpr size_t get_file_name_offset(T (& str)[1])
    {
        返回0；
    }
  

'

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

代码在以下情况下生成编译时间偏移：

• gcc：至少gcc6.1 + -O1

• msvc：将结果放入 constexpr 变量：

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

• clang：坚持不编译时评估

有一个技巧可以强制所有 3 个编译器进行编译时评估，即使在禁用优化的调试配置中：

    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

Answer 22

至少对于 gcc，__FILE__ 的值是编译器命令行上指定的文件路径。如果像这样编译 file.c：

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

__FILE__ 将扩展为 "/full/path/to/file.c"。如果您这样做：

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

那么 __FILE__ 将扩展为 "file.c"。

这可能实用，也可能不实用。

C 标准不要求这种行为。关于 __FILE__ 的全部内容是它扩展为“当前源文件的假定名称（字符串文字）”。

另一种方法是使用 #line 指令。它会覆盖当前行号以及源文件名（可选）。如果您想覆盖文件名但保留行号，请使用 __LINE__ 宏。

例如，您可以将其添加到 file.c 的顶部附近：

#line __LINE__ "file.c"

唯一的问题是它将指定的行号分配给下面行，并且第一行#line 的参数必须是数字序列，因此您不能执行诸如

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

确保 #line 指令中的文件名这样 的操作与文件的实际名称相匹配留作练习。

至少对于 gcc 来说，这也会影响诊断消息中报告的文件名。

Answer 23

这里纯粹是编译时解决方案。它基于以下事实：字符串文字的 sizeof() 返回其长度+1。

#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__)

请随意将条件运算符级联扩展到项目中的最大合理文件名。路径长度并不重要，只要您检查距离字符串末尾足够远即可。

我将看看是否可以通过宏递归获得一个没有硬编码长度的类似宏...

Answer 24

最近的 Clang 编译器有一个 __FILE_NAME__ 宏（请参阅此处）。

Answer 25

对于 Visual Studio，您可以使用（未​​记录/实验性）/d1trimfile 编译器选项。它采用不区分大小写的前缀参数，并且具有在计算此宏时从 __FILE__ 中删除此前缀的效果。

应用 /d1trimfile:"$(SolutionDir)\" 选项可有效地将所有 __FILE__ 计算更改为相对于解决方案目录：

注意：关于 " 之前的尾随 \ 的说明：

转义第一个（$(SolutionDir) 以反斜杠结尾），否则引用将被转义。你需要均匀数量的反斜杠
报价前。

Answer 26

多年来我一直使用与 @Patrick 的答案相同的解决方案。

当完整路径包含符号链接时，它有一个小问题。

更好的解决方案。

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

为什么要使用这个？

• -Wno-builtin-macro-redefine 使重新定义 __FILE__ 宏的编译器警告静音。

  <块引用>

  对于那些不支持此功能的编译器，请参阅下面的稳健方法。

• 从文件路径中删除项目路径是您的真正要求。您不会愿意浪费时间去查找 header.h 文件、src/foo/header.h 或 src/bar/header 在哪里.h.

• 我们应该删除 cmake 配置文件中的 __FILE__ 宏。

  大多数现有代码中都使用该宏。只需重新定义它即可让您自由。

  像gcc这样的编译器从命令行参数预定义了这个宏。完整路径写入由 cmake 生成的 makefile 中。

• 需要 CMAKE_*_FLAGS 中的硬代码。

  在某些较新的版本中，有一些命令可以添加编译器选项或定义，例如 add_definitions() 和 add_compile_definitions()。这些命令将在应用于源文件之前解析 make 函数，例如 subst。这不是我们想要的。

-Wno-builtin-macro-redefine 的稳健方法。

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)

请记住从 set(*_FLAGS ... -D__FILE__=...) 行中删除此编译器选项。

Answer 27

在VC中，使用/FC时，__FILE__扩展为完整路径，没有/FC选项__FILE__扩展文件名。参考： 这里

Answer 28

此行为已在某些编译器中实现，您可以使用以下方法获取编译文件的基本名称：

• GCC: Macro __FILE_NAME__ （自 GCC 12)
• Clang：宏 __FILE_NAME__（自 CLANG 9.0.0 起）
• MSVC：不幸的是，正如此线程，计划不支持此类宏

Answer 29

以下是 C++14 或更高版本中使用编译时计算的解决方案：

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__);

Answer 30

没有编译时方法可以做到这一点。显然，您可以使用 C 运行时在运行时执行此操作，正如其他一些答案所演示的那样，但在编译时，当预处理器启动时，您就不走运了。