Bonjour à tous!

Après plusieurs jours à me creuser la tête pour tenter de faire fonctionner VS Code, je n'ai toujours pas réussi à inscrire une ligne de code...

J'ai tout de même avancé dans les procédures de configurations, mais voilà que je me frappe à ce message: 

warning C4530: Gestionnaire d'exceptions C++ utilisé, mais les sémantiques de déroulement n'ont pas été activées. Spécifiez /EHsc. 

J'ai tenté de suivre la procédures pour m'assurer que EHsc apparait dans le fichier TASK. Json, mais rien à faire... je ne réussi pas à régler cette erreure. 

Je suis en apprentissage de C++ et je souhaitait tester avec VS Code, mais je commence à me démoraliser... 

Pouvez-vous m'aider avant que ma flamme s'éteigne?! 

Bonne soirée!

VSCode n'a pas nativement de système de build pour le C++.

La première chose à faire est d'installer l'extension C++.

A partir de là tu as 2 options:

- definir dans les fichiers de conf où se trouve ton compilateur et les repertoires d'include pour que l'intellisense fonctionne correctement. De plus tu devras decrire toutes les commandes pour compiler ton projet... bien entendu cette description dans des json n'a rien de portable à un autre IDE ou build system. L'avantage c'est que ca te fait apprendre les options de ton compilateur.

- l'autre option est d'utiliser CMake couplé avec l'extension CMake tools de VSCode pour l'integration dans l'IDE, qui est aussi bonne que dans Visual Studio. A mon avis CMake pour un debutant en C++ c'est prematuré.

Quoiqu'il en soit sache que VSCode ne tient pas la route ne serait ce qu'en terme de consommation de ressources de l'intellisense pour de gros projets en C++.

Utilise donc plutot Visual Studio si tu es sur Windows.

Peux tu préciser sous quel système d'exploitation tu es et quel compilateur souhaites-tu utiliser ?

Personnellement j'utilise visual code car je suis sur linux et que c'est l'éditeur que je préfère. Il est très rapide dans l'utilisation que j'en fais (moins lourd qu'un IDE). J'entends par rapide, le démarrage, la complétion sans trop de ralentissement, et le linter qui tient la route (même si dans certaines situations il est aux fraises). Je ne me prononcerais pas sur ses perf pour des gros projets vu que dans mon équipe on est sur des projets moyens (environ 100 000 lignes de code).

Je pense que la première option de @Spaceln est la plus appropriée vu que tu débutes. Voir la page officielle pour configurer vs code en c++ : https://code.visualstudio.com/docs/languages/cpp

Si tu es sur windows, tu as ce tutoriel plus détaillé pour t'aider à configurer vs code pour faire du c++ : https://code.visualstudio.com/docs/cpp/config-msvc (j'ai pas trouvé de bon tuto en français).

Pour linux : https://www.codeproject.com/Articles/1184735/Quick-Start-to-Use-Visual-Studio-Code-for-Cplusplu

Après, un fichier cmake ne prend pas la vie à écrire si tu ne cherches pas à être hyper générique. Et y a des bénéfices pédagogiques à utiliser cmake (plus en tout cas que juste appuyer sur un bouton "compiler"). Un bon endroit pour apprendre à l'utlilser : cmake wiki. Je confirme que l'intégration avec vscode se fait très facilement.

Je ne sais pas si cmake est très utilisé en entreprise, mais énormément de projets c++ que tu trouves sur internet (github) sont compilés à l'aide de cmake car c'est beaucoup plus rapide que d'écrire un fichier Makefile à la main.

Tu as donc plusieurs options. Tu peux choisir de rester sur vscode et suivre les étapes de configurations. Vscode est pour moi (ce n'est que mon avis) le meilleur éditeur moderne multiplateforme que tu pourras trouver actuellement. Si tu rencontres des problèmes, soit plus détaillé en listant toutes les étapes que tu as faites.

L'autre option est de passer par un IDE. Sur windows le meilleur reste pour moi visual studio. Sur linux, j'affectionne tout particulièrement QtCreator fait à la base pour l'utiliser avec Qt mais qui peut très bien s'utiliser sans.

Merci à tous pour vos recommandations. 

Zoop, j'ai l'intention de passer à visual studio par la suite, mais je m'acharne sur VS Code pour suivre une formation interessante qui est donné la dessus. 

SpaceIn: En ce qui concerne l'extention C++ je l'ai déjà installé. pas de soucis de ce côté. Je vais tenter de suivre la voie de la configuration dans les JSON. s'il est hasardeux de se lancer dans les options de CMAKE en tant que débutant. Je vais rester avec les options les plus simples. Ce que je comprend c'est que mon problème est bien en lien avec les fichiers json.

Sylabio: Je suis sur Windows 10 et Voici le chemin d'accès du compilateur: 

C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.24.28314/bin/Hostx64/x64/cl.exe

Mode Intellisence = MSVC - x64

j'ouvre les fichers Tasks.json et c._cpp._proprieties.json je copie ce qu'il y a sur le tutoriel. Mais quand je lance ceci: 

J'ai toujours ce message qui arrive: warning C4530: Gestionnaire d'exceptions C++ utilisé, mais les sémantiques de déroulement n'ont pas

été activées. Spécifiez /EHsc

Est ce que je suis sensé changer qque chose dans le fichier de configuration???

Voici également mon fichier Task:

Merci à tous pour votre soutien!!

Bon effectivement, limite avec CMake ça ira plus vite.

- Installe la dernière version de CMake: https://cmake.org/download/

- Nettoie complètement ton répertoire .vscode

- Installe l'extension CMake Tools dans VSCode. Si tu n'as pas ajouté CMake dans ton PATH (à l'installation, ou après), tu peux aider VSCode à trouver CMake en lui donnant le chemin de l’exécutable (champs cmake.cmakePath dans ton settings.json).

- Ajoute un fichier appelé CMakeLists.txt à la racine de ton projet, avec ce contenu (à la fin tu mets autant de add_subdirectory que tu as de sous- répertoires avec des .cpp):

cmake_minimum_required(VERSION 3.8)

if(${CMAKE_VERSION} VERSION_LESS 3.16)
  cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
else()
  cmake_policy(VERSION 3.16)
endif()

project(MonProjet)

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

if(MSVC)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
else()
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic")
endif()

add_subdirectory(src/chapter01)
add_subdirectory(src/chapter02)
...

- Déplace ton fichier cpp dans le répertoire src/chapter01 (ou tout autre sous arborescence que tu veux, c'est juste pour structurer tes exos par chapitre).

- Dans chaque répertoire src/chapter01, src/chapter02 etc, tu crées un autre fichier CMakeLists.txt.

Tu mets ceci dedans:

add_executable(exercise_01 exercise_01.cpp)
...

Tu répètes les add_executable pour chaque fichier .cpp qui doit construire un exécutable indépendant. Si tu n'as pas encore de fichier .cpp, tu laisses le fichier vide, mais il doit exister si tu avais fais un add_subdirectory de ce répertoire.

- Lance VSCode, CMake Tools va automatiquement détecter qu'il doit se lancer. Il va la toute première fois te proposer de chercher toutes les chaines de build dispo, tu acceptes (il va surement te trouver visual c++). Puis il va essayer de lancer le "configure" avec Cmake sur ton projet (un répertoire build devrait se créer dans ton projet, il ne faut pas commit ce répertoire si tu utilises git, c'est juste un répertoire de travail pour CMake, et là où il mettre les résultats de la compilation). A la fin de celui ci, il va te proposer d'asservir l'extension C++ sur le résultat des configure de CMake tools, tu acceptes, ça devrait te créer un settings.json dans VSCode.

Au pire si cela ne le crée pas, tu l'ajoutes à la main (et refais un configure pour que l'extension C++ capte bien la modif):

{
  "C_Cpp.default.configurationProvider": "vector-of-bool.cmake-tools"
}

- Ensuite il n'y a plus qu'à coder, et cliquer sur build pour compiler. A chaque fois que tu crées de nouveaux fichiers .cpp, ou de nouveaux répertoires, pense à éditer tes CMakeLists.txt en conséquence, puis cliquer sur "Configure" dans le panneau CMake Tools, puis "Build".

Au final, pour des projets qui n'ont pas des tonnes de déclaration, ça fera très bien le taf (juste que j'ai eu des mauvaises expériences avec des header monstres genre vulkancpp, où l'intellisense de l'extension C++ galère pendant des plombes, ou alors fait carrément planter le PC).

-
Edité par SpaceIn 14 janvier 2020 à 20:55:10

Bon tout d'abord, très bonne réponse de @Speceln qui explique absolument tout ce que tu as à faire pour démarrer avec cmake sur VSCode. Merci à @Spaceln.

Essayons quand même de résoudre ton problème car cela pourra sans doute aider d'autres personnes.

Je suis actuellement sur linux donc j'utilise le compilateur GCC, donc je ne peux pas pour le moment tester ton problème. Je testerai éventuellement ce week-end sur mon pc windows. Première question, as tu vérifié que le compilateur MVSC est bien installé à la ligne que tu indiques dans ton tasks.json ici:

"compilerPath": "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.24.28314/bin/Hostx64/x64/cl.exe"

Si oui, le problème semble venir de la gestion des exceptions du compilateur de MVSC (cf : la page relatant le warning C4530 Compiler Warning (level 1) C4530)

Cela proviendrait de la ligne où tu précises les arguments du compilateur (pourtant la même que sur la page de la doc de VSCode):

 "args": ["/EHsc", "/Zi", "/Fe:", "helloworld.exe", "helloworld.cpp"],

qui lancerai une commande shell du style :

ci.exe /EHsc /Zi /Fe: helloworld.exe helloworld.cpp

Il faut savoir que <iostream> comporte des exceptions donc tu es obligé de demander au compilateur de les gérer. Il me semble que sur GCC c'est par défaut. Visiblement, sur MVSC c'est l'argument /EH qui précise le modèle de gestion des exceptions à utiliser (voir la doc sur /EH).

Je ne comprends donc pas quel est le problème. J'ai regardé ces deux fils de discussion pour voir s'il y avait la réponse, mais je n'ai pas trouvé satisfaction (peut-être quelqu'un plus compétent que moi comprendra) :

• https://community.gamedev.tv/t/hello-world-and-warning-c4530-solved/103633/8
• https://stackoverflow.com/questions/552695/how-can-i-switch-off-exception-handling-in-msvc

{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "shell",
      "label": "g++.exe build active file",
      "command": "C:\\mingw-w64\\i686-8.1.0-posix-dwarf-rt_v6-rev0\\mingw32\\bin\\g++.exe",
      "args": ["-g", "${file}", "-o", "${fileDirname}\\${fileBasenameNoExtension}.exe"],
      "options": {
        "cwd": "C:\\mingw-w64\\i686-8.1.0-posix-dwarf-rt_v6-rev0\\mingw32\\bin"
      },
      "problemMatcher": ["$gcc"],
      "group": {
        "kind": "build",
        "isDefault": true
      }
    }
  ]
}

-
Edité par Sylabio 15 janvier 2020 à 9:30:07

Merci Sylabio, 

J'ai changé pour mingw et maintenant tout fonctionne. J'ai donc abandonné les procédures avec MSCV. 

J'ai quand même fait le test en enlevant <iostream> et les std::cout. Dans ce cas il n'y a pas de message d'erreur. C'est vraiment une question de prise en charge des exceptions. 

Merci également, SpaceIn pour toutes les informations concernant CMAKE! 

Je vais me perfectionner un peu et expérimenter cela en temps et lieu!!

 Grâce à vous je peux enfin commencer à avoir du plaisir dans une aventure C++

Bonne journée!!

Ravi qu'avec GCC ça fonctionne, il n'y avait pas de raisons du contraire. J'aurais bien aimé comprendre ce qui n'allait pas avec MVSC. Je pense que je vais faire des tests et je reviendrai poster ici ma réponse.

Tu devrais du coup mettre le sujet en résolu si tout est bon pour toi. Bonne chance dans ton apprentissage et surtout prends du plaisir.