__FILE__ macro hiển thị đường dẫn đầy đủ

Macro được xác định trước tiêu chuẩn __FILE__có sẵn trong C hiển thị đường dẫn đầy đủ đến tệp. Có cách nào để rút ngắn con đường? Ý tôi là thay vì

/full/path/to/file.c

tôi hiểu rồi

to/file.c

hoặc là

file.c

Thử

#include <string.h>

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

Đối với Windows, sử dụng '\\' thay vì '/'.

Đây là một mẹo nếu bạn đang sử dụng cmake. Từ: http://public.kitware.com/pipermail/cmake/2013-Janemony/053117.html

Tôi đang sao chép mẹo để tất cả trên trang này:

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

Nếu bạn đang sử dụng GNU make, tôi thấy không có lý do gì bạn không thể mở rộng điều này sang các tệp tạo của riêng bạn. Ví dụ: bạn có thể có một dòng như thế này:

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

đâu $(SOURCE_PREFIX)là tiền tố mà bạn muốn loại bỏ.

Sau đó sử dụng __FILENAME__thay thế __FILE__.

Tôi vừa nghĩ ra một giải pháp tuyệt vời cho việc này hoạt động với cả tệp nguồn và tệp tiêu đề, rất hiệu quả và hoạt động trên thời gian biên dịch trong tất cả các nền tảng mà không cần các tiện ích mở rộng dành riêng cho trình biên dịch. Giải pháp này cũng bảo tồn cấu trúc thư mục tương đối của dự án của bạn, vì vậy bạn biết tệp nằm trong thư mục nào và chỉ liên quan đến thư mục gốc của dự án.

Ý tưởng là lấy kích thước của thư mục nguồn bằng công cụ xây dựng của bạn và chỉ cần thêm nó vào __FILE__macro, loại bỏ hoàn toàn thư mục và chỉ hiển thị tên tệp bắt đầu từ thư mục nguồn của bạn.

Ví dụ sau được triển khai bằng CMake, nhưng không có lý do gì nó không hoạt động với bất kỳ công cụ xây dựng nào khác, vì thủ thuật này rất đơn giản.

Trên tệp CMakeLists.txt, xác định một macro có độ dài đường dẫn đến dự án của bạn trên 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}")

Trên mã nguồn của bạn, xác định một __FILENAME__macro chỉ thêm kích thước đường dẫn nguồn vào __FILE__macro:

#define __FILENAME__ (__FILE__ + SOURCE_PATH_SIZE)

Sau đó, chỉ cần sử dụng macro mới này thay vì __FILE__macro. Điều này hoạt động vì __FILE__đường dẫn sẽ luôn bắt đầu với đường dẫn đến thư mục nguồn CMake của bạn. Bằng cách loại bỏ nó khỏi __FILE__chuỗi, bộ xử lý trước sẽ đảm nhiệm việc chỉ định tên tệp chính xác và tất cả sẽ liên quan đến thư mục gốc của dự án CMake của bạn.

Nếu bạn quan tâm đến hiệu suất, điều này cũng hiệu quả như việc sử dụng __FILE__, bởi vì cả hai __FILE__và SOURCE_PATH_SIZEđược biết là hằng số thời gian biên dịch, do đó nó có thể được tối ưu hóa bởi trình biên dịch.

Nơi duy nhất thất bại là nếu bạn đang sử dụng tệp này trên các tệp được tạo và chúng nằm trong thư mục xây dựng ngoài nguồn. Sau đó, có lẽ bạn sẽ phải tạo một macro khác bằng cách sử dụng CMAKE_BUILD_DIRbiến thay vì CMAKE_SOURCE_DIR.

Hoàn toàn biên dịch giải pháp thời gian ở đây. Nó dựa trên thực tế là sizeof()một chuỗi ký tự trả về độ dài của nó + 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__)

Vui lòng mở rộng tầng toán tử có điều kiện đến tên tệp hợp lý tối đa trong dự án. Độ dài đường dẫn không quan trọng, miễn là bạn kiểm tra đủ xa từ cuối chuỗi.

Tôi sẽ xem liệu tôi có thể có được một macro tương tự không có độ dài được mã hóa cứng với đệ quy macro không ...

Ít nhất là đối với gcc, giá trị của __FILE__là đường dẫn tệp như được chỉ định trên dòng lệnh của trình biên dịch . Nếu bạn biên dịch file.cnhư thế này:

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

những __FILE__sẽ mở rộng tới "/full/path/to/file.c". Nếu bạn thay vào đó làm điều này:

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

sau đó __FILE__sẽ mở rộng ra chỉ "file.c".

Điều này có thể hoặc không thể thực tế.

Tiêu chuẩn C không yêu cầu hành vi này. Tất cả những gì nó nói __FILE__là nó mở rộng thành "Tên giả định của nguồn hiện tại fi le (một chuỗi ký tự theo nghĩa đen)".

Một cách khác là sử dụng #linechỉ thị. Nó ghi đè số dòng hiện tại và tùy chọn tên tệp nguồn. Nếu bạn muốn ghi đè tên tệp nhưng chỉ để lại số dòng, hãy sử dụng __LINE__macro.

Ví dụ: bạn có thể thêm phần này ở gần đầu file.c:

#line __LINE__ "file.c"

Vấn đề duy nhất với điều này là nó gán số dòng được chỉ định cho dòng sau và đối số đầu tiên #linephải là một chuỗi số để bạn không thể làm gì đó như

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

Đảm bảo rằng tên tệp trong lệnh #linekhớp với tên thực của tệp được để lại dưới dạng bài tập.

Ít nhất là đối với gcc, điều này cũng sẽ ảnh hưởng đến tên tệp được báo cáo trong các thông báo chẩn đoán.

Đến bữa tiệc muộn một chút, nhưng với GCC, hãy xem -ffile-prefix-map=old=newtùy chọn:

Khi biên dịch các tệp nằm trong thư mục cũ , hãy ghi lại bất kỳ tham chiếu nào đến chúng trong kết quả biên dịch như thể các tệp nằm trong thư mục mới thay thế. Chỉ định tùy chọn này tương đương với chỉ định tất cả các -f*-prefix-maptùy chọn riêng lẻ . Điều này có thể được sử dụng để làm cho các bản dựng có thể lặp lại độc lập với vị trí. Xem thêm -fmacro-prefix-mapvà -fdebug-prefix-map.

Vì vậy, đối với các bản dựng Jenkins của tôi, tôi sẽ thêm -ffile-prefix-map=${WORKSPACE}/=/và một bản khác để loại bỏ tiền tố cài đặt gói dev cục bộ.

LƯU Ý Thật không may là -ffile-prefix-maptùy chọn chỉ avalable trong GCC 8 trở đi, như là -fmacro-prefix-maptrong đó, tôi nghĩ rằng , hiện các __FILE__phần. Đối với, GCC 5, chúng tôi chỉ có -fdebug-prefix-mapmà không (dường như) ảnh hưởng __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__)]);
  }

Mã tạo ra thời gian biên dịch bù khi:

• gcc: ít nhất là gcc6.1 + -O1

• msvc: đưa kết quả vào biến constexpr:

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

• clang: kiên trì không biên dịch đánh giá thời gian

Có một mẹo để buộc cả 3 trình biên dịch thực hiện đánh giá thời gian ngay cả trong cấu hình gỡ lỗi với tối ưu hóa bị vô hiệu hóa:

    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

Trong VC, khi sử dụng /FC, __FILE__mở rộng đến đường dẫn đầy đủ mà không có /FCtùy chọn __FILE__mở rộng tên tệp. ref: tại đây

Không có cách biên dịch thời gian để làm điều này. Rõ ràng bạn có thể thực hiện nó trong thời gian chạy bằng cách sử dụng thời gian chạy C, như một số câu trả lời khác đã chứng minh, nhưng tại thời điểm biên dịch, khi người tiền xử lý bắt đầu, bạn đã hết may mắn.

Sử dụng hàm basename () hoặc, nếu bạn đang ở trên Windows, _splitpath () .

#include <libgen.h>

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

Cũng thử man 3 basenametrong một cái vỏ.

Nếu bạn đang sử dụng CMAKEvới trình biên dịch GNU, globalđịnh nghĩa này hoạt động tốt:

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

Tôi đã sử dụng cùng một giải pháp với câu trả lời của @Patrick trong nhiều năm.

Nó có một vấn đề nhỏ khi đường dẫn đầy đủ chứa liên kết ký hiệu.

Giải pháp tốt hơn.

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 $<))\"'")

Tại sao nên sử dụng cái này?

• -Wno-builtin-macro-redefinedđể tắt tiếng cảnh báo trình biên dịch để xác định lại __FILE__macro.

  Đối với những trình biên dịch không hỗ trợ điều này, hãy tham khảo cách mạnh mẽ dưới đây.

• Tách đường dẫn dự án từ đường dẫn tệp là yêu cầu thực sự của bạn . Bạn sẽ không muốn lãng phí thời gian để tìm ra một header.htập tin, src/foo/header.hhoặc src/bar/header.h.

• Chúng ta nên loại bỏ __FILE__macro trong cmaketập tin cấu hình.

  Macro này được sử dụng trong hầu hết các mã tồn tại. Đơn giản chỉ cần xác định lại nó có thể giải phóng bạn.

  Trình biên dịch như gccxác định trước macro này từ các đối số dòng lệnh. Và đường dẫn đầy đủ được viết bằng makefiles được tạo bởi cmake.

• Mã cứng trong CMAKE_*_FLAGSlà bắt buộc.

  Có một số lệnh để thêm tùy chọn trình biên dịch hoặc định nghĩa trong một số phiên bản gần đây hơn, như add_definitions()và add_compile_definitions(). Các lệnh này sẽ phân tích các hàm tạo như substtrước khi áp dụng cho các tệp nguồn. Đó không phải là chúng tôi muốn.

Cách mạnh mẽ cho -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)

Hãy nhớ loại bỏ tùy chọn trình biên dịch này khỏi set(*_FLAGS ... -D__FILE__=...)dòng.

Một thay đổi nhỏ về những gì @ red1ynx đề xuất sẽ tạo ra macro sau:

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

Trong mỗi tệp .c (pp) của bạn thêm:

SET_THIS_FILE_NAME();

Sau đó, bạn có thể tham khảo THIS_FILE_NAMEthay vì __FILE__:

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

Điều này có nghĩa là việc xây dựng được thực hiện một lần trên mỗi tệp .c (pp) thay vì mỗi lần macro được tham chiếu.

Nó được giới hạn chỉ sử dụng từ các tệp .c (pp) và sẽ không thể sử dụng được từ các tệp tiêu đề.

Tôi đã làm một macro __FILENAME__tránh cắt toàn bộ đường dẫn mỗi lần. Vấn đề là giữ tên tệp kết quả trong một biến cpp-local.

Nó có thể được thực hiện dễ dàng bằng cách định nghĩa một biến toàn cục tĩnh trong tệp .h . Định nghĩa này đưa ra các biến riêng biệt và độc lập trong mỗi tệp .cpp bao gồm .h . Để trở thành một bằng chứng đa luồng, đáng để biến (các) biến cũng thành luồng cục bộ (TLS).

Một biến lưu trữ Tên tệp (thu nhỏ). Một cái khác giữ giá trị không cắt mà __FILE__đã cho. Tập tin h:

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

Bản thân macro gọi phương thức với tất cả logic:

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

Và chức năng được thực hiện theo cách này:

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 () có thể được triển khai theo nhiều cách khác nhau, nhưng dường như nhanh và đơn giản với 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;
}

Trình biên dịch Clang gần đây có một __FILE_NAME__macro (xem tại đây ).

chỉ hy vọng cải thiện macro FILE một chút:

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

cái này bắt / và \, như Czarek Tomczak yêu cầu, và cái này hoạt động rất tốt trong môi trường hỗn hợp của tôi.

Thử

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

sau các câu lệnh bao gồm trong tệp nguồn của bạn và thêm

#pragma pop_macro("__FILE__")

ở cuối tập tin nguồn của bạn

Đây là một chức năng di động hoạt động cho cả Linux (đường dẫn '/') và Windows (kết hợp '\' và '/').
Biên dịch với gcc, clang và 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;
}

Đầu ra tiêu chuẩn:

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: 

Đây là giải pháp sử dụng tính toán thời gian biên dịch:

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

Nếu bạn đã kết thúc trên trang này để tìm cách xóa đường dẫn nguồn tuyệt đối đang chỉ đến vị trí xây dựng xấu xí từ nhị phân mà bạn đang vận chuyển, dưới đây có thể phù hợp với nhu cầu của bạn.

Mặc dù điều này không tạo ra chính xác câu trả lời mà tác giả đã bày tỏ mong muốn của mình vì nó giả định việc sử dụng CMake , nhưng nó đã trở nên khá gần gũi. Thật đáng tiếc điều này đã không được đề cập trước đó bởi bất cứ ai vì nó sẽ giúp tôi tiết kiệm rất nhiều thời gian.

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

Đặt biến ở trên thành ONsẽ tạo lệnh xây dựng theo định dạng:

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

Do đó, __FILE__macro sẽ giải quyết../../src/path/to/source.c

Tài liệu CMake

Cảnh giác với cảnh báo trên trang tài liệu mặc dù:

Sử dụng đường dẫn tương đối (Có thể không hoạt động!).

Nó không được đảm bảo để hoạt động trong mọi trường hợp, nhưng hoạt động trong mỏ của tôi - CMake 3.13 + gcc 4.5

Vì bạn đang sử dụng GCC, bạn có thể tận dụng lợi thế của

__BASE_FILE__Macro này mở rộng thành tên của tệp đầu vào chính, dưới dạng hằng số chuỗi C. Đây là tệp nguồn được chỉ định trên dòng lệnh của trình biên dịch tiền xử lý hoặc trình biên dịch C

và sau đó kiểm soát cách bạn muốn hiển thị tên tệp bằng cách thay đổi biểu diễn tệp nguồn (đường dẫn đầy đủ / đường dẫn tương đối / tên cơ sở) tại thời điểm biên dịch.

Đây là một giải pháp hoạt động cho các môi trường không có thư viện chuỗi (nhân Linux, hệ thống nhúng, v.v.):

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

Bây giờ chỉ cần sử dụng FILENAMEthay vì __FILENAME__. Vâng, nó vẫn là một điều thời gian chạy nhưng nó hoạt động.

#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

Câu trả lời ngắn gọn, hiệu quả cho cả Windows và * nix:

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