__FICHIER__ macro montre chemin d'accès complet

Essayer

#include <string.h>

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

Pour Windows utiliser '\\' au lieu de '/'.

J'ai juste pensé à une solution à ce qui travaille à la fois la source et les fichiers d'en-tête, est très efficace et fonctionne sur la compilation de toutes les plates-formes sans compilateur extensions spécifiques. Cette solution préserve également la relative structure de répertoire de votre projet, de sorte que vous savez dans quel dossier le fichier est en cours, et seulement par rapport à la racine de votre projet.

L'idée est d'obtenir la taille de la source de répertoire avec votre outil de construction et il suffit de l'ajouter à la __FILE__ macro, la suppression du répertoire entièrement et en indiquant uniquement le nom de fichier commençant à votre répertoire source.

L'exemple suivant est mis en œuvre en utilisant CMake, mais il n'y a pas de raison que ça ne marcherait pas avec tous les autres outils de construction, parce que le truc est très simple.

Sur le CMakeLists.txt fichier, définir une macro qui a la longueur du chemin d'accès à votre projet sur 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}")

Sur votre code source, de définir un __FILENAME__ macro qui ajoute juste la source chemin de la taille de la __FILE__ macro:

#define __FILENAME__ (__FILE__ + SOURCE_PATH_SIZE)

Alors il suffit d'utiliser cette macro au lieu de la __FILE__ macro. Cela fonctionne parce que les __FILE__ chemin commence toujours par le chemin d'accès à votre CMake source dir. En le supprimant de la __FILE__ chaîne le préprocesseur va prendre soin de spécifier le nom de fichier correct et ça va être par rapport à la racine de votre CMake projet.

Si vous vous souciez de la performance, c'est aussi efficace que l'utilisation de __FILE__, parce que les deux __FILE__ et SOURCE_PATH_SIZE sont connus moment de la compilation, de constantes, de sorte qu'il peut être optimisé par le compilateur.

Le seul endroit où ce serait un échec si vous êtes en utilisant ce sur les fichiers générés, et ils sont hors de la source de dossier de création. Ensuite, vous devrez probablement créer une autre macro à l'aide de la CMAKE_BUILD_DIR variable au lieu de CMAKE_SOURCE_DIR.

Au moins pour gcc, la valeur de __FILE__ est le chemin d'accès au fichier comme spécifié sur la ligne de commande du compilateur. Si vous compilez file.c comme ceci:

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

la __FILE__ étendra à "/full/path/to/file.c". Si vous au lieu de faire ceci:

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

puis __FILE__ étendra à juste "file.c".

Cela peut ou peut ne pas être pratique.

Le C standard ne nécessitent pas de ce comportement. Tout ce qu'elle dit à propos de __FILE__ est qu'il s'étend à "La présumée nom du fichier source (une chaîne de caractères littérale)".

Une alternative est d'utiliser le #line directive. Il remplace le numéro de ligne en cours, et éventuellement le nom du fichier source. Si vous voulez remplacer le nom du fichier, mais de laisser le numéro de la ligne seul, utiliser le __LINE__ macro.

Par exemple, vous pouvez ajouter ceci à proximité du haut de file.c:

#line __LINE__ "file.c"

Le seul problème avec ceci est qu'il attribue le numéro de ligne spécifié à l' suivantes ligne, et le premier argument de #line doit être un chiffres-séquence de sorte que vous ne pouvez pas faire quelque chose comme

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

Veiller à ce que le nom de fichier dans la #line directive correspond au nom du fichier est laissée en exercice.

Au moins pour gcc, cela affectera également le nom de fichier signalés dans les messages de diagnostic.

Utiliser le basename() fonction, ou, si vous êtes sur Windows, _splitpath().

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

Aussi essayer man 3 basename dans un shell.

Si vous utilisez CMAKE avec le compilateur GNU ce global définir fonctionne très bien:

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

J'ai fait une macro __FILENAME__ qui évite de couper chemin d'accès complet à chaque fois. La question est de tenir le nom de fichier résultant dans un rpc-variable locale.

Il peut être facilement fait en définissant une variable globale statique dans .h fichier.
Cette définition donne distincte et indépendante des variables dans chaque .rpc fichier qui contient la .h.
Afin d'être un multithreading-la preuve, il vaut la peine de faire de la variable(s) fil local (TLS).

Une variable stocke le Nom du Fichier (réduits). Un autre tient la non-coupé valeur __FILE__ a donné. Le h de fichier:

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

La macro elle-même appelle la méthode avec toute la logique:

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

Et la fonction est mise en œuvre de cette façon:

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

La removePath() peut être mis en œuvre de différentes façons, mais la rapide et simple semble être avec 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;
}

• C++11

• msvc2015u3,gcc5.4,clang3.8.0

  template <size_t S>
  inline constexpr size_t get_file_name_offset(const char (& 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 <size_t S>
  inline constexpr size_t get_file_name_offset(const wchar_t (& str)[S], size_t i = S - 1)
  {
  return (str[i] == L'/' || str[i] == L'\\') ? i + 1 : (i > 0 ? get_file_name_offset(str, i - 1) : 0);
  }
  template <size_t S>
  inline constexpr size_t get_file_name_offset(const char16_t (& str)[S], size_t i = S - 1)
  {
  return (str[i] == u'/' || str[i] == u'\\') ? i + 1 : (i > 0 ? get_file_name_offset(str, i - 1) : 0);
  }
  template <size_t S>
  inline constexpr size_t get_file_name_offset(const char32_t (& str)[S], size_t i = S - 1)
  {
  return (str[i] == U'/' || str[i] == U'\\') ? 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__)]);
  }

Code génère un moment de la compilation d'une compensation lorsqu':

• gcc: au moins gcc6.1 + -O1

• msvc: mettre le résultat dans constexpr variable:

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

• clang: persiste sur les pas de temps de compilation de l'évaluation

Il existe une astuce pour forcer tous les 3 compilateurs n'moment de la compilation, de l'évaluation, même dans la configuration de débogage pour les personnes handicapées de l'optimisation:

    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/P1y3ZI

Essayer

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

après l'inclure des instructions dans votre fichier source et d'ajouter

#pragma pop_macro("__FILE__")

à la fin de votre fichier source.

Si vous vous retrouviez sur cette page à la recherche d'un moyen de supprimer la source absolue chemin qui pointe vers laid emplacement de génération de l'exécutable qui vous sont expédition, ci-dessous peut répondre à vos besoins.

Bien que ce ne produisent pas exactement la réponse que l'auteur a exprimé son souhait pour puisqu'elle suppose l'utilisation de CMake, il devient très proche. C'est dommage, ce n'était pas mentionné plus haut par quelqu'un comme elle m'aurait sauvé des charges de temps.

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

Au dessus de variable à ON va générer commande de construction dans le format:

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

Comme un résultat, __FILE__ macro se résoudre à ../../src/path/to/source.c

La documentation de CMake

Méfiez-vous de l'avertissement sur la page de documentation si:

Utiliser des chemins relatifs (Peut ne pas fonctionner!).

Il n'est pas garanti dans tous les cas, mais il a travaillé dans la mine de CMake 3.13 + gcc 4.5

Voici une solution qui fonctionne pour les environnements qui n'ont pas la chaîne de la bibliothèque (noyau Linux, systèmes embarqués, etc):

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

Maintenant seulement utiliser FILENAME au lieu de __FILENAME__. Oui, c'est toujours un runtime chose, mais il fonctionne.

#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