__FILE__ makrosu tam yolu gösterir

__FILE__C'de bulunan standart önceden tanımlanmış makro , dosyanın tam yolunu gösterir. Yolu kısaltmanın bir yolu var mı? Demek istediğim

/full/path/to/file.c

anlıyorum

to/file.c

veya

file.c

Deneyin

#include <string.h>

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

Windows için '/' yerine '\\' kullanın.

İşte cmake kullanıyorsanız bir ipucu. Gönderen: http://public.kitware.com/pipermail/cmake/2013-Ocak/053117.html

Bahşişi kopyalarım bu yüzden hepsi bu sayfada

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

GNU marka kullanıyorsanız, bunu kendi markalarınıza genişletemezsiniz. Örneğin, böyle bir satırınız olabilir:

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

$(SOURCE_PREFIX)kaldırmak istediğiniz önek nerede .

Sonra kullanmak __FILENAME__yerine __FILE__.

Sadece kaynak ve başlık dosyaları ile çalışan, çok verimli ve derleyiciye özgü uzantıları olmayan tüm platformlarda derleme zamanında çalışan harika bir çözüm düşündüm. Bu çözüm aynı zamanda projenizin göreli dizin yapısını da korur, böylece dosyanın hangi klasörde olduğunu ve yalnızca projenizin kök dizinine göre olduğunu bilirsiniz.

Fikir, oluşturma aracınızla kaynak dizinin boyutunu almak ve __FILE__makroya eklemek , dizini tamamen kaldırmak ve yalnızca kaynak dizininizden başlayan dosya adını göstermektir.

Aşağıdaki örnek CMake kullanılarak uygulanır, ancak başka bir oluşturma aracıyla çalışmamasının bir nedeni yoktur, çünkü hile çok basittir.

CMakeLists.txt dosyasında, CMake'teki projenize giden yolun uzunluğuna sahip bir makro tanımlayın:

# 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}")

Kaynak kodunuzda, __FILENAME__yalnızca makroya kaynak yolu boyutunu ekleyen bir makro tanımlayın __FILE__:

#define __FILENAME__ (__FILE__ + SOURCE_PATH_SIZE)

Ardından, makro yerine bu yeni makroyu kullanın __FILE__. Bu, __FILE__yol her zaman CMake kaynak dizininizin yolu ile başlayacağı için çalışır . __FILE__Ön işlemcinin dizeden kaldırılmasıyla , doğru dosya adını belirtmeye özen gösterecek ve tümü CMake projenizin köküne göreli olacaktır.

Performansı önemsiyorsanız, bu kullanım kadar verimlidir __FILE__, çünkü hem __FILE__ve hem de SOURCE_PATH_SIZEderleme zamanı sabitleri bilinir, böylece derleyici tarafından optimize edilebilir.

Bunun başarısız olacağı tek yer, bunu oluşturulan dosyalarda kullanıyorsanız ve kaynak dışı bir derleme klasöründeyseniz. Ardından, CMAKE_BUILD_DIRdeğişkeni kullanmak yerine muhtemelen başka bir makro oluşturmanız gerekir CMAKE_SOURCE_DIR.

Zaman çözümünü burada derleyin. sizeof()Bir dizgenin değişmezinin uzunluğunu + 1 döndürmesi gerçeğine dayanır .

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

Koşullu operatör kaskadını projedeki maksimum mantıklı dosya adına genişletmekten çekinmeyin. Dizenin sonundan yeterince kontrol ettiğiniz sürece yol uzunluğu önemli değildir.

Makro özyineleme ile sabit kodlu uzunluğu olmayan benzer bir makro alıp alamayacağımı göreceğim ...

En azından gcc için değeri , derleyicinin komut satırında belirtilen__FILE__ dosya yoludur . Eğer böyle derlerseniz :file.c

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

__FILE__genişleyecektir "/full/path/to/file.c". Bunun yerine bunu yaparsanız:

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

sonra __FILE__sadece genişleyecektir "file.c".

Bu pratik olabilir veya olmayabilir.

C standardı bu davranışı gerektirmez. Tek söylediği şey __FILE__, "Geçerli kaynak dosyasının varsayılan adı (bir karakter dizesi değişmezi)" olarak genişlemesi.

Alternatif olarak #lineyönergeyi kullanmaktır . Geçerli satır numarasını ve isteğe bağlı olarak kaynak dosya adını geçersiz kılar. Dosya adını geçersiz kılmak, ancak satır numarasını yalnız bırakmak istiyorsanız, __LINE__makroyu kullanın .

Örneğin, bunu aşağıdakilerin üst kısmına ekleyebilirsiniz file.c:

#line __LINE__ "file.c"

Bununla ilgili tek sorun, belirtilen satır numarasını aşağıdaki satıra ataması ve ilk argümanın basamak dizisi#line olması gerektiğinden , böyle bir şey yapamazsınız.

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

Yönergedeki dosya adının dosyanın #linegerçek adıyla eşleştiğinden emin olmak alıştırma olarak bırakılır.

En azından gcc için bu, tanılama mesajlarında bildirilen dosya adını da etkiler.

Partiye biraz geç, ancak GCC için -ffile-prefix-map=old=newseçeneğe bir göz atın :

Eski dizinde bulunan dosyaları derlerken , derleme sonucunda bunlara yapılan referansları, dosyalar yeni dizinde bulunuyormuş gibi kaydedin . Bu seçeneğin belirlenmesi, tüm ayrı -f*-prefix-mapseçeneklerin belirlenmesine eşdeğerdir . Bu, konumdan bağımsız yeniden üretilebilir yapılar yapmak için kullanılabilir. Ayrıca bkz . -fmacro-prefix-mapVe -fdebug-prefix-map.

Bu yüzden Jenkins yapılarıma ekleyeceğim -ffile-prefix-map=${WORKSPACE}/=/ve başka bir yerel dev paket yükleme önekini kaldıracağım.

NOT Maalesef -ffile-prefix-mapseçenek olarak, itibaren GCC 8'de sadece avalable olduğunu -fmacro-prefix-map, hangi bence , yaptığı __FILE__parçasını. Diyelim ki GCC 5, sadece -fdebug-prefix-mapetkilemeyen (görünmeyen) elimizde __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__)]);
  }

Kod aşağıdaki durumlarda bir derleme zamanı ofseti oluşturur:

• gcc: en az gcc6.1 + -O1

• msvc: sonucu constexpr değişkenine koy:

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

• clang: Zaman değerlendirmesini derlememeye devam ediyor

3 derleyicinin tümünü, hata ayıklama yapılandırmasında bile devre dışı bırakma optimizasyonu ile zaman değerlendirmesini derlemek için bir hile vardır:

    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

Kullanırken VC yılında /FC, __FILE__olmadan, tam yol genişler /FCseçeneği __FILE__dosya adını genişler. ref: burada

Bunu yapmanın derleme zamanı yok. Açıkçası, diğer cevapların bazılarının gösterdiği gibi, C çalışma zamanını kullanarak çalışma zamanında yapabilirsiniz, ancak derleme zamanında, ön-işlemcinin devreye girmesi, şansınız kalmaz.

Kullanım basename () Windows üzerinde ise, işlev ya, _splitpath () .

#include <libgen.h>

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

Ayrıca man 3 basenamebir kabukta deneyin .

CMAKEGNU derleyicisi ile kullanıyorsanız bu globaltanımlama düzgün çalışır:

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

Yıllardır @Patrick'in cevabı ile aynı çözümü kullanıyorum .

Tam yol sembol bağlantısı içerdiğinde küçük bir sorun vardır.

Daha iyi çözüm.

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

Bunu neden kullanmalıyım?

• -Wno-builtin-macro-redefined__FILE__makrosu yeniden tanımlamak için derleyici uyarılarını sessize almak için .

  Bu derleyiciler bunu desteklemediğinden, aşağıdaki Sağlam yola bakın.

• Proje yolunu dosya yolundan çıkarın gerçek gereksiniminizdir. Bir header.hdosyanın nerede olduğunu bulmak için zaman kaybetmek istemezsiniz src/foo/header.hveya src/bar/header.h.

• Biz şerit gerektiğini __FILE__de makro cmakeyapılandırma dosyası.

  Bu makro, mevcut kodların çoğunda kullanılır. Sadece yeniden tanımlamak sizi serbest bırakabilir.

  Like derleyicileri gccbu makroyu komut satırı argümanlarından önceden tanımlar. Ve tam yol makefiletarafından üretilen s yazılır cmake.

• Sabit kod girilmesi CMAKE_*_FLAGSgerekiyor.

  Bazı son sürümlerde derleyici seçeneklerini veya tanımlarını eklemek için bazı komutlar vardır, add_definitions()ve gibi add_compile_definitions(). Bu komutlar, substkaynak dosyalara uygulanmadan önce make işlevlerini ayrıştırır . Biz istemiyoruz.

Sağlam bir yol -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)

Bu derleyici seçeneğini set(*_FLAGS ... -D__FILE__=...)satırdan kaldırmayı unutmayın .

@ Red1ynx'in önerdiği şeyin küçük bir varyasyonu aşağıdaki makroyu oluşturacaktır:

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

.C (pp) dosyalarınızın her birine şunları ekleyin:

SET_THIS_FILE_NAME();

Sonra THIS_FILE_NAMEbunun yerine başvurabilirsiniz __FILE__:

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

Bu, yapıya, makroya her başvuruda bulunmak yerine .c (pp) dosyası başına bir kez gerçekleştirildiği anlamına gelir.

Yalnızca .c (pp) dosyalarından kullanılmak üzere sınırlıdır ve başlık dosyalarından kullanılamaz.

__FILENAME__Her seferinde tam yol kesmekten kaçınan bir makro yaptım . Sorun, ortaya çıkan dosya adını bir cpp-local değişkeninde tutmaktır.

.H dosyasında statik bir global değişken tanımlayarak kolayca yapılabilir . Bu tanım, her ayrı ve bağımsız değişkenler verir .Cpp içeren dosyanın .h . Çok iş parçacıklı bir kanıt olmak için değişken (ler) i yerel olarak da (TLS) yapmaya değer.

Bir değişken Dosya Adını (küçültülmüş) saklar. Bir diğeri, verilen kesilmemiş değeri tutar __FILE__. H dosyası:

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

Makronun kendisi tüm mantıkla yöntemi çağırır:

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

Ve işlev şu şekilde uygulanır:

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 () farklı şekillerde uygulanabilir, ancak hızlı ve basit, strrchr ile birlikte görünür:

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

Son Clang derleyicisinin bir __FILE_NAME__makrosu vardır ( buraya bakın ).

sadece DOSYA makrosunu biraz geliştirmeyi umuyoruz:

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

bu Czarek Tomczak'ın istediği gibi yakalar ve / ve karışık ortamımda harika çalışır.

Deneyin

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

kaynak dosyanıza ifadeleri ekledikten sonra

#pragma pop_macro("__FILE__")

kaynak dosyanızın sonunda.

Hem Linux (yol '/') hem de Windows ('\' ve '/' karışımı) için çalışan taşınabilir bir işlev.
Gcc, clang ve vs. ile derler

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

Standart çıktı:

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: 

Derleme zamanı hesaplamasını kullanan çözüm:

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

Bu sayfada, gönderim yaptığınız ikili dosyadan çirkin bir yapı konumuna işaret eden mutlak kaynak yolunu kaldırmanın bir yolunu bulduysanız, aşağıda ihtiyaçlarınıza uygun olabilir.

Bu, yazarın CMake'in kullanımını üstlendiği için arzusunu dile getirdiği yanıtı tam olarak vermese de, oldukça yakınlaşıyor. Bana daha fazla zaman kazandıracak gibi bu daha önce kimse tarafından belirtilmemiş yazık.

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

Değişkenin yukarısına ayarlanması ONbiçiminde build komutu oluşturur:

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

Sonuç olarak, __FILE__makro../../src/path/to/source.c

CMake belgeleri

Yine de belgeler sayfasındaki uyarılara dikkat edin:

Göreli yollar kullanın (Çalışmayabilir!).

Her durumda çalışacağı garanti edilmez, ancak madende çalıştı - CMake 3.13 + gcc 4.5

GCC kullandığınız için ,

__BASE_FILE__Bu makro, ana girdi dosyasının adına, C dizesi sabiti biçiminde genişler. Bu, önişlemcinin veya C derleyicisinin komut satırında belirtilen kaynak dosyadır

ve derleme zamanında kaynak dosya sunumunu (tam yol / göreli yol / taban adı) değiştirerek dosya adını nasıl görüntülemek istediğinizi denetleyin.

Dize kitaplığı olmayan ortamlar için çalışan bir çözüm (Linux çekirdeği, gömülü sistemler vb.):

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

Şimdi FILENAMEyerine kullanın __FILENAME__. Evet, hala çalışma zamanı bir şey ama işe yarıyor.

#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

Hem Windows hem de * nix için kısa, çalışan bir cevap:

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