compiler SFML avec cmake sous visual studio

Version imprimable

Bonjour à tous,
toujours sur le tuto de c++ moderne sur zds j'essaye de compiler SFML via cmake pour le rendre compatible avec visual studio 2019 comme indiqué ici:
https://www.sfml-dev.org/tutorials/2...h-cmake-fr.php,

j'ai essayé en utilisant visual studio (je précise au passage que je n'ai jamais utilisé cmake) j'ai donc ouvert un projet cmake en indiquant à visual studio l'emplacement du fichier CMakeLists.txt .
à partir de la, impossible de compiler (VC me demande de choisir un élément de démarrage valide) la seule chose que je puisse apparemment faire, c'est générer le cache cmake ce qui me donne l'erreur suivante:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
Gravité	Code	Description	Projet	Fichier	Ligne	État de la suppression
Erreur		CMake Error at C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.17/Modules/CMakeTestCCompiler.cmake:60 (message):
  The C compiler
 
    "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.26.28801/bin/HostX64/x64/cl.exe"
 
  is not able to compile a simple test program.
 
  It fails with the following output:
 
    Change Dir: C:/Users/aperi/c++ libraries/SFML-2.5.1-sources/SFML-2.5.1/out/build/x64-Debug (par défaut)/CMakeFiles/CMakeTmp
 
    Run Build Command(s):C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/Ninja/ninja.exe cmTC_d5ac8 && [1/2] Building C object CMakeFiles\cmTC_d5ac8.dir\testCCompiler.c.obj
    [2/2] Linking C executable cmTC_d5ac8.exe
    FAILED: cmTC_d5ac8.exe 
    cmd.exe /C "cd . && "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe" -E vs_link_exe --intdir=CMakeFiles\cmTC_d5ac8.dir --rc=C:\PROGRA~2\WINDOW~4\10\bin\100183~1.0\x64\rc.exe --mt=C:\PROGRA~2\WINDOW~4\10\bin\100183~1.0\x64\mt.exe --manifests  -- C:\PROGRA~2\MICROS~1\2019\COMMUN~1\VC\Tools\MSVC\1426~1.288\bin\Hostx64\x64\link.exe /nologo CMakeFiles\cmTC_d5ac8.dir\testCCompiler.c.obj  /out:cmTC_d5ac8.exe /implib:cmTC_d5ac8.lib /pdb:cmTC_d5ac8.pdb /version:0.0  /machine:x64  /debug /INCREMENTAL /subsystem:console  kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib && cd ."
    LINK Pass 1: command "C:\PROGRA~2\MICROS~1\2019\COMMUN~1\VC\Tools\MSVC\1426~1.288\bin\Hostx64\x64\link.exe /nologo CMakeFiles\cmTC_d5ac8.dir\testCCompiler.c.obj /out:cmTC_d5ac8.exe /implib:cmTC_d5ac8.lib /pdb:cmTC_d5ac8.pdb /version:0.0 /machine:x64 /debug /INCREMENTAL /subsystem:console kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib /MANIFEST /MANIFESTFILE:CMakeFiles\cmTC_d5ac8.dir/intermediate.manifest CMakeFiles\cmTC_d5ac8.dir/manifest.res" failed (exit code 1104) with the following output:
    LINK : fatal error LNK1104: impossible d'ouvrir le fichier 'kernel32.lib'
    ninja: build stopped: subcommand failed.
 
 
 
 
 
  CMake will not be able to correctly generate this project.		C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.17/Modules/CMakeTestCCompiler.cmake	60

pour résumer, je n'ai aucune idée de ce que cmake essaye de faire ni de pourquoi il n'y arrive pas!
merci d'avance!

Salut,

Alors, il va falloir s'assurer que les bonnes choses ont été faites, et on va essayer de le faire dans l'ordre ;)

La toute premère chose qu'il faut vérifier est: es tu sur d'avoir téléchargé la bonne version de la bibliothèque :question:

Il faut, en effet, savoir que, si on trouve jusqu'à neuf versions différentes de la SFML disponible sur la page de téléchargements, ce n'est pas sans raison:

C'est parce que ce que l'on appelle l' ABI (Application Binary Interface), la manière dont les différents éléments du programme discutent entre eux, n'est -- à ce jour -- pas (encore?) "standardisée".

Du coup, dés que tu change de compilateur, ou même, dés que tu change la version du compilateur utilisé, et parfois même, simplement en changeant les options de compilation, la discussion entre ton projet et la "bibliothèque externe" (SFML, en l'occurrence) ne se fait plus correctement. Et, bien sur, le compilateur (ou plutôt l'éditeur de liens) t'envoie bouler :P

Et, bien sur, il faut utiliser l'architecture (32 ou 64 bits) des bibliothèques qui correspond au type de programme que tu veux créer: On ne peut en effet pas utiliser une version 32bits d'une bibliothèque avec un programme 64 bits (et inversement).

Or, déjà, tu parles d'utiliser visual studio 2019, ce qui est un choix tout à fait raisonnable. Le problème, c'est qu'un rapide coup d’œil sur la page de téléchargements de SFML suffit pour nous rendre compte que, s'il y a bien une version compilée (en 32 bits et en 64 bits) pour visual studio 2017 qu'il n'y a pas de version compilée de la SFML pour visual studio 2019 :P

Alors, je pourrais te proposer d'installer visual studio 2017 (qui reste disponible ==>ICI<==), mais, bon ... Nous sommes d'accord pour dire que ce n'est sans doute pas une solution acceptable, parce que cela prend du temps, que cela demande un espace disque pour le moins important et, surtout, parce qu'il y a peu de chances pour que le compilateur que cette version spécifique de visual studio supporte les derniers ajouts effectués par la norme (pour information: la norme couramment utilisée de nos jours est C++17, qui est parue en ... 2017, mais une nouvelle version de la norme a été finalisée en 2020 et il est conseillé de l'utiliser dans la mesure du possible ) ;).

Mais, du coup, tout cela ne fait pas vraiment nos affaires, car cela implique sans doute qu'il faudra en arriver à ... compiler toi-même la SFML pour qu'elle puisse fonctionner avec un programme compilé à l'aide de visual studio 2019 :P

Bon, je te rassure, cela n'a rien "très compliqué", d'autant plus que, vu que tu as décidé d'utiliser CMake pour la gestion de ton projet, tu pourrais "tout aussi bien" te contenter de rajouter les sources de SFML dans un sous-dossier "séparé" de ton projet (appelons le dependences, dependencies ou 3rdParty, selon ton inspiration personnelle :D ) et de le faire compiler en même temps que l'ensemble de ton projet.

Ou alors, on peut également décider de travailler de manière "plus classique", à savoir: on compile SFML "tout seul, dans son coin", et, après, on configure notre projet pour qu'il utilise la version de la SFML que nous aurons compilée.

Je t'avouerai avoir un penchant naturel pour l'idée qui consiste à "intégrer" le code de la SFML directement dans le projet, parce que cela permet -- si l'on décide de changer de compilateur (ou d'en utiliser plusieurs en fonction de son inspiration) -- de s'assurer que la dépendance (SFML) sera systématiquement compilée ... dans une version compatible avec le compilateur utilisé pour le reste du projet.

Cependant, je dois t'avouer que cette préférence est essentiellement due au fait que je joue régulièrement avec plusieurs compilateurs différents (pour te donner une idée, sous windows, j'utilise généralement VisualStudio, MinGW et clang).

Si bien que je comprendrai très bien que tu dises que "ah, non, moi, j'ai pas envie de commencer à me prendre le choux avec trois compilateurs différents: j'installe visual studio, et ca me suffira amplement", ce qui est une approche plaidant d'avantage pour la compilation "une bonne fois pour toutes" de la SFML et pour la configuration correcte de VisualStudio (et de CMake) en vue de son utilisation ;)

Par contre, il faut comprendre que, si tu choisi cette option et que tu décide de fournir ton code source à ton meilleur pote pour qu'il le compile lui-même, il ne pourra compiler ton projet (quel que soit le compilateur ou l'EDI qu'il utilise) que ... s'il dispose de la version adéquate (pour son compilateur, s'entend) de SFML.

Je vais donc te proposer les deux solutions, et il te reviendra de choisir celle que tu préfères ;)

Compiler la SFML séparément

Compiler la SFML séparément est finalement tout simple:

Tu télécharge les sources (tu trouveras une archive tout en bas de la page de téléchargements ;) ), et tu extraits les sources (fournies dans un dossier appelé SFML-x.y.z où x, y et z correspondent au numéro de version).

Tu ouvre une invite de commande, tu entre dans le dossier qui contient les sources, puis:
par facilité tu crées un dossier build (dans lequel la compilation s'effectuera) et tu rendre dedans au moyen de la commande mkdir build && cd build
tu configure la compilation à l'aide de la commande cmake .. (qui devrait suffire)
tu peux modifier quelques options dont les valeurs sont choisies par défaut en les ajoutant à la ligne de commande ci-dessus. Parmi les plus intéressantes, je citerais:

-DCMAKE_INSTALL_PREFIX=<dossier_d'installation> pour indiquer où tu veux que les bibliothèques et les fichier d'en-tête soient installés, car, autrement, l'installation se fera dans C:/Program Files (x86)/SFML par défaut, ce qui n'est pas la meilleure des idées ;)
-DBUILD_SHARED=OFF si tu préfères utiliser une version "statique" des bibliothèques de la SFML
-DSFML_BUILD_DOC=ON si tu souhaite générer la documentation (doxygen est requis pour ce faire)
-DSFML_BUILD_EXAMPLES=ON si tu souhaite compiler les exemples

(note: sous windows et par défaut, le générateur utilisé sera celui prévu pour visual studio 2019, ce qui fait notre affaire dans le cas présent ... Cependant, si tu veux générer le projet pour un autre compilateur, il faut utiliser l'option -G"<nom du générateur>" où le nom du générateur devra être l'un de ceux dont la liste peut être obtenue à l'aide de la commande cmake --help)

Une fois la compilation terminée, tu pourras lancer la compilation à l'aide de la commande cmake --build ..

NOTA:
A priori, visual studio est également intégré à ton menu contextuel, et tu pourrais, tout simplement, faire un clique droit dans le dossier qui contient les sources de SFML et choisir l'option "ouvrir dans visual studio".

Si tu as installé l'extension permettant l'utilisation de CMake dans visual studio, il devrait être en mesure de générer lui-même sa propre solution, et tu pourrais donc effectuer la compilation en choisissant "générer tout" dans le menu "générer" de visual studio ;)

A ce stade, les fichiers d'en-tête de SFML sont disponibles dans le dossier <dossier_sfml>/include et les bibliothèques sont disponibles dans le dossier <dossier_sfml>/build/lib.

Il sera donc temps de les installer en utilisant la commande cmake --install . (depuis le dossier build, toujours)

Ce processus devrait créer, dans le dossier indiqué par l'option CMAKE_INSTALL_PREFIX (voir plus haut)

un dossier bin qui contient au minimum openal32.dll (une des dépendances qui risquent de manquer autrement)
un dossier include avec un sous dossier SFML, contenant les fichier d'en-tête
un dossier lib contenant

un sous dossier debug, contenant les fichier pdb requis pour le debug par visual studio)
un sous dossier cmake/SFLM contenant les fichiers requis par CMake (*) lorsqu'on utilise l'instruction find_package

(*)Quand tu utiliseras CMake pour ton projet, il faudra qu'il soit en mesure de trouver ce fameux dossier cmake/SFLM afin de pouvoir effectuer la configuration de ton projet ;)

utiliser directement les sources de SFML pour ton projet

Avant de commencer, disons le tout de suite: j'aime que les sources d'un projet soient un minimum organisée, si bien que, de manière générale, mes projets ont tous à peu près la même organisation qui, dans mon cas, est proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 <dossier_racine> // le dossier qui contient l'ensemble du projet |-> 3rdParty // l'ensemble des dépendances qui seront compilées | |->SFML-x.y.z // voilà les sources SFML |->applications // les sources des différentes applications, dans des dossiers séparés |->examples // si besoin |->lib // on peut créer plusieurs bibliothèques | |->lib1 // les sources de la première bibliothèque | |->lib2 // les sources de la deuxième bibliothèque | |->... | |->libN // les sources de la N ieme bibliothèque |->test // les tests unitaires et d'intégration (si nécessaire)
L'idée est que l'on va demander à CMake d'aller à chaque fois voir "ce qui se passe" dans les différents sous dossiers, si bien que le CMakeLists d'origine va sans doute ressembler à quelque chose comme
<root_directory>/CmakeLists.txt
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #la version minimale de CMake qui sera utilisée cmake_minimum_required(VERSION 3.11) # pour désigner l'ensemble du projet à CMake project(mon_projet VERSION 1.0.0.0 LANGUAGES CXX) #je préférerais utiliser C++14, mais les sources de SFML utilisent toujours autoptr #or, si autoptr est "simplement" déprécié en C++14, il a carrément été supprimé #en C++17 :P set(CMAKE_CXX_STANDARD 14) set(CMAKE_CXX_EXTENSIONS OFF) set(CMAKE_CXX_STANDARD_REQUIRED ON) add_subdirectory(3rdParty) add_subdirectory(lib) # les dossiers suivants seront ajoutés en cas de besoin #add_subdirectory(applications) #add_subdirectory(tests) #add_subdirectory(examples) #add_subdirectory(doc) # pour générer la documentation
Grace à ce CMakeLists.txt qui se trouve dans le dossier racine, CMake va donc savoir qu'il doit aller voir "ce qui se passe" dans le dossier 3rdParty (tu le nomme comme tu veux, bien sur :D) afin d'y trouver ... les sources de la SFML qui doivent être compilées.

On va donc écrire un CMakeLists.txt dans le dossier 3rdParty qui donnera l'ensemble des instructions à suivre pour compiler les dépendances. Dans notre cas, il pourrait ressembler à quelque chose comme
3rdParty/CmakeLists.txt
Code:

1 2 set(BUILD_SHARED_LIBS OFF) # ou ON, si tu veux utiliser les dlls add_subdirectory(SFML-2.5.1)
(je fais au plus simple ici ;))

Puis nous allons créer une première bibliothèque (dans un sous dossier du dossier lib). Nous allons donc rajouter ce sous dossier dans le CMakeLists.txt qui se trouve dans le dossier lib, ce qui lui donnera la forme très évoluée de...
lib/CmakeLists.txt
Code:

1 2 add_subdirectory(lib_1) # et toutes les autres bibliothèques développées dans le cadre du projet
Si nous avons une classe nomméé MyClass dans cette première bibliothèque, et que nous avons donc un fichier MyClass.hpp et un fichier MyClass.cpp dans cette bibliothèque, le fichier CMakeLists.txt qui se trouve dans le dossier lib_1 devrait donc ressembler à quelque chose comme
lib/lib_1/CMakeLists.txt
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 project(lib_1 VERSION 1.0.0.0 LANGUAGES CXX) #désiger la bibliothèque comme étant un projet #signalons que nous voulons unb bibliothèque (statique) add_library(lib_1 STATIC "") # tu peux choisir SHARED si tu veux # ou meme ajouter une option pour choisir plus facilement #indiquons les fichiers qui devront être utilisés target_sources(lib_1 PUBLIC # les fichiers "publics" (les fichier d'en-tête principalement) MyClass.hpp PRIVATE #les fichiers "privés" (d'implémentation, principalement) MyClass.cpp) #indiquons que le dossier qui contient les sources contient également des #fichiers d'en-tête (pour permettre au compilateur de les trouver) target_include_directories(lib_1 PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) # indiquons à CMake que lib_1 dépend de sfml-system (pour faire simple) target_link_libraries(lib_1 PUBLIC sfml-system )
Une fois que tout cela est mis en place, il te suffira, comme pour la compilation de la SFML (voir plus haut), d'entrer dans le dossier racine de ton projet, de créer un répertoire build (pour garder les sources "clean" :D ), et de lancer les commande cmake .. (configuration) et cmake --build . (compilation)

Avec Visual Studio 2019, tu disposes en outre -- bien sur -- de l'intégration dans tes menus contextuels, si bien que tu peux aussi te contenter d'un clique droit ->ouvrir dans visual studio ;)

Bien sur, je t'invite à étudier à ton aise les possibilités offertes par CMake, car je suis resté vraiment au plus simple ici ;)

Mais, voilà, en (très rapide!!!) comment les chose devraient pouvoir se passer ;)

24/07/2020, 11h42
aperikub

Citation:

Envoyé par koala01

Mais, du coup, tout cela ne fait pas vraiment nos affaires, car cela implique sans doute qu'il faudra en arriver à ... compiler toi-même la SFML pour qu'elle puisse fonctionner avec un programme compilé à l'aide de visual studio 2019 :P

Citation:

Envoyé par koala01

NOTA:
A priori, visual studio est également intégré à ton menu contextuel, et tu pourrais, tout simplement, faire un clique droit dans le dossier qui contient les sources de SFML et choisir l'option "ouvrir dans visual studio".

Si tu as installé l'extension permettant l'utilisation de CMake dans visual studio, il devrait être en mesure de générer lui-même sa propre solution, et tu pourrais donc effectuer la compilation en choisissant "générer tout" dans le menu "générer" de visual studio ;)

c'est justement ce que j'essayais de faire et le message d'erreur que j'ai posté est celui que m'affiche visual studio lorsque j'ai essayé de compiler SFML avec la version de Cmake intégrée à visual studio.

du coup je suis en train d'essayer ta procédure via la ligne de commande je te tiens au jus !

Citation:

Envoyé par koala01

Une fois la compilation terminée, tu pourras lancer la compilation à l'aide de la commande cmake --build ..

j'ai un peu de mal avec cette phrase :?
du coup j'ai executé cmake .. a priori tout s'est bien passé du coup j'ai continué avec cmake --build et la :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
PS C:\Users\aperi\c++ libraries\SFML-2.5.1-sources\SFML-2.5.1\build> cmake --build
Usage: cmake --build <dir> [options] [-- [native-options]]
Options:
  <dir>          = Project binary directory to be built.
  --parallel [<jobs>], -j [<jobs>]
                 = Build in parallel using the given number of jobs.
                   If <jobs> is omitted the native build tool's
                   default number is used.
                   The CMAKE_BUILD_PARALLEL_LEVEL environment variable
                   specifies a default parallel level when this option
                   is not given.
  --target <tgt>..., -t <tgt>...
                 = Build <tgt> instead of default targets.
  --config <cfg> = For multi-configuration tools, choose <cfg>.
  --clean-first  = Build target 'clean' first, then build.
                   (To clean only, use --target 'clean'.)
  --verbose, -v  = Enable verbose output - if supported - including
                   the build commands to be executed.
  --             = Pass remaining options to the native tool.

dans le doute j'ai aussi essayé cmake --install:

Code:

1
2
3
4
5
6
7
8
9
PS C:\Users\aperi\c++ libraries\SFML-2.5.1-sources\SFML-2.5.1\build> cmake --install
Usage: cmake --install <dir> [options]
Options:
  <dir>              = Project binary directory to install.
  --config <cfg>     = For multi-configuration tools, choose <cfg>.
  --component <comp> = Component-based install. Only install <comp>.
  --prefix <prefix>  = The installation prefix CMAKE_INSTALL_PREFIX.
  --strip            = Performing install/strip.
  -v --verbose       = Enable verbose output.

puis j'ai essayé cmake --install <mon repertoire d'installation> (comme indiqué au dessus:

Citation:

Usage: cmake --install <dir> [options]

ce qui me donne :

Code:

1
2
3
4
5
6
7
8
9
10
11
PS C:\Users\aperi\c++ libraries\SFML-2.5.1-sources\SFML-2.5.1\build> cmake --install <"C:\Users\aperi\c++ libraries\SfML">
Au caractère Ligne:1 : 17
+ cmake --install <"C:\Users\aperi\c++ libraries\SfML">
+                 ~
L’opérateur «*<*» est réservé à une utilisation future.
Au caractère Ligne:1 : 54
+ cmake --install <"C:\Users\aperi\c++ libraries\SfML">
+                                                      ~
Spécification de fichier manquante après l’opérateur de redirection.
    + CategoryInfo          : ParserError: (:) [], ParentContainsErrorRecordException
    + FullyQualifiedErrorId : RedirectionNotSupported

24/07/2020, 14h33
koala01

C'est parce que tu as oublié le "." après l'option "--build" :

Quand tu lances la commande cmake --build cmake s'attend à ce que tu lui donne le dossier dans lequel il doit lancer la compilation. Dans le cas présent, c'est le dossier ... dans lequel tu te trouves et qui est représenté par ... un point "." (un peu comme deux points ".." représentent toujours le dossier parent ;) ).

du coup le build a fonctionné (en quoi ça consiste d’ailleurs? parce que executer des commandes comme ça sans avoir aucune idée de ce que ça fait c'est un peu frustrant) par contre cmake --install . et cmake --install <mon dossier d'installation> ne fonctionnent pas:

Code:

1
2
3
4
5
6
7
PS C:\Users\aperi\c++ libraries\SFML-2.5.1-sources\SFML-2.5.1\build> cmake --install .
-- Install configuration: "Release"
-- Installing: C:/Users/aperi/c++ libraries/SFML-2.5.1-sources/SFML-2.5.1/build/<C:/Users/aperi/c++ libraries/SFML>/./include
CMake Error at cmake_install.cmake:36 (file):
  file INSTALL cannot make directory "C:/Users/aperi/c++
  libraries/SFML-2.5.1-sources/SFML-2.5.1/build/<C:/Users/aperi/c++
  libraries/SFML>/./include": Invalid argument.

Code:

1
2
PS C:\Users\aperi\c++ libraries\SFML-2.5.1-sources\SFML-2.5.1\build> cmake --install "C:\Users\aperi\c++ libraries\SFML"
CMake Error: Error processing file: C:/Users/aperi/c++ libraries/SFML/cmake_install.cmake

24/07/2020, 16h06
aperikub

c'est bon l'install a fonctionné j'avais laissé le "<>" dans l'adresse d'installation. par contre si tu pouvais quand même m’expliquer en quoi consiste le build et l'install tu illuminerai ma journée et ma reconnaissance serait éternelle :D
24/07/2020, 16h39
koala01
Il y a trois étapes à CMake (pour le local, car on peut en avoir une quatrième ;) ):
la configuration: CMake s'assure que tous les prérequis sont respecter pour permettre la compilation du projet. Il en profite pour générer le build qui permettra l'étape suivante.
Le build (la construction): CMake s'occupe (au travers de l'outil utilisé par ton système) de compiler les fichiers d'implémentation, et d'effectuer l'édition de liens (si nécessaire, pour les applications)
l'installation: maintenant que l'on a -- dans un dossier "temporaire" ou "de développement" -- l'ensemble des éléments qui doivent être fournis, au format binaire, il est temps de placer ces éléments à l'endroit où l'utilisateur s'attend à les avoir.

Si tu installe ==>NSIS<== sous windows, ou que tu es sous linux (ou sous MacOs), cmake est capable de générer un installateur qui te permettra de fournir le résultat de ton travail (que ce soit sous forme de sources ou sous forme directement exécutable) à n'importe qui, qui sera en mesure de l'installer sur son propre système. C'est ce que l'on appelle "le déploiement".

Enfin, entre la construction et le déploiement, cmake est aussi capable de faire quelques trucs sympa, comme
- générer la documentation, si l'outil adéquat (comme doxygen, par exemple) est présent
- exécuter une suite de tests unitaires
- j'en oublie très certainement ;)
Je te conseilles très vivement de chercher quelques tutoriaux sur CMake, car il s'agit vraiment d'un outil qui t'offre une multitude de possibilités dans la gestion et la configuration de ton projet ;)

Par exemple, le dépôt git de ==>CMake Cookbook<== (le "livre de recettes de cmake :D ) donne une foule de petites recettes "simples" pour tout une séries se situations ;) (il y a d'ailleurs un livre -- en anglais -- qui explique toutes les recettes présentées ;)
24/07/2020, 18h06
aperikub

Citation:

Envoyé par koala01

Je te conseilles très vivement de chercher quelques tutoriaux sur CMake, car il s'agit vraiment d'un outil qui t'offre une multitude de possibilités dans la gestion et la configuration de ton projet ;)

c'est bien mon intention, la partie git/cmake du tuto de c++ moderne m'a laissé avec plus de question que de réponses.
du coup lorsque j'utilise cmake intégré à visual studio la fonction "générer le cache cmake" correspond à l'étape build, c'est bien ça?
24/07/2020, 23h05
koala01

Citation:

Envoyé par aperikub

c'est bien mon intention, la partie git/cmake du tuto de c++ moderne m'a laissé avec plus de question que de réponses.
du coup lorsque j'utilise cmake intégré à visual studio la fonction "générer le cache cmake" correspond à l'étape build, c'est bien ça?

Non, la génération du cache correspond à la configuration.

Le build correspond à ce qui se fait quand tu utilise les possibilités offertes par le menu "Générer" de visual studio: c'est à ce moment là que ton code source est réellement compilé ;)
25/07/2020, 16h31
aperikub

ok, merci encore d'avoir pris les temps de répondre à mes questions de ces derniers jours!