c++ 如何在编译时提取没有路径和后缀的源文件名？

jucafojl  于 2023-07-01  发布在  其他
关注(0)|答案(6)|浏览(143)

同时使用gcc和-std=c11以及g和-std=c14。
例如，对于一个名为src/dir/Hello.cxx的文件，它应该扩展为如下内容：

  1. const char basename[] = "Hello";

或

  1. const char basename[] = getStaticBasename(__FILE__);

其中getStaticBasename()是一个宏（对于C源代码）或constexpr函数（对于C++源代码），其结果为“Hello”。
我必须避免在运行时从__FILE__拆分字符串，因为路径和后缀不能以任何方式编译到可执行文件中。
解决方案必须不依赖于boost等大型库。
因为我没有makefile，所以像this这样的解决方案不能在我的情况下使用。
有办法解决吗？
编辑2015-07-02：

  • 我对编译器和链接器的调用方式没有影响（有时通过makefile，有时从命令行，或一些IDE（Eclipse CDT管理的make，Crossworks，Xcode等）。因此，解决方案只需要在代码中。
  • 我的用例是为一个小型日志记录解决方案提供某种“通用区域标识符”。应用程序代码（使用我的日志记录器）应该只包含#include <Joe/Logger.h>，并且在后面对例如LOG_DEBUG(...)我将隐式地使用自动生成的“通用区域标识符”。
  • 我目前的解决方案是，应用程序代码必须声明一个JOE_LOG_FILE_REGION(Hello);（在#include <Joe/Logger.h>之后），然后才能将LOG_DEBUG(...)放入其代码中。
c++

6条答案

按热度按时间
mwecs4sa

mwecs4sa1#

1. gcc内置函数可以在编译时获取全路径的文件名。

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

2. c++11 constexpr也可以在编译时执行此操作。

c++11 constexpr函数只能使用return-statement。
示例：

  1. #include <stdio.h>
  3. constexpr const char* str_end(const char *str) {
  4.     return *str ? str_end(str + 1) : str;
  5. }
  7. constexpr bool str_slant(const char *str) {
  8.     return *str == '/' ? true : (*str ? str_slant(str + 1) : false);
  9. }
  11. constexpr const char* r_slant(const char* str) {
  12.     return *str == '/' ? (str + 1) : r_slant(str - 1);
  13. }
  14. constexpr const char* file_name(const char* str) {
  15.     return str_slant(str) ? r_slant(str_end(str)) : str;
  16. }
  18. int main() {
  19.     constexpr const char *const_file = file_name(__FILE__);
  20.     puts(const_file);
  21.     return 0;
  22. }

源文件名为foo/foo1/foo2/foo3/foo4.cpp
使用g++ -o foo.exe foo/foo1/foo2/foo3/foo4.cpp -std=c++11 --save-temps编译此文件。
你可以看到这个

  1. .file   "foo4.cpp"
  2.         .section        .rodata
  3. .LC0:
  4.         .string "foo/foo1/foo2/foo3/foo4.cpp"
  5.         .text
  6.         .globl  main
  7.         .type   main, @function
  8. main:
  9. .LFB4:
  10.         .cfi_startproc
  11.         pushq   %rbp
  12.         .cfi_def_cfa_offset 16
  13.         .cfi_offset 6, -16
  14.         movq    %rsp, %rbp
  15.         .cfi_def_cfa_register 6
  16.         subq    $16, %rsp
  17.         movq    $.LC0+19, -8(%rbp) 
  18.         movl    $.LC0+19, %edi
  19.         call    puts
  20.         movl    $0, %eax
  21.         leave
  22.         .cfi_def_cfa 7, 8
  23.         ret
  24.         .cfi_endproc
  25. .LFE4:
  26.         .size   main, .-main
  27.         .ident  "GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.3) 4.8.4"
  28.         .section        .note.GNU-stack,"",@progbits

movl $.LC0+19, %edi.LC0 + 19是不带路径和后缀的文件名字符串的地址

3. c++14 constexpr函数可以用一种简单的方法做到这一点

  1. #include <iostream>
  3. constexpr const char* file_name(const char* path) {
  4.     const char* file = path;
  5.     while (*path) {
  6.         if (*path++ == '/') {
  7.             file = path;
  8.         }
  9.     }
  10.     return file;
  11. }
  13. int main() {
  14.     constexpr const char* file = file_name(__FILE__);
  15.     std::cout << file << std::endl;
  16.     return 0;
  17. }

c++14 constexpr函数可以使用循环和局部变量。
file_name函数将在编译时替换为const char *地址。~

展开查看全部
赞(0）分享  回复(0）举报  2023-07-01
7rfyedvj

7rfyedvj2#

在编译时提取基本文件名，而不需要预处理器技巧和外部脚本？#21440;，没有问题。

  1. #include <iostream>
  2. #include <string>
  4. using namespace std;
  6. namespace detail {
  7.     constexpr bool is_path_sep(char c) {
  8.         return c == '/' || c == '\\';
  9.     }
  11.     constexpr const char* strip_path(const char* path)
  12.     {
  13.         auto lastname = path;
  14.         for (auto p = path ; *p ; ++p) {
  15.             if (is_path_sep(*p) && *(p+1)) lastname = p+1;
  16.         }
  17.         return lastname;
  18.     }
  20.     struct basename_impl
  21.     {
  22.         constexpr basename_impl(const char* begin, const char* end)
  23.         : _begin(begin), _end(end)
  24.         {}
  26.         void write(std::ostream& os) const {
  27.             os.write(_begin, _end - _begin);
  28.         }
  30.         std::string as_string() const {
  31.             return std::string(_begin, _end);
  32.         }
  34.         const char* const _begin;
  35.         const char* const _end;
  36.     };
  38.     inline std::ostream& operator<<(std::ostream& os, const basename_impl& bi) {
  39.         bi.write(os);
  40.         return os;
  41.     }
  43.     inline std::string to_string(const basename_impl& bi) {
  44.         return bi.as_string();
  45.     }
  47.     constexpr const char* last_dot_of(const char* p) {
  48.         const char* last_dot = nullptr;
  49.         for ( ; *p ; ++p) {
  50.             if (*p == '.')
  51.                 last_dot = p;
  52.         }
  53.         return last_dot ? last_dot : p;
  54.     }
  55. }
  57. // the filename with extension but no path
  58. constexpr auto filename = detail::strip_path(__FILE__);
  59. constexpr auto basename = detail::basename_impl(filename, detail::last_dot_of(filename));
  61. auto main() -> int
  62. {
  63.     cout << filename << endl;
  64.     cout << basename << endl;
  66.     cout << to_string(basename) << endl;
  68.     return 0;
  69. }
展开查看全部
赞(0）分享  回复(0）举报  2023-07-01
cgyqldqp

cgyqldqp3#

如果从源文件所在的文件夹中运行gcc，您将得到一个与传递绝对路径不同的__FILE__（即通过IDE交给gcc）。

  • gcc test.c -otest.exe给出了__FILE__作为test.c。
  • gcc c:\tmp\test.c -otest.exe给出了__FILE__作为c:\tmp\test.c。

也许从源所在的路径调用gcc就足够了？

编辑

这里有一个“肮脏”但安全的黑客，它在编译时删除了文件扩展名。不是我推荐的东西，但写起来很有趣：）所以就拿它来说吧。它只在C中工作。

  1. #include <stdio.h>
  3. #define EXT_LENGTH (sizeof(".c") - 1) // -1 null term
  5. typedef union
  6. {
  7.   char filename_no_nul [sizeof(__FILE__)-EXT_LENGTH-1]; // -1 null term
  8.   char filename_nul    [sizeof(__FILE__)-EXT_LENGTH];
  9. } remove_ext_t;
  11. int main (void)
  12. {
  13.   const remove_ext_t file = { __FILE__ };
  15.   puts(file.filename_nul);
  17.   return 0;
  18. }

联合体分配一个足够大的成员，以容纳完整路径减去扩展和空终止符。它分配一个足够大的成员，以容纳完整的路径减去扩展，尽管有一个空终止符。
如果成员太小，无法容纳完整的__FILE__，则使用尽可能多的__FILE__进行初始化。这在C中是可以的，但在C++中是不允许的。如果__FILE__包含test.c，联合成员现在将被初始化为包含test，没有空终止符。
然而，在该字符串之后仍然会有尾随的零，因为这种黑客滥用了另一个联合成员已经根据“聚合/联合”初始化规则初始化的事实。该规则强制“聚合”中的任何剩余项被初始化，就好像它们具有静态存储持续时间，即初始化为零。它恰好是空终止符的值。

展开查看全部
赞(0）分享  回复(0）举报  2023-07-01
xuo3flqw

xuo3flqw4#

结果非常简单，只需要#line预处理器指令，例如

  1. #line 0 "Hello"

在文件的顶部，这是，如果所有你想要的是完全隐藏文件名，然后

  1. #line 0 ""

会有用的
如果不想使用Makefile s，可以使用以下命令

  1. file=cfile;
  2. content=$(sed -e "1s/^/#line 0 \"$file\"\n/" example/${file}.c);
  3. echo $content | gcc -xc -O3 -o ${file} -

上面的-xc gcc标志意味着（来自gcc的文档）：
-x：
明确指定下列输入文件的语言（而不是让编译器根据文件名后缀选择默认语言）。此选项适用于以下所有输入文件，直到下一个-x选项。语言的可能值为：

  1. c  c-header  cpp-output
  2.           c++  c++-header  c++-cpp-output
  3.           objective-c  objective-c-header  objective-c-cpp-output
  4.           objective-c++ objective-c++-header objective-c++-cpp-output
  5.           assembler  assembler-with-cpp
  6.           ada
  7.           f77  f77-cpp-input f95  f95-cpp-input
  8.           go
  9.           java

如果你没有任何类型的脚本来帮助你构建源代码，那么我认为就没有办法做到这一点。
另外，从上面引用的gcc文档中可以看出，您可以完全不带任何扩展名地保存文件，然后将@Lundin的 original 解决方案与此结合使用。

  1. gcc -xc -o file filename_without_extension

在这种情况下，__FILE__将扩展为"filename_without_extension"，您将实现您想要的，尽管您需要在它所在的同一目录中编译文件，因为否则它将包含文件的路径。

展开查看全部
赞(0）分享  回复(0）举报  2023-07-01
628mspwn

628mspwn5#

投票最多的解决方案不依赖于回答OP，因为完整的文件路径存储在二进制文件中，并且仅计算和使用指向路径最后部分的指针（从最后一个'/'字符开始）。
请参见@pexeer answer中建议的解决方案的汇编输出：

  1. .LC0:
  2.         .string "/app/example.cpp"
  3. main:
  4.         push    rax
  5.         mov     esi, OFFSET FLAT:.LC0+5
  6.         mov     edi, OFFSET FLAT:_ZSt4cout
  7.         call    std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
  8.         mov     rdi, rax
  9.         call    std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&)
  10.         xor     eax, eax
  11.         pop     rdx
  12.         ret
  13. _GLOBAL__sub_I_main:
  14.         push    rax
  15.         mov     edi, OFFSET FLAT:_ZStL8__ioinit
  16.         call    std::ios_base::Init::Init() [complete object constructor]
  17.         mov     edx, OFFSET FLAT:__dso_handle
  18.         mov     esi, OFFSET FLAT:_ZStL8__ioinit
  19.         pop     rcx
  20.         mov     edi, OFFSET FLAT:_ZNSt8ios_base4InitD1Ev
  21.         jmp     __cxa_atexit

为了避免存储完整的文件路径，您需要类似于以下内容：

  1. #include <iostream>
  2. #include <utility>
  4. constexpr const char* file_name(const char* path) {
  5.     const char* file = path;
  6.     while (*path) {
  7.         if (*path++ == '/') {
  8.             file = path;
  9.         }
  10.     }
  11.     return file;
  12. }
  14. constexpr size_t file_length(const char * path) {
  15.     size_t i = 0;
  16.     const char * file = file_name(path);
  17.     while (*file) { i ++; file++; }
  18.     return i;
  19. }
  21. template<std::size_t... I>
  22. const char * print_impl(std::index_sequence<I...>) {
  23.     static const char file[file_length(__FILE__)+1] = { file_name(__FILE__)[I]...};
  24.     return file;
  25. }
  27. inline const char* print_file() {
  28.     return print_impl(std::make_index_sequence<file_length(__FILE__) + 1>());
  29. }
  31. int main() {
  32.     std::cout<<print_file()<<std::endl;
  33.     return 0;
  34. }

你会得到这个程序集输出（其中没有存储完整的文件路径）：

  1. main:
  2.         push    rax
  3.         mov     esi, OFFSET FLAT:print_impl<0ul, 1ul, 2ul, 3ul, 4ul, 5ul, 6ul, 7ul, 8ul, 9ul, 10ul, 11ul>(std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul, 6ul, 7ul, 8ul, 9ul, 10ul, 11ul>)::file
  4.         mov     edi, OFFSET FLAT:_ZSt4cout
  5.         call    std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
  6.         mov     rdi, rax
  7.         call    std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&)
  8.         xor     eax, eax
  9.         pop     rdx
  10.         ret
  11. _GLOBAL__sub_I_main:
  12.         push    rax
  13.         mov     edi, OFFSET FLAT:_ZStL8__ioinit
  14.         call    std::ios_base::Init::Init() [complete object constructor]
  15.         mov     edx, OFFSET FLAT:__dso_handle
  16.         mov     esi, OFFSET FLAT:_ZStL8__ioinit
  17.         pop     rcx
  18.         mov     edi, OFFSET FLAT:_ZNSt8ios_base4InitD1Ev
  19.         jmp     __cxa_atexit
  20. print_impl<0ul, 1ul, 2ul, 3ul, 4ul, 5ul, 6ul, 7ul, 8ul, 9ul, 10ul, 11ul>(std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul, 6ul, 7ul, 8ul, 9ul, 10ul, 11ul>)::file:
  21.         .string "example.cpp"

示例here
这里的基本思想是构造一个静态初始化的char数组，其中只包含所需的字符串（而不是指向包含完整文件路径的静态char数组的指针）。推导文件长度是很简单的，但却是必需的，因为我们不能在 constexpr 函数中调用strlen。
然后，技巧是使用整数序列作为文件指针数组中的索引（类似于自然声明：const char f[] = {"str"[0], "str"[1], ...}）。整数序列可用于可变参数模板示例化，因此必须在此类上下文中调用它。
GCC将print_impl函数作为符号泄漏（因此它可能比文件的完整路径更大），但它可以在链接器步骤（或使用strip --strip-all /path/to/binary）中剥离

展开查看全部
赞(0）分享  回复(0）举报  2023-07-01
bq8i3lrv

bq8i3lrv6#

不幸的是，似乎每个人都在忙碌着通过代码中的各种神奇方法删除路径中不需要的部分（-->大多数都不起作用）。
在我看来，正确的方法是告诉编译器从宏中更改/删除路径，避免所有修补的需要。使用gcc时，参数名为fmacro-prefix-map。你可以这样使用它：

  1. -fmacro-prefix-map=/path/to/source/=

将“/path/to/source/main.cpp”更改为“main.cpp”
顺便说一下：这也适用于std：：source_location，当然完整路径（未更改）不会存储在结果二进制文件中。

赞(0）分享  回复(0）举报  2023-07-01
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com