C语言中可用的标准预定义宏__FILE__显示文件的完整路径。有办法缩短这条路吗?我的意思是
/full/path/to/file.c
我看到
to/file.c
or
file.c
使用basename()函数，或者，如果是在Windows上，使用_splitpath()。
#include <libgen.h>
#define PRINTFILE() { char buf[] = __FILE__; printf("Filename: %s\n", basename(buf)); }
还可以在shell中尝试man 3 basename。
Try
#include <string.h>
#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
对于Windows，使用“\\”而不是“/”。
对@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)文件中使用，不能从头文件中使用。
因为使用的是GCC，所以可以利用
__BASE_FILE__这个宏扩展为主输入文件的名称，以C字符串常量的形式。这是源文件 在预处理器或C编译器的命令行中指定
然后在编译时通过更改源文件表示(完整路径/相对路径/basename)来控制显示文件名的方式。
只是希望改进一下FILE宏:
#定义文件(strrchr(__FILE__， '/') ?strrchr __FILE __, '/') + 1: strrchr __FILE __, '\\') ?strrchr(__FILE__， '\\') + 1: __FILE__)
这捕获/和\，像Czarek Tomczak要求的，这在我的混合环境中工作得很好。
如果您正在使用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 $<))\"'")
如果您正在使用GNU make，我认为没有理由不能将其扩展到您自己的make文件。例如，你可能有这样的一行:
CXX_FLAGS+=-D__FILENAME__='\"$(subst $(SOURCE_PREFIX)/,,$(abspath $<))\"'"
其中$(SOURCE_PREFIX)是要删除的前缀。
然后使用__FILENAME__代替__FILE__。
我做了一个宏__FILENAME__，以避免每次都切割完整路径。问题是将结果文件名保存在cppp -local变量中。
这可以通过在.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;
}
至少对于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__宏。
例如，你可以把它添加到文件的顶部。c:
#line __LINE__ "file.c"
唯一的问题是它将指定的行号赋给下一行，而#line的第一个参数必须是一个数字序列，因此您不能执行类似的操作
#line (__LINE__-1) "file.c" // This is invalid
确保#line指令中的文件名与文件的实际名称匹配作为练习。
至少对于gcc来说，这也会影响诊断消息中报告的文件名。
Try
#pragma push_macro("__FILE__")
#define __FILE__ "foobar.c"
在源文件中的include语句之后，然后添加
#pragma pop_macro("__FILE__")
在源文件的末尾。
我刚刚想到了一个很好的解决方案，它可以同时使用源文件和头文件，非常有效，并且可以在所有平台的编译时工作，没有特定于编译器的扩展。此解决方案还保留了项目的相对目录结构，因此您可以知道文件在哪个文件夹中，并且只相对于项目的根目录。
其思想是用构建工具获取源目录的大小，并将其添加到__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都是已知的编译时常量，因此可以由编译器优化。
唯一会失败的地方是如果你在生成的文件上使用这个，而且它们在一个off-source build文件夹上。然后，您可能必须使用CMAKE_BUILD_DIR变量而不是CMAKE_SOURCE_DIR创建另一个宏。
纯粹的编译时解决方案。它基于这样一个事实:字符串字面量的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__)
请随意将条件操作符级联扩展到项目中最大的合理文件名。路径长度并不重要，只要检查距离字符串的末尾足够远。
我将看看我是否可以得到一个类似的宏，没有硬编码的长度与宏递归…
如果你使用CMAKE和GNU编译器，这个全局定义工作正常:
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__MY_FILE__='\"$(notdir $(abspath $<))\"'")
下面是一个解决方案，适用于没有字符串库的环境(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__。是的，它仍然是一个运行时的东西，但它是有效的。
下面是一个适用于Linux(路径'/')和Windows('\'和'/'混合)的可移植函数。使用gcc, clang和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;
}
标准输出:
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:
下面是使用编译时计算的解决方案:
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__);
GCC 8现在有-fmacro prefix-map和- file-prefix-map选项:
-fmacro-prefix-map = =新老 当预处理位于旧目录下的文件时，展开__FILE__和__BASE_FILE__宏，就好像文件位于新目录下一样。这可用于将绝对路径更改为相对路径。对于new，这可以导致更可重复的构建，这些构建是独立于位置的。该选项还会在编译期间影响__builtin_FILE()。参见- file-prefix-map。
-ffile-prefix-map = =新老 当编译位于旧目录中的文件时，记录所有引用 对他们来说，编译的结果就好像文件就在里面一样 改为新建目录。指定此选项相当于 指定所有单独的-f*-prefix-map选项。可以使用这个 制作独立于位置的可重复构建。另请参阅 -fmacro prefix-map和-fdebug-prefix-map。
为- file-prefix-map (-fdebug-prefix-map)设置无效路径将中断调试，除非你告诉调试器如何映射回去。(gdb: set replace -path, vscode: "sourceFileMap")。
如果你的意图只是清理__FILE__，只需使用-fmacro prefix-map。
例子: 所以对于我的Jenkins构建，我将添加- file-prefix-map=${WORKSPACE}/=/，并删除本地开发包安装前缀。
不幸的是- file-prefix-map和-fmacro prefix-map选项仅在GCC 8以后可用。例如，对于GCC 5，我们只有-fdebug-prefix-map，它不影响__FILE__。
c++ 11 msvc2015u3、gcc5.4 clang3.8.0 模板<typename T, size_t S> (const T (& str)[S]， size_t i = S - 1) ｛ 返回(str[i] == '/' || str[i] == '\\') ?I + 1:(I > 0 ?Get_file_name_offset (str, I - 1): 0); ｝ template <typename T> (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
如果您最终在本页上寻找一种方法，以从您正在交付的二进制文件中删除指向丑陋构建位置的绝对源路径，那么下面可能适合您的需要。
尽管这并没有得到作者所希望的答案，因为它假设使用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中工作
#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
我多年来一直使用@Patrick的答案。
当完整路径包含符号链接时，它有一个小问题。
更好的解决方案。
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 $<))\"'")
为什么要用这个?
-Wno-builtin-macro-redefined to mute the compiler warnings for redefining __FILE__ macro. For those compilers do not support this, refer to the Robust way below. Strip the project path from the file path is your real requirement. You won't like to waste the time to find out where is a header.h file, src/foo/header.h or src/bar/header.h. We should strip the __FILE__ macro in cmake config file. This macro is used in most exists codes. Simply redefine it can set you free. Compilers like gcc predefines this macro from the command line arguments. And the full path is written in makefiles generated by cmake. Hard code in CMAKE_*_FLAGS is required. There is some commands to add compiler options or definitions in some more recently version, like add_definitions() and add_compile_definitions(). These commands will parse the make functions like subst before apply to source files. That is not we want.
重新定义- wno -内置宏的健壮方法。
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)
记住从集合(*_FLAGS…-D__FILE__ =…)。
一个简短的，适用于Windows和*nix的答案:
#define __FILENAME__ std::max<const char*>(__FILE__,\
std::max(strrchr(__FILE__, '\\')+1, strrchr(__FILE__, '/')+1))
red1ynx的答案经过调整，甚至更加“臃肿”:
#define __FILENAME__ \
(strchr(__FILE__, '\\') \
? ((strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)) \
: ((strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)))
如果我们发现反斜杠，我们就分反斜杠。否则，拆分为正斜杠。很简单。
几乎任何替代方案都会更简洁(在我看来，c++ constexpr确实是这里的黄金标准)。然而，如果你正在使用一些__BASE_FILE__不可用的编译器，这可能是有帮助的。
I think this is better than using strrchr function. strfnchr will search last delemeter '/' and get filename from __FILE__ and you can use __FILE__NAME__ instead __FILE__ for get file name without full file path. strrchr solution searching filename twice per use. but this code is just 1 time search. And it works effectively even if there is no seperater '/' in __FILE__. You can use it by replacing it with \ as needed. The source code of strfnchr was improved by using the source code of strrchr below. I think it will work more effectively than 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__, '/')
GCC 12将提供GNU C扩展宏__FILE_NAME__来获取编译文件的基名。
请参阅GCC文档，其中已经包含了这个宏:GCC -common_predefined_macros
GCC线程:Bug 42579 - [PATCH]支持获取文件basename
这个解决方案是基于@RenatoUtsch的答案:
CMake列表:
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
对于Visual Studio，您可以使用/d1trimfile选项。
你可能想把它设置为/d1trimfile:"$(SolutionDir)\":
注意:“”前面加了\的解释:
要转义第一个($(SolutionDir)以反斜杠结束)，否则将转义引号。你需要等量的反斜杠 在引用之前。
在MSVC中，将FILENAME宏作为FILENAME=%(FILENAME)%(扩展名)添加到c++项目的预处理器定义中。恐怕这完全是一个编译器杀手。它在某种程度上打破了并行构建。
上面的答案不够好，因为它不是一个编译时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，可以在头文件中使用。
