Comment écrire et exécuter des programmes C et C++ avec VSCode

Recommandations associées : "Tutoriel de base vscode"

0. Préface

Cet article s'adresse aux débutants, et chaque étape est détaillée. Lisez cet article pour acquérir des connaissances sur la ligne de commande, la compilation et le débogage des programmes, ainsi que sur l'utilisation de VS Code. Si vous trouvez cet article gênant, je vais vous donner une version simplifiée : installez les extensions gcc et c/c++, ouvrez le dossier, cliquez sur le code open source, F1, créez et déboguez le fichier actif, et c'est fait.

De nombreux contenus de cet article peuvent être obtenus à partir de la documentation officielle de VS Code : Programmation C++ avec Visual Studio Code et la documentation de chaque extension, et ils seront également mis à jour (cet article a a également été mis à jour plusieurs fois (mises à jour majeures), si vous souhaitez en savoir plus, vous pouvez le consulter. Cet article est essentiellement le résultat de nombreuses tentatives. S'il y a des erreurs, merci de les signaler.

Effet final : affichage en temps réel des erreurs, des extraits de code, de la complétion, du formatage, de la compilation d'un seul fichier et du débogage pendant la phase de compilation.

1. Préparation de l'environnement

Je n'entrerai pas dans les détails du site officiel, du téléchargement et de l'installation de VSC. VSC est juste un éditeur de texte brut (éditeur), pas un IDE (environnement de développement intégré). Il n'inclut pas de compilateur (compilateur) et de nombreuses autres fonctions, le compilateur doit donc le faire. être installé par vous-même.

Téléchargez le compilateur : MinGW-w64 - pour Windows 32 et 64 bits Faites défiler un peu vers le bas et sélectionnez la dernière version x86_64-posix-seh. Il est préférable de ne pas utiliser Télécharger la dernière version Il s'agit d'un package d'installation en ligne. Le téléchargement peut échouer en raison de « l'environnement réseau » national. Si le téléchargement du navigateur ne parvient pas, essayez de le télécharger via Thunder ou de vous connecter au point d'accès sur votre téléphone mobile. Si le téléchargement échoue toujours, utilisez une méthode qui vous permet d'accéder à Google.

"Installer" le compilateur : ce qui revient est un package compressé 7z. Si vous ne savez pas comment décompresser, vous pouvez rechercher « Comment décompresser un package compressé » sur Baidu. Après la décompression, placez-le dans un endroit où il ne sera pas facilement supprimé. Vous pouvez supprimer certains des fichiers qui se chevauchent. Soyez optimiste quant au chemin complet du dossier bin. Dans mon image, il s'agit de C:mingw64bin et ajoutez-le au PATH dans la variable d'environnement. Si vous ne savez pas comment réaliser cette étape, consultez « B. Comment ajouter des variables d'environnement » à la fin de cet article (vous pouvez effectuer une recherche avec Ctrl+F sur cette page)

Pour Debian Linux, utilisez simplement sudo apt update; sudo apt install build-essential.

L'ordre n'est pas important ; le chemin peut être différent, de toute façon, assurez-vous simplement que gcc.exe est dans ce dossier

Vérifiez

Appuyez sur Win+R, exécutez cmd (ne sautez pas cette étape), entrez gcc, vous devriez être invité avec aucun fichier d'entrée au lieu de « pas une commande interne ou externe » ou "l'élément "gcc" ne peut pas être reconnu. Il s'agit du nom d'une applet de commande, d'une fonction, d'un fichier de script ou d'un programme exécutable." S'il ne s'agit "pas d'une commande interne ou d'une commande externe", cela signifie que le dossier où se trouve gcc n'est pas dans le chemin de la variable d'environnement et doit être ajouté. Si le problème persiste après l'avoir ajouté, redémarrez. Si cela ne fonctionne toujours pas après le redémarrage, il y a un problème avec vos propres opérations.

Entrez gcc -v pour afficher la version de gcc. Si la version affichée est différente/plus ancienne que la que vous venez de télécharger , cela signifie qu'il existe une ancienne version du compilateur dans Path, qui peut avoir été installée en installant un autre IDE. Vous devez supprimer le chemin gcc d'origine dans Path.

Ces deux vérifications doivent être conformes à , sinon les variables d'environnement doivent être modifiées. Attention à ne pas supprimer par erreur.

Ne vous inquiétez pas du bruit maintenant, quelque chose va mal se passer. Le tutoriel clang a été déplacé à la fin de cet article

Entrez la dernière ligne de sortie de gcc -v. La version doit correspondre à la vôtre, par exemple, 64 bits doit avoir x86_64 et seh

Installer l'extension (extension)

• C/C++ : également connu sous le nom de cpptools , fournit la fonction de débogage et de format
• Code Runner : faites un clic droit pour compiler et exécuter un seul fichier, ce qui est très pratique mais ne peut pas déboguer

Autres extensions facultatives :

• Bracket Pair Colorizer 2 : Rainbow Braces
• One Dark Pro : Probablement le thème le plus installé pour VS Code

Extensions non recommandées/non requises pour l'installation :

• GBKtoUTF8 : convertissez les documents codés GBK en documents codés UTF8. Cette extension n'a pas été mise à jour depuis longtemps et peut présenter de sérieux bugs
• C++ Intellisense : utilise gtags, le choix de la première version de cet article. L'effet est très très général
• Inclure la saisie semi-automatique : fournit la complétion du nom du fichier d'en-tête. Désormais, cpptools et vscode-clangd ont déjà cette fonction, il n'est donc pas nécessaire de l'installer
• Extraits C/C++. : Extraits C'est-à-dire réutilisez des blocs de code, et l'effet sera Baidu par vous-même ; bien que le volume d'installation de cette extension soit élevé, je pense personnellement qu'elle n'est pas très utile. cpptools et clangd peuvent également en être fournis ; choisissez également d'autres extensions Snippets ou même définissez la vôtre

Connaissances supplémentaires

• Le compilateur transforme le code source en un fichier exécutable, et l'éditeur est le logiciel que vous tapez. Notepad est un éditeur et VSC est également un éditeur. L'éditeur ne peut pas compiler et exécuter le programme, car c'est le travail du compilateur
• MinGW est un portage de gcc sous Windows, et gcc est la combinaison de compilateur C/C++ la plus populaire dans le monde. Mais le nom gcc fait également référence au programme qui compile le langage C, et g++ est le compilateur C++. Autrement dit, le programme gcc et le programme g++ sont inclus dans la suite gcc et MinGW. Lorsque seul gcc est mentionné, il faut le distinguer selon le contexte
• En fait, MinGW et MinGW-w64 sont simplement. noms similaires, ce sont deux projets différents. Pour plus de commodité, MinGW dans cet article fait en fait référence à MinGW-w64. MinGW lui-même n'a pas été mis à jour depuis longtemps, ne l'utilisez pas Oups, il s'avère que MinGW est vivant, mais il ne peut produire que des programmes 32 bits
• Extensions sont des extensions et les plug-ins sont des plugins. VSC utilise l'ancien nom. La plupart des articles utilisent un mélange des deux, ce qui n'est pas rigoureux mais peut être compris. Il faut apprendre à saisir la contradiction principale. Bien sûr, tout ce qui est utilisé dans cet article est correct
• Lecture facultative : [Popular Science][FAQ] MinGW vs MinGW-W64 et autres

2. Configuration de quelques fichiers .json

Créez un dossier dans lequel vous prévoyez de stocker le code, appelé dossier de l'espace de travail Le chemin ne peut pas contenir de caractères chinois ni de guillemets , et il est préférable de ne pas en avoir espaces. J'utilise C:VS-Code-C. C et C++ doivent respectivement créer des dossiers différents, sauf si un espace de travail virtuel est utilisé. Ne sélectionnez pas le dossier dans lequel le compilateur est stocké dans la section précédente. Le code source et le compilateur doivent être conservés séparément.

Ouvrir VSC, sélectionner Ouvrir le dossier ; il est préférable de ne pas sélectionner "Ajouter un dossier d'espace de travail". Il s'agit d'un espace de travail virtuel, je ne l'ai pas utilisé, je ne peux donc pas garantir qu'il le sera. ça va. Cliquez pour créer un nouveau dossier nommé .vscode. La raison pour laquelle il n'est pas possible d'en créer un nouveau dans la gestion des ressources est que l'Explorateur Windows n'autorise pas que le premier caractère d'un dossier créé soit un point (pris en charge après 1903). Créez ensuite launch.json, task.json, settings.json ( pas settings.json) et placez-les dans le dossier .vscode . Rendu :

doit être en .vscode, ne le mettez pas en parallèle

Le contenu de ces fichiers est le suivant. Après avoir copié le code suivant, Zhihu ajoutera automatiquement quelques lignes devant celui-ci indiquant que tous les droits sont réservés. Vous devez le supprimer lorsque vous l'utilisez réellement. Certains endroits sont facultatifs à modifier, alors vérifiez-le par vous-même en fonction des commentaires. Remarque : Si vous écrivez en C++, une partie de tâches.json doit être modifiée. Le

code launch.json

externalConsole peut être modifié selon vos propres préférences. cwd peut être le chemin relatif lorsque le programme est en cours d'exécution et peut être modifié en ${ si nécessaire fileDirname} (merci à @xhx). Je n'ai jamais utilisé lldb donc je ne dirai pas grand chose. Il est normal que le type et la demande ne changent pas de couleur.

// https://code.visualstudio.com/docs/cpp/launch-json-reference
{
    "version": "0.2.0",
    "configurations": [{
        "name": "(gdb) Launch", // 配置名称，将会在启动配置的下拉菜单中显示
        "type": "cppdbg", // 配置类型，cppdbg对应cpptools提供的调试功能；可以认为此处只能是cppdbg
        "request": "launch", // 请求配置类型，可以为launch（启动）或attach（附加）
        "program": "${fileDirname}/${fileBasenameNoExtension}.exe", // 将要进行调试的程序的路径
        "args": [], // 程序调试时传递给程序的命令行参数，一般设为空即可
        "stopAtEntry": false, // 设为true时程序将暂停在程序入口处，相当于在main上打断点
        "cwd": "${workspaceFolder}", // 调试程序时的工作目录，此为工作区文件夹；改成${fileDirname}可变为文件所在目录
        "environment": [], // 环境变量
        "externalConsole": true, // 使用单独的cmd窗口，与其它IDE一致；为false时使用内置终端
        "internalConsoleOptions": "neverOpen", // 如果不设为neverOpen，调试时会跳到“调试控制台”选项卡，你应该不需要对gdb手动输命令吧？
        "MIMode": "gdb", // 指定连接的调试器，可以为gdb或lldb。但我没试过lldb
        "miDebuggerPath": "gdb.exe", // 调试器路径，Windows下后缀不能省略，Linux下则不要
        "setupCommands": [
            { // 模板自带，好像可以更好地显示STL容器的内容，具体作用自行Google
                "description": "Enable pretty-printing for gdb",
                "text": "-enable-pretty-printing",
                "ignoreFailures": false
            }
        ],
        "preLaunchTask": "Compile" // 调试会话开始前执行的任务，一般为编译程序。与tasks.json的label相对应
    }]
}

À l'origine, après octobre 2018, le terminal intégré pouvait être utilisé en définissant externalConsole sur false, mais en octobre 2019, cpptools 0.26.1 a introduit un bug, qui empêchait le terminal intégré pour saisir le chinois sous Win. Pour l'instant, il s'agit de 0.29 .0 n'est toujours pas résolu. J'ai ouvert

https://github.com/microsoft/MIEngine/pull/1025 Je suis venu pour le réparer, mais un mois plus tard, ils n'avaient aucun avis, avis négatif.

code task.json

S'il est

écrit en C++, le compilateur doit être remplacé par g++ si vous ne souhaitez pas d'avertissements supplémentaires, supprimez le - ; Wall one ; -std Modifiez-le selon vos propres besoins, mais il semble y avoir un problème avec c++17. Il est préférable d'utiliser au maximum c++14, il n'est pas nécessaire d'ajouter -fexec-charset sous Linux. . Quoi qu'il en soit, j'y ai ajouté des commentaires, mais je n'arrive toujours pas à les comprendre, tutoriel d'utilisation de Baidu gcc.

révèle les contrôles s'il faut accéder au panneau de connexion pendant la compilation. Vous pouvez le modifier selon vos propres préférences ; même s'il est défini sur Jamais, il ne sautera pas automatiquement et vous pourrez toujours voir les informations en cliquant manuellement dessus.

// https://code.visualstudio.com/docs/editor/tasks
{
    "version": "2.0.0",
    "tasks": [{
        "label": "Compile", // 任务名称，与launch.json的preLaunchTask相对应
        "command": "gcc",   // 要使用的编译器，C++用g++
        "args": [
            "${file}",
            "-o",    // 指定输出文件名，不加该参数则默认输出a.exe，Linux下默认a.out
            "${fileDirname}/${fileBasenameNoExtension}.exe",
            "-g",    // 生成和调试有关的信息
            "-m64", // 不知为何有时会生成16位应用而无法运行，加上此条可强制生成64位的
            "-Wall", // 开启额外警告
            "-static-libgcc",     // 静态链接libgcc，一般都会加上
            "-fexec-charset=GBK", // 生成的程序使用GBK编码，不加这条会导致Win下输出中文乱码；繁体系统改成BIG5
            // "-std=c11", // 要用的语言标准，根据自己的需要修改。c++可用c++14
        ], // 编译的命令，其实相当于VSC帮你在终端中输了这些东西
        "type": "process", // process是把预定义变量和转义解析后直接全部传给command；shell相当于先打开shell再输入命令，所以args还会经过shell再解析一遍
        "group": {
            "kind": "build",
            "isDefault": true // 不为true时ctrl shift B就要手动选择了
        },
        "presentation": {
            "echo": true,
            "reveal": "always", // 执行任务时是否跳转到终端面板，可以为always，silent，never。具体参见VSC的文档
            "focus": false,     // 设为true后可以使执行task时焦点聚集在终端，但对编译C/C++来说，设为true没有意义
            "panel": "shared"   // 不同的文件的编译信息共享一个终端面板
        },
        "problemMatcher":"$gcc" // 捕捉编译时终端里的报错信息到问题面板中，修改代码后需要重新编译才会再次触发
        // 本来有Lint，再开problemMatcher就有双重报错，但MinGW的Lint效果实在太差了；用Clang可以注释掉
    }]
}

code settings.json

Mettez le contenu de ce fichier dans "Paramètres utilisateur" pour remplacer les paramètres globaux, sinon il ne sera efficace que dans l'espace de travail actuel. Chacun de ces deux points a ses propres avantages.

La ligne de commande de Code Runner et certaines options peuvent être modifiées ici en fonction de vos propres besoins. Si vous souhaitez la personnaliser ou savoir ce que cela signifie, veuillez vous référer à la documentation de cette extension et à l'utilisation de Baidu gcc. tutoriel. Si le terminal utilise cmd (

Win7par défaut), vous devez le commenter ou remplacer par PowerShell par défaut sur PS et n'a pas besoin d'être modifié. terminal.integrated.shell.windows

Merci pour les suggestions d'extraits mentionnées par

@Wellin Boss cependant, il y a encore quelques problèmes avec l'utilisation de top, il est donc remplacé par facultatif.

{
    "files.defaultLanguage": "c", // ctrl+N新建文件后默认的语言
    "editor.formatOnType": true,  // 输入分号(C/C++的语句结束标识)后自动格式化当前这一行的代码
    "editor.suggest.snippetsPreventQuickSuggestions": false, // clangd的snippets有很多的跳转点，不用这个就必须手动触发Intellisense了
    "editor.acceptSuggestionOnEnter": "off", // 我个人的习惯，按回车时一定是真正的换行，只有tab才会接受Intellisense
    // "editor.snippetSuggestions": "top", // （可选）snippets显示在补全列表顶端，默认是inline

    "code-runner.runInTerminal": true, // 设置成false会在“输出”中输出，无法输入
    "code-runner.executorMap": {
        "c": "gcc '$fileName' -o '$fileNameWithoutExt.exe' -Wall -O2 -m64 -lm -static-libgcc -std=c11 -fexec-charset=GBK && &'./$fileNameWithoutExt.exe'",
        "cpp": "g++ '$fileName' -o '$fileNameWithoutExt.exe' -Wall -O2 -m64 -static-libgcc -std=c++14 -fexec-charset=GBK && &'./$fileNameWithoutExt.exe'"
        // "c": "gcc $fileName -o $fileNameWithoutExt.exe -Wall -O2 -m64 -lm -static-libgcc -std=c11 -fexec-charset=GBK && $dir$fileNameWithoutExt.exe",
        // "cpp": "g++ $fileName -o $fileNameWithoutExt.exe -Wall -O2 -m64 -static-libgcc -std=c++14 -fexec-charset=GBK && $dir$fileNameWithoutExt.exe"
    }, // 右键run code时运行的命令；未注释的仅适用于PowerShell（Win10默认）和pwsh，文件名中有空格也可以编译运行；注释掉的适用于cmd（win7默认）、PS和bash，但文件名中有空格时无法运行
    "code-runner.saveFileBeforeRun": true, // run code前保存
    "code-runner.preserveFocus": true,     // 若为false，run code后光标会聚焦到终端上。如果需要频繁输入数据可设为false
    "code-runner.clearPreviousOutput": false, // 每次run code前清空属于code runner的终端消息，默认false
    "code-runner.ignoreSelection": true,   // 默认为false，效果是鼠标选中一块代码后可以单独执行，但C是编译型语言，不适合这样用
    "code-runner.fileDirectoryAsCwd": true, // 将code runner终端的工作目录切换到文件目录再运行，对依赖cwd的程序产生影响；如果为false，executorMap要加cd $dir

    "C_Cpp.clang_format_sortIncludes": true, // 格式化时调整include的顺序（按字母排序）
}

c_cpp_properties.json

Si vous êtes sûr de ne pas avoir besoin d'utiliser les bibliothèques d'autres personnes, alors la version actuelle (après 0.18.0)

n'a pas besoin de créer ceci fichier , cpptools Les paramètres par défaut seront utilisés automatiquement. Cet article ne contient donc plus la configuration de ce fichier.

Si vous avez écrit le fichier d'en-tête vous-même et qu'il ne se trouve pas sous workspaceFolder, ou si vous utilisez la bibliothèque de quelqu'un d'autre, vous devez créer manuellement le fichier et le placer sous

. Pour les modèles, veuillez vous référer à : .vscodeMicrosoft/vscode-cpptools.

Quelques expériences passées :

Le chemin de la bibliothèque doit être ajouté à includePath et parcourir
Si une inclusion récursive est requise, ajoutez
• à la fin . /**
Ce json n'autorise pas les commentaires. En fait, selon le standard json, il ne peut pas avoir de
compilerPath semble devoir être le chemin complet de MinGW, précis pour gcc.exe, sinon, il indiquera que le fichier d'en-tête est introuvable ; Sous Linux, il s'agit de /usr/bin/gcc mais je ne l'ai pas testé depuis longtemps
Le séparateur de répertoire sous Windows est une barre oblique inverse. À l'origine, deux barres obliques inverses doivent être utilisées pour s'échapper, mais la barre oblique est utilisée directement ici. Bang accepte également
En plus de configurer ce fichier, d'autres opérations doivent être effectuées. Pour en savoir une partie, veuillez vous référer à la « Compilation de fichiers multiples » ci-dessous

Connaissances supplémentaires

json est un format d'échange de données, la plupart sont un sous-ensemble de JavaScriptconfiguration. VSC et diverses extensions liront les entrées dans json pour déterminer certaines fonctions et comportements.

D'où viennent tant d'entrées ? C'est en fait similaire à l'API. Le développeur de l'extension "indiquera" à VSC les options qui peuvent être modifiées, ce qui est écrit sur la page d'installation de chaque extension. En tant qu'utilisateur, VSC vous demandera ce qui est disponible lors de la saisie, c'est donc en fait très facile à écrire.

Pourquoi avez-vous besoin d'écrire autant de choses en json ? Parce que VSC lui-même n’accorde pas de traitement spécial au langage C, ni à de nombreux autres langages. Et la commande de compilation la plus critique n'a rien à voir avec VSC. C'est l'affaire de l'éditeur et du compilateur mentionnés ci-dessus. VSC n'est pas responsable, ne peut pas ou ne peut pas compiler le langage C.

Les variables commençant par $ sont des variables prédéfinies par VSC. Pour plus de détails, voir : Référence des variables. Par exemple, $file sera remplacé par le nom du fichier actuellement ouvert lors de l'opération réelle.

3. Écrivez du code, compilez et déboguez

Après avoir créé un nouveau fichier, vous pouvez écrire du code. Le suffixe du code source du langage C est .c et C++ est .cpp ou .C. ou .cxx (ceci Voulez-vous que je vous l'apprenne aussi...). Les fichiers de code peuvent être enregistrés dans l'espace de travail. Vous pouvez créer un dossier par vous-même n'a pas besoin d'être placé dans le dossier .vscode , mais le chemin (y compris le nom du fichier) ne doit pas contenir. Caractères chinois et guillemets , de préférence sans espaces. La raison principale est que de nombreux symboles sont une syntaxe shell valide. Sinon, essayez d'utiliser rm pour supprimer un fichier appelé -rf sous Linux ? Je ne peux certainement pas l'écrire sans le vérifier.

Appuyez sur Alt+Shift+F (ou utilisez le menu contextuel) pour formater le code. Modifiez la méthode de formatage, par exemple si les accolades sont renvoyées à la ligne. Vous pouvez voir : Formater. Accolades sur la même ligne en C++ VSCode . Lorsque Intellisense apparaît appuyez sur la tabulation pour compléter le code . Lors de la saisie d'extraits, plusieurs points de saut apparaîtront. Appuyez sur la touche de tabulation pour passer au suivant.

Après avoir arrêté de taper pendant une courte période (une seconde), Lint apparaîtra. L'extension donnera des avertissements suggestifs (comme déclarer des variables mais ne pas les utiliser). Si vous vous sentez mal à l'aise, il existe des moyens de l'empêcher de vous inviter. Par exemple, supprimer -Wall réduira le nombre d'invites. Si vous souhaitez supprimer d'autres avertissements, laissez-moi vous rappeler : -Wno-.... Après avoir trouvé les paramètres, vous pouvez utiliser #pragma GCC diagnostic ignored ou les ajouter à divers Flags. Quoi qu'il en soit, faites vos propres recherches. Cependant, Lint de cpptools ne prend pas en charge la définition des indicateurs, ce qui est un peu déroutant. Suivez : Drapeaux d'erreur et d'avertissement ? · Problème n° 2814 · microsoft/vscode-cpptools

Ensuite, parlons-en. à propos de courir. Premièrement, la compilation est le processus de génération d'un fichier exécutable à partir du code source. Le débogage est en fait un type particulier d'opération, qui permet de contrôler le fonctionnement du programme et de faciliter les modifications ultérieures. Il s'agit de deux étapes différentes. La compilation peut réussir mais le débogage échoue, la compilation peut échouer directement ou la compilation peut échouer avant le démarrage de la compilation. Si vous dites simplement « l'opération a échoué », les autres ne seront pas en mesure de déterminer à quelle étape se situe le problème. S'il est déterminé qu'une certaine étape a été franchie, vous n'avez pas à vous soucier de cette étape et pouvez vous concentrer sur la résolution des problèmes des autres étapes.

Appuyez sur Ctrl+Shift+B pour simplement compiler, et appuyez sur F5 pour compiler et déboguer. À l'origine, ctrl+F5 signifiait exécuter mais pas déboguer, mais maintenant, cpptools ne le prend pas en charge, il déboguera donc toujours. Suivez : Support "Exécuter sans débogage" · Numéro n°1201 · microsoft/vscode-cpptools

Dans les premiers stades de l'écriture d'un programme, je recommande fortement de ne pas utiliser f5 comme un compilateur, car certains bugs ne généreront que des avertissements et n'empêcheront pas la compilation, mais plus ces problèmes seront résolus tôt, mieux ce sera. Les informations de compilation seront dans le panneau "Terminal" en bas. S'il y a des erreurs dans le code, vous pouvez cliquer dessus pour voir les informations rapportées par le compilateur. Cependant, grâce à Lint, les erreurs courantes peuvent être découvertes et corrigées. immédiatement, ce qui rend beaucoup plus facile l'écriture de code.

Pour ajouter un point d'arrêt, cliquez simplement devant le numéro de colonne. Vous pouvez ajouter un point d'arrêt conditionnel en cliquant avec le bouton droit. Si vous souhaitez l'arrêter depuis le début, vous pouvez l'ajouter à la fonction principale, ou il y a un paramètre dans launch.json. Après avoir démarré le débogage, appuyez sur f11 pour procéder étape par étape. La ligne de code pointée par la flèche est le code à exécuter ensuite ; f5 s'exécutera jusqu'au prochain point d'arrêt. pour choisir de l'exécuter tout le temps sur la ligne spécifiée.

Il y a une barre de débogage à gauche, où vous pouvez voir les valeurs des variables. S'il n'y a pas de barre automatique, vous pouvez l'ajouter manuellement : sélectionnez l'expression à surveiller dans le code, à droite. -cliquez et il y a une option pour l'ajouter directement à la montre. Il suffit de frapper à la main. Vous pouvez voir la valeur de la variable en plaçant la souris dessus, mais seules les expressions simples peuvent être reconnues. Les cadres de pile sont utiles pour observer la récursion. En cas de débordement de pile et d'erreur de segmentation, vous pouvez également capturer les « exceptions » et passer automatiquement à la mauvaise ligne.

Spécialement, pour les tableaux : les tableaux en langage C dégénéreront en pointeurs après avoir été passés par les fonctions. Si vous ajoutez directement une expression, vous ne pourrez voir que le premier élément. À ce stade, vous pouvez le forcer à pointer vers un pointeur de tableau de taille fixe, puis le déréférencer : par exemple, une fois int arr[10] passé dans la fonction, il devient int* arr Ajouter *(int(*)[10])arr à Watch pour que vous puissiez le faire. peut voir le tableau complet. Mais la longueur doit être précisée, alors faites attention à ne pas franchir la ligne. Ou un simple programme peut toujours le voir en utilisant le tableau de variables globales. Autre façon d'écrire qui n'est valable que pour gdb et qui est non nulle* : *arr@10.

Touches de raccourci : vscode : touches de raccourci communes de Visual Studio Code - Zhiwen Studio. Bien sûr, il existe des descriptions de touches de raccourci dans le document anglais, et vous pouvez également consulter l'aide-mémoire, et le document anglais sera mis à jour. Celui-ci est répertorié séparément uniquement pour les débutants.

Si vous rencontrez une erreur, lisez d'abord les "Quelques erreurs possibles" ci-dessous et la zone de commentaires .

Code Runner

Si vous n'avez pas besoin de déboguer, vous pouvez directement cliquer avec le bouton droit et sélectionner exécuter le code, ou cliquer sur le bouton de lecture dans le coin supérieur droit. Si elles sont exécutées dans le terminal, les données peuvent être saisies, mais la fonction d'affichage de l'heure est manquante dans la « sortie », les deux éléments ci-dessus sont inversés.

Appuyez sur Ctrl + C dans le terminal pour terminer le programme. Vous devez vous assurer que le programme en cours est terminé avant de l'exécuter la prochaine fois (il en va de même pour les tâches). Si vous souhaitez copier, faites un clic droit après avoir sélectionné le contenu ; pour coller, faites un clic droit lorsqu'il n'est pas sélectionné ; cette opération est limitée à Win10, ctrl+c peut également copier, mais le programme peut être arrêté accidentellement.

Vous pouvez également l'utiliser pour compiler et exécuter des programmes dans des espaces non-travail, mais gcc est utilisé par défaut à moins qu'executorMap ne soit placé dans les paramètres globaux. D'après ma configuration, il existe une différence entre la tâche et Code Runner : le répertoire de travail. Le premier est le dossier que vous avez ouvert et le second est le dossier où se trouve le fichier. Bien entendu, ils peuvent également être modifiés par eux-mêmes.

En fait, Code Runner ne remplace que votre saisie manuelle de commandes , et sa fonction n'est pas forte. Il est applicable à différents scénarios. Ne pensez pas qu'exécuter du code pour exécuter Hello World est facile, Code Runner est très puissant et toutes les configurations précédentes sont des ordures.

De plus, le répondant en bas, Han Jun, est l'auteur de cette extension. Si vous avez des questions, veuillez le contacter (drôle).

Compilation multi-fichiers

Si vous souhaitez effectuer une petite quantité de compilation multi-fichiers, utilisez simplement gcc 源文件1.c 源文件2.c 头文件1.h pour le langage C et g++ pour C++. A.exe est généré par défaut, ajoutez -o pour spécifier le nom du fichier de sortie, et les options restantes sont le didacticiel d'utilisation de Baidu gcc. Si vous devez compiler plusieurs fois, vous pouvez écrire un processus par lots.

Si vous souhaitez faire beaucoup de compilation multi-fichiers, apprenez à écrire des makefiles ou à utiliser cmake. Modifiez ensuite la commande tâches pour appeler make (ou mingw32-make), etc.

Si vous souhaitez utiliser les bibliothèques d'autres personnes, telles que ffmpeg, vous devrez peut-être spécifier -I, -l (L minuscule), -L dans la commande. Lisez la documentation de cette bibliothèque pour connaître les paramètres spécifiques. Vous devrez peut-être également ajouter le chemin d'accès à c_cpp_properties.json pour configurer Intellisense.

Dans ces cas, vous pouvez envisager de créer un espace de travail séparé et de ne pas le partager avec une compilation en fichier unique. En fait, déboguer un seul fichier sans créer un nouveau projet n’est pas propice à une utilisation et à une compréhension futures des IDE à grande échelle. Cependant, les débutants n'ont pas besoin de beaucoup maîtriser. Ne pensez pas que construire un projet est difficile. Vous pouvez très bien compiler sans construire de projet.

En bref, ceux-ci n'ont rien à voir avec VSC. Vous rencontrerez des problèmes similaires lors de l'utilisation d'autres IDE ou de la compilation manuelle, ce qui est également un peu compliqué. Cet article n’en discutera pas en détail et nous les résoudrons nous-mêmes.

Enregistrez le dossier

Après écrit le code, vous devez ouvrir le dossier précédemment créé pour écrire, sinon tout Intellisense aura disparu et seul Code Runner pourra être utilisé. (Principalement besoin de ces quatre jsons. Pour créer d'autres dossiers, vous devez copier ces jsons.)

Vous pouvez créer un raccourci (clic droit pour en créer un nouveau) et transmettre le chemin de l'espace de travail en tant que paramètre. Programme principal de VSC, pensez à mettre des guillemets doubles ; vous pouvez également ajouter une icône. 1.18 dispose d'un véritable espace de travail virtuel, et une fenêtre peut contenir plusieurs dossiers qui ne sont pas ensemble. Le menu "Fichier" a également la fonction "Enregistrer l'espace de travail", mais je ne l'ai pas essayé, donc je ne peux pas garantir que ce sera le cas. D'ACCORD.

Nettoyer les fichiers temporaires

Selon cette configuration, il y aura certainement un gros problème pour compiler le code depuis longtemps. La pile d'exes peut aussi être dispersée dans différents dossiers.

可以考虑修改一下json文件，把生成文件的目录指定到一个专门放exe的文件夹里；如果不会，百度gcc使用教程以及看我的json里的注释。或者资源管理器右上角搜索*.exe然后手动删除。

也可也写个bat，放到工作区里，要用的时候右键Run Code：

del %~dp0*.exe /q /s
del %~dp0tempCodeRunnerFile.c /q /s
del %~dp0a.out /q /s
del %~dp0*.o /q /s

其中%~dp0会被替换成该批处理所在目录，这是为了防止有同学选错工作目录，误删根目录下的文件；code runner的设置我也调整成了先切换到文件目录，双保险。

添加纯英文输入法

Windows 10，默认输入法只有一个微软拼音，按一次shift就能进行中英转换；为了保持兼容，按ctrl加空格也能进行中英转换，但这个快捷键正是强制触发Intellisense的快捷键。

所以，我强烈建议手动添加“英语”语言输入法，正常代码时切换到纯英文输入法（win+空格），在需要频繁中文注释或者在字符串里写中文时才用中文输入法的英文模式。

这样也可以解决某些游戏需要用到shift键但同样快捷键冲突的问题。具体操作可以自己百度，也可以看我写的这篇有点复杂的文章：Windows 切换显示语言与添加纯英文输入法。

某些可能出现的错误

为了阅读的连贯性，这一部分移到了“A. 一些其它可能出现的错误”。遇到问题优先查看那里是否已经提了。

4. 其他设置

我的一些其他的设置，用在全局settings.json里，根据自己的情况调整，不需要全部照着我的写。写完一个以后要打逗号；最外面的那个大括号我没加，就别弄丢了。

现在的VSC用的是可视化的设置界面，其实原本是手动编辑且出现两列设置的。点击右上角那个花括号就能手动编辑。

作者：谭九鼎
链接：https://www.zhihu.com/question/30315894/answer/154979413
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

"editor.fontFamily": "等距更纱黑体 SC", // 控制编辑器字体
"editor.fontSize": 16, // 同上
"editor.fontLigatures": true, // 连体字，效果不太好形容，见 https://typeof.net/Iosevka 最后一部分
"editor.minimap.enabled": false, // 我个人不用minimap，就是右边那个东西
"editor.dragAndDrop": false, // 选中文字后，可以拖动它们调整位置。我是不需要
"editor.cursorSmoothCaretAnimation": true, // 移动光标时变得平滑
"editor.smoothScrolling": true, // 滚动平滑，不过效果很微弱
 
"files.trimTrailingWhitespace": true, // 保存时，删除每一行末尾的空格
"files.insertFinalNewline": true, // 保存后文件最末尾加一整行空行，Linux下的习惯
"files.autoGuessEncoding": false, // 启用后，会在打开文件时尝试猜测字符集编码。我关闭的理由见6，默认也是禁用的

"workbench.colorTheme": "One Dark Pro", // 主题
"workbench.colorCustomizations": {
      "activityBar.foreground": "#39C5BB" // 自定义颜色；想定义其它位置参见官方文档
},
"workbench.settings.useSplitJSON": true, // 恢复手动编辑时的两列设置
"window.zoomLevel": 0.2, // 整体放大

"git.enabled": false, // 如果你不用git，可以考虑关闭它
"git.ignoreMissingGitWarning": true, // 同上

"[c]": {
    // "files.encoding": "gbk" // 这样的格式可以对指定后缀的文件应用设置，如果你实在想用gbk，就这样设置吧。cpp同理。
},

更纱黑体是楼下B神做的字体，特点是标点好看（误）：be5invis/Sarasa-Gothic

Consolas虽然是Windows自带字体中还算行的，但它只有英文字体；微软雅黑虽然是非衬线字体，但它不是等距的，这一点非常不适合编程，等线也不等距；中易宋体……告辞。不下新的字体，其他两大系统我不清楚，Windows下简直没有编程可用的字体。Consolas加雅黑嘛，也还行吧，不过能用更好的干嘛不用呢。

6. 关于中文和乱码

VS Code输出中文会出现乱码，很多人都遇到过。这是因为源代码默认是UTF-8编码，cmd/PowerShell是GBK编码。直接编译，会把“你好”输出成“浣犲ソ”。Linux就没有这个问题。

一种解决方法是用gcc，编译时用-fexec-charset=GBK这个参数（目前的配置是有的），生成的程序就是GBK编码的，源文件仍是UTF8。而clang的execution-charset supports only UTF-8，所以用clang就无解。

另一种方法是用宽字符输出，有点复杂，见：C语言与中文的一些测试 (Win, UTF8源码) 。此文也提到了chcp 65001的事。

直接修改非Unicode程序的语言为UTF8(beta)会导致所有用GBK的程序乱码，这是不可接受的。

当然，如果你不打算坚持用UTF8作为源代码的编码，那直接用GBK编码也行。

如果是打开已有的以GBK编码的文件，VS Code默认会以UTF-8编码打开（除非你设置了猜测编码），这样编辑器内的中文就会乱码，此时要点右下角的GBK，选“通过编码重新打开”，选UTF-8即可。那为什么不打开自动猜测编码呢？可以参见我的这个回答：VS Code 中文注释显示乱码怎么办？。如果你不担心，那就开吧。

如果把代码文件发给其他用Windows的人，最好转成GBK，否则别人用记事本打开有可能会乱码（1803后的记事本改善了一些，联通已经不会乱码了）。

对于调试，无论怎么做，gdb都无法调试路径中存在中文的程序。这个貌似是gdb的bug，但是优先级极低：[gdb] cannot not open source file with Chinese/Unicode characters in path when debugging · Issue #602 · microsoft/vscode-cpptools

总之，对于Windows，这些问题没什么好办法，因为本文用的这一套就是从Linux搬过来的。用Linux应该就没有这些问题了。

7. Erreur de fichier d'en-tête introuvable

• gcc n'est pas dans le chemin. Revenez en arrière et regardez l'étape de vérification ci-dessus
• c_cpp_properties.json a été configuré manuellement et le chemin inclus était incorrect. Si vous n'avez pas créé ce fichier, ne vous embêtez pas
• Redémarrez et essayez

Si vous vous assurez que ces points répondent aux exigences, alors je n'ai pas de bonnes idées ...ou donnez-moi une autre réponse, tutoriel du Maître. Notez que cette phrase est la solution de rechange ultime. Si vous êtes sûr de ne pas avoir commis d'erreur, vous n'avez pas besoin de me le demander, je ne peux pas la résoudre.

Une autre erreur de fichier d'en-tête introuvable :

Ce cas est dû à la cible par défaut de clang est msvc, vous devez ajouter le paramètre --target=x86_64-w64-mingw.

Cette cible par défaut est codée en dur dans le code source. J'ai cherché et je n'ai pas trouvé de moyen normal de la modifier. Téléchargez le code source de clang, modifiez-le vous-même, puis compilez clang lui-même, vous pourrez peut-être le résoudre. Ou installez le SDK Windows sans utiliser mingw, qui sera conforme à la cible par défaut.

Bien sûr, le moyen le plus simple pour le moment est de compiler avec gcc.

12. Utiliser clang sous Win

En fait, cette partie était à l'origine la partie principale de cet article, mais elle introduit trop de concepts, et l'effet n'est pas si bon (car là n'est pas une libc++), maintenant tout est facultatif ici. Théoriquement, il vaut mieux l'utiliser en WSL, mais peut-être qu'il passera d'une fosse à une autre, je ne l'ai pas essayé. Cette partie est uniquement destinée à l'expérience des pièges.

• Q : Pourquoi devez-vous installer Clang ?
  A : Le message d’erreur est plus convivial. Et : En quoi Clang est-il meilleur que GCC ?
• Q : Comment prononcer Clang ?
  A : La bonne réponse est /?kl??/, c'est-à-dire que c prononce le son "ke", mais cela repose toujours sur une compréhension mutuelle. Par exemple, il est également compréhensible de dire SQL sous forme de cercle.
• Q : Pourquoi dois-je installer à la fois Clang et MinGW ?
  A : Parce que Clang sous Win n'a pas de libc++. Vous pouvez également choisir d'installer VS et d'utiliser le SDK Windows, qui ne nécessite pas MinGW. C'est plus officiel, mais plus volumineux.
• Q : L'installation de l'intégration MSVC a échoué/impossible de trouver une installation de Visual Studio...
  R : C'est la raison pour laquelle la précédente Clang utilise le backend MSVC par défaut. Mais cette partie utilise MinGW, vous n'avez donc pas besoin de prêter attention à cette invite. Sinon, installez le SDK Windows

Environnement

• Page de téléchargement LLVM : Téléchargez Clang sur cette page. Sélectionnez Windows (64 bits) dans les binaires pré-construits, il n'est pas nécessaire de télécharger le fichier .sig
• vscode-clangd : fournit les fonctions Intellisense et Lint pour l'entrepôt et l'utilisation, voir : clangd/clangd
• Adaptateur de commande C/C++ Clang : cet article l'a déjà utilisé. S'il y a un problème avec vscode-clangd, vous pouvez envisager de passer à celui-ci. La configuration est un peu différente. et clang.cflags doit être modifié. S'il n'y a pas de problème, ne l'installez pas
• Clang-Format : installé uniquement si vous souhaitez personnaliser le style du code, par exemple si les accolades sont des nouvelles lignes. . Il faut apprendre à utiliser
• CodeLLDB : l'extension vscode de lldb, qui nécessite un environnement Python ; je ne l'ai jamais utilisé

Configuration

Ajoutez
• à la commande de compilation. La cible par défaut de clang est msvc Si vous ne l'ajoutez pas, vous ne trouverez pas le fichier d'en-tête --target=x86_64-w64-mingw
• , C_Cpp.errorSquiggles et C_Cpp.autocomplete. celui rapporté par clangd C_Cpp.suggestSnippets

compile_flags.txt

En fait, il s'agit de définir ces options de compilation, utilisez essentiellement -. Mur et --target=x86_64-w64-mingw. clangd n'utilisera que le compile_flags.txt le plus proche du fichier en cours d'évaluation. Étant donné que vous devez vous assurer qu'il existe un --target, il est préférable de créer un répertoire racine sur le disque de l'espace de travail pour la solution de secours.

Mais ce qui est plus déroutant, c'est que C et C++ utilisent tous deux .h comme fichier d'en-tête. Si vous n'ajoutez aucun std, .c et .cpp peuvent être lint correctement, mais .h utilisera le mode C. Il ne semble pas y avoir de bonne solution de repli. Encore une fois, installez simplement le SDK Windows.

13. Mon expérience en écriture de code

En termes de taille, le corps principal + le compilateur + les extensions, s'il est juste utilisé pour écrire du C, l'occupation du disque dur n'est pas trop petite, jusqu'à 1G. L'utilisation de la mémoire est encore relativement faible (environ 0,5 g) ; il y a eu un bug qui utilisait beaucoup de mémoire, mais bien sûr, il a été corrigé depuis longtemps.

Peut-être que le premier avantage du VSC est qu'il a l'air bien ? Bien qu’il ne soit pas spécifiquement conçu pour le C/C++, il devrait actuellement être l’éditeur de texte brut le plus moderne. Et Lint seul est bien meilleur que wintc, cfree et dev c++, sans oublier que la propre fonction Debug de dev c++ contient des bogues.

Autre IDE, CodeBlocks est toujours vivant, même si le bagage historique est très évident. Clion a une belle interface et des fonctions puissantes, mais il est uniquement en anglais, il peut donc être un peu difficile de démarrer. Les étudiants peuvent demander une clé gratuitement, sinon il y a des frais. Si vous souhaitez utiliser le SDK Windows, la prochaine version de Visual Studio (Installer) Community consiste simplement à connecter le développement de bureau C++. Cela sera conforme à la cible par défaut de Clang, mais je pense qu'il est préférable d'utiliser VS directement. Vous pouvez lire cette réponse pour les évaluations d'autres répondants sur certains IDE C : Un novice sans aucune base en programmation va apprendre le langage C, doit-il utiliser VC6 ou VS2015 ? .

Il y a encore une chose que je veux dire au groupe étudiant : si vous pouvez Baidu accéder à cet article, travailler dur pour le comprendre et le configurer vous-même, vous serez meilleur que les innombrables personnes qui vous contactent. à Tieba et attendez que l'enseignant distribue l'IDE dans le groupe QQ Beaucoup plus fort. Si vous en avez la capacité, je vous recommande quand même de lire la documentation VSC : Documentation pour Visual Studio Code Ce n'est pas compliqué aussi de faire l'expérience de l'application pratique de l'anglais.

A. Quelques autres erreurs possibles

• Si vous écrivez uniquement hello world sans ajouter de points d'arrêt, la boîte noire clignotera après avoir appuyé sur f5. C'est un phénomène normal . Si vous souhaitez que le programme se mette en pause, vous pouvez en ajouter un ou deux getchar(); à la fin. Je ne comprends pas pourquoi on en utilise parfois deux ? Demandez à votre professeur de langage C ; ou utilisez system("pause"), ou ajoutez des points d'arrêt, ou utilisez le terminal intégré (externalConsole false) dans launch.json. Si vous insistez pour utiliser un terminal externe et ne faites rien, et que vous souhaitez simplement le mettre en pause après son exécution, alors VSC ne peut pas le faire, du moins pas avec ma configuration, et je ne veux pas l'étudier, car j'utilise le borne intégrée.
• preLaunchTask "Compile" a été terminé, le code de sortie est 1 : il y a une erreur dans la compilation et si vous utilisez F5 pour exécuter, vous verrez cette invite si vous cliquez sur Still debug, le fichier qui était ; compilé avec succès la dernière fois sera débogué. En fait, tous les échecs de compilation déclencheront cette erreur. N'est-il pas logique que la valeur de retour d'une erreur soit 1 ? Donc, me dire simplement que cette invite apparaît ne sert à rien , cela signifie que quelque chose s'est mal passé et que personne ne peut voir la raison, la raison est dans le panneau "Terminal" . Si Hello World peut être débogué et exécuté normalement, mais que cette erreur se produit dans un autre code, il est probable que il y ait une erreur dans votre propre code .
• Le terminal sera réutilisé par la tâche, appuyez sur n'importe quelle touche pour fermer : Avez-vous déjà entendu parler de « appuyez sur n'importe quelle touche pour continuer » ? C'est ce que signifie cette phrase. Cette phrase est encore plus inutile que le code de sortie 1 ci-dessus. Elle ne contient aucune information valide Elle sera affichée quel que soit le succès ou l'erreur C'est juste un texte explicatif.
• Impossible d'ouvrir..., fichier introuvable (file:///build/glibc-OTsEL5/glibc-2.27/...) : J'ai rencontré ce problème sous Linux, il semble que ce devrait être Vous vous essayez d’accéder à une fonction de bibliothèque, mais vous n’avez pas le code source. La solution est de placer la prochaine glibc à l'emplacement spécifié. Ou consultez ceci : Désactivez "Impossible d'ouvrir le fichier" pendant le débogage · Problème n°811 · Microsoft/vscode-cpptools.
• référence non définie à xxx ... échec de la commande linker : une fonction non déclarée a été appelée. Peut-être que le nom de la fonction est mal saisi ou qu'il n'y a pas de fichier d'en-tête d'inclusion. Bref, il y a une erreur dans votre propre code.
• ld : impossible d'ouvrir le fichier de sortie... autorisation refusée : le programme d'origine est toujours en cours d'exécution (comme une boucle infinie) et ne peut pas être écrasé, donc la génération échoue. Terminez simplement ce processus dans le Gestionnaire des tâches.
• Sous MinGW, l'utilisation de strcmp dans la fenêtre Watch entraînera le crash et la fermeture de gdb pour des raisons inconnues. Normal sous Linux.
• Après avoir renommé le fichier, le Lint existant sera toujours dans la colonne des problèmes ; les points d'arrêt peuvent devenir invalides après la modification du fichier. Il existe également d'autres petits bugs comme celui-ci. Généralement, fermez simplement VSC et rouvrez-le.
• Cette configuration ne peut pas être utilisée avec Bash pour Windows ou WSL car les barres obliques inverses dans bash sont reconnues comme des nouvelles lignes. cpptools fournit désormais des extraits Bash au lancement de Windows pour launch.json. Il existe maintenant un autre WSL distant. Mais je n’ai essayé d’utiliser aucun de ces éléments.
• Si vous souhaitez déboguer, n'activez pas l'optimisation. Gcc peut toujours conserver certaines informations de débogage en utilisant -Og, mais une fois clang utilisé, gdb ne peut pas être utilisé pour le débogage. Malgré cela, j'ai rencontré le problème de ne pas pouvoir accéder à une fonction lorsque j'écrivais du code, mais VS pouvait y accéder.
• vscode-clangd n'a pas pu détecter correctement printf, scanf et realloc pour la première fois, mais cela s'est amélioré après l'avoir utilisé une fois dans le code. Je ne sais pas non plus pourquoi.
• Il ne devrait y avoir aucun & pour le moment : utilisez PowerShell ou executorMap de Code Runner dans le terminal pour utiliser les deux commandes que j'ai commentées. Voir la description de settings.json ci-dessus pour plus de détails.
• crt0_c.c:(.text.startup+0x2e) : référence non définie à `WinMain' : Il n'y a pas de fonction principale, ou main est écrit comme mian.
• Lors de l'utilisation de clang+mingw sous Win, #include signalera le fichier 'float.h' introuvable. Tout ira bien après l'avoir changé en g++. Je pense que cela devrait être un bug dans la bibliothèque. Quoi qu'il en soit, je ne sais pas comment le résoudre. Ou n'utilisez pas C++17 et essayez

B. Comment ajouter des variables d'environnement

Graphiquement : cliquez avec le bouton droit sur "Ce PC" et sélectionnez Propriétés ou appuyez sur win+ ; PausePause. Sélectionnez Paramètres système avancés, Avancé, Variables d'environnement sur la gauche. Sélectionnez Chemin parmi les éléments ci-dessus, modifiez-le et créez-en un nouveau. Remplissez ensuite le chemin d'accès au dossier contenant l'exe cible. Par exemple, si gcc est dans C:mingwbingcc, remplissez C:mingwbin Win n'est pas sensible à la casse.

Méthode en ligne de commande : ouvrez cmd ou PS, setx /m path "%path%;C:mingwbin". Cette commande ne nécessite pas de privilèges d'administrateur et ne se terminera pas à la fermeture du terminal (elle a le même effet graphique que ci-dessus).

Si vous ne savez toujours pas comment le modifier, vous pouvez rechercher des « variables d'environnement » sur Baidu ou Bilibili et regarder la vidéo. La plupart d'entre eux ne sont pas en C mais la différence n'est pas grande, faites juste attention à ne pas supprimer par erreur.

---

Si vous avez des questions, vous pouvez laisser un message pour en discuter, mais il est préférable de le décrire en détail. Et je le répète, ne vous contentez pas de me dire la phrase "preLaunchTask terminée avec le code 1". Cette phrase est inutile.

Pour plus de connaissances liées à la programmation, veuillez visiter : Introduction à la programmation ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!