Problème lors de l'ajout de std :: filesystem au projet CMake

CHECK_CXX_SYMBOL_EXISTS prend trois arguments, pas deux:

CHECK_CXX_SYMBOL_EXISTS(std::filesystem::path::preferred_separator filesystem cxx17fs)

Vous avez oublié d'indiquer à CMake où chercher les symboles (l'en-tête qui les déclare). p>

Gcc 8.2. est livré avec , il n'est donc pas nécessaire d'enquêter sur la disponibilité. Ensuite, l'option 1 est suffisante, mais nécessite une correction:

set(CMAKE_CXX_STANDARD 17) # no need to manually adjust the CXXFLAGS

add_executable(yourExecutable yourSourceFile.cpp)

target_link_libraries(yourExecutable stdc++fs)

Cela devrait aboutir à la compilation des sources avec -std = c ++ 17 ou - std = gnu ++ 17 et en ajoutant -lstdc ++ fs lors de la liaison.

Modifier: notez que comme @Ashkan l'a souligné dans les commentaires, le paramètre CMAKE_CXX_STANDARD_REQUIRED à true résultats dans une erreur immédiate au moment de la configuration si C ++ 17 n'est pas pris en charge par le compilateur, au lieu d'une erreur de compilation (en raison de l'en-tête manquant) ou au moment du lien (en raison de l'absence bibliothèque partagée). Cela pourrait être souhaitable.

En plus de la réponse de @ lubgr. Je pense qu'un moyen plus complet est également de faire try_compile pour voir que vous pouvez réellement utiliser l'en-tête du système de fichiers. C'est à mon avis mieux car certains compilateurs ne prennent pas encore en charge std :: filesystem. Aussi dans gcc 7.x vous avez le système de fichiers sous l'espace de noms experimental . De cette façon, vous pouvez avoir un try_compile séparé dans la clause else et le détecter.

Voici le cmake associé

#include <filesystem>

namespace fs = std::filesystem;

int main()
{
    fs::path aPath {"../"};

    return 0;
}

Le fichier tests / has_filesystem.cc est très simple

# set everything up for c++ 17 features
set(CMAKE_CXX_STANDARD 17)
# Don't add this line if you will try_compile with boost.
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# test that filesystem header actually is there and works
try_compile(HAS_FS "${CMAKE_BINARY_DIR}/temp" 
"${CMAKE_SOURCE_DIR}/tests/has_filesystem.cc" 
            CMAKE_FLAGS -DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_STANDARD_REQUIRED=ON
            LINK_LIBRARIES stdc++fs)
if(HAS_FS)
    message(STATUS "Compiler has filesystem support")
else()
#   .... You could also try searching for boost::filesystem here.
    message(FATAL_ERROR "Compiler is missing filesystem capabilities")
endif(HAS_FS)

Vous pouvez dans votre clause else try_compile pour boost :: filesystem et passer une directive qui peut être utilisée dans votre fichier source où vous décidez si vous voulez utiliser le système de fichiers c ++ 17 ou boost.

J'ai trouvé un cas où try_compile n'était pas suffisant: lors de l'utilisation du compilateur Intel C ++ ( icpc (ICC) 19.1.1.216 20200306 ) en mode C ++ 17 fonctionnant sous MacOS "Mojave" 10.14.6. Le programme de test recommandé par @Ashkan s'est compilé sans erreur, et il a même fonctionné. Cependant, mon code utilise fs :: path :: filename () à un moment donné et qui a entraîné une erreur de l'éditeur de liens d'exécution ( dyld: lazy symbol binding failed: Symbol not found: ). En d'autres termes: l'en-tête est là, l'implémentation n'est apparemment pas (?). Je n'ai pas étudié cela plus en détail.

La solution est d'utiliser try_run au lieu de try_compile et (dans mon cas) de revenir à boost :: système de fichiers si std :: filesystem n'est pas encore pris en charge.

Voici la section de code CMake appropriée:

// == PROGRAM has_stdfs.cc ==

// Check if std::filesystem is available
// Source: https://stackoverflow.com/a/54290906
// with modifications

#include <filesystem>
namespace fs = std::filesystem;

int main(int argc, char* argv[]) {
    fs::path somepath{ "dir1/dir2/filename.txt" };
    auto fname = somepath.filename();
    return 0;
}

Notez que la variable RUNS_WITH_STDFS n'est pas mise à NO en cas d'échec mais à "FAILED_TO_RUN" qui n'est pas interprétée comme un FALSE Boolean (voir CMake if () docs :

if () True si la constante est 1, ON, YES, TRUE, Y ou a nombre différent de zéro. Faux si la constante est 0, OFF, NO, FALSE, N, IGNORE, NOTFOUND, la chaîne vide ou se termine par le suffixe -NOTFOUND.

j'ai donc dû comparer sa valeur.

Le petit programme de test a également un peu changé par rapport à la solution de @ Ashkan:

try_run(RUNS_WITH_STDFS COMPILES_WITH_STDFS
    "${CMAKE_BINARY_DIR}/try"
    "${CMAKE_SOURCE_DIR}/cmake/has_stdfs.cc"
    CMAKE_FLAGS CMAKE_CXX_STANDARD=17 CMAKE_CXX_STANDARD_REQUIRED=ON
    )
if (RUNS_WITH_STDFS STREQUAL "FAILED_TO_RUN")
    message(STATUS "Using boost::filesystem instead of std::filesystem")
    set(_boost_components ${_boost_components} filesystem system)
    add_definitions(-DUSE_BOOST_FILESYSTEM)
else()
    message(STATUS "std::filesystem supported")
endif()