VS CodeでC++開発！設定・デバッグ・コンパイル完全ガイド

By /

VS CodeでC++開発！設定・デバッグ・コンパイル完全ガイド

はじめに

Visual Studio Code（VS Code）は、軽量でありながら強力な機能を備えたソースコードエディターです。モダンなWeb開発だけでなく、C++のようなコンパイル言語の開発環境としても非常に人気があります。その最大の理由は、豊富な拡張機能による高いカスタマイズ性と、統合開発環境（IDE）に匹敵するレベルの編集、コンパイル、デバッグ機能を提供できる点にあります。

C++開発におけるVS Codeの魅力は以下の通りです。

  1. 軽量で高速: IDEのように重くなく、起動や操作がスムーズです。
  2. クロスプラットフォーム: Windows, macOS, LinuxのどのOSでも同じ環境で開発できます。
  3. 強力な拡張機能: C/C++拡張機能をはじめ、IntelliSense（コード補完、エラー検出）、デバッグ機能、ビルドシステムの統合など、開発を効率化する機能が豊富です。
  4. カスタマイズ性: テーマ、キーバインド、設定など、自分の好みに合わせて細かく調整できます。
  5. 統合ターミナル: エディター内で直接コマンドを実行できるため、コンパイルやテスト実行が容易です。
  6. Git統合: ソースコード管理がスムーズに行えます。

この記事では、VS Codeを使ってC++開発を始めるための準備から、コードの記述、コンパイル、そしてデバッグまで、一連のプロセスを詳細に解説します。特に、VS CodeのC++開発における核となる「拡張機能」「タスク（tasks.json）」「デバッグ（launch.json）」「IntelliSense（c_cpp_properties.json）」の設定方法と使い方に焦点を当て、初心者の方でも安心してC++開発環境を構築・活用できるよう、具体例を交えながら掘り下げていきます。

約5000語の詳細なガイドとして、読者の皆様がVS Codeを C++開発の強力な味方として使いこなせるようになることを目指します。

Step 0: 開発環境の準備（VS Codeのインストールより前に）

VS Codeはあくまでエディターであり、C++のコードをコンパイルしたり実行したりするためには、別途コンパイラやデバッガ、ビルドツールが必要です。まずはこれらを準備しましょう。お使いのOSによってインストール方法が異なります。

Windowsの場合: MinGW-w64 / MSYS2 のインストール

WindowsでC++開発を行う場合、GCC (GNU Compiler Collection) や GDB (GNU Debugger) を利用するのが一般的です。これらを含むディストリビューションとして、MinGW-w64 や MSYS2 が広く使われています。MSYS2は、MinGW-w64を含むパッケージマネージャーを備えた環境であり、簡単に開発ツールをインストール・管理できるため推奨されます。

  1. MSYS2のダウンロードとインストール:

    • MSYS2の公式サイト (https://www.msys2.org/) からインストーラーをダウンロードします。
    • インストーラーを実行し、指示に従ってインストールします。インストール先はデフォルト（C:\msys64など）で問題ありません。
    • インストール完了後、MSYS2 MINGW64 ターミナルを起動します。（スタートメニューから MSYS2 MINGW64 を検索）

  2. システムアップデート:

    • ターミナルで以下のコマンドを実行し、MSYS2のパッケージリストとシステムを更新します。
      bash
      pacman -Syu
    • 途中でターミナルの再起動を求められる場合があります。指示に従ってください。再度 MINGW64 ターミナルを起動し、もう一度コマンドを実行します。
      bash
      pacman -Su

  3. GCC, G++, GDB のインストール:

    • C++コンパイラ (g++)、Cコンパイラ (gcc)、デバッガ (gdb) をインストールします。以下のコマンドを実行します。
      bash
      pacman -S --needed base-devel mingw-w64-ucrt-x86_64-toolchain
      または、古い環境向けに mingw-w64-x86_64-toolchain を選択することもできますが、ucrt の方が新しいWindows環境との互換性が高いです。迷ったら ucrt を選びましょう。
    • インストール内容を確認するプロンプトが表示されたら Enter を押します。

  4. 環境変数PATHの設定:

    • VS CodeやWindowsのコマンドプロンプトからこれらのツールを使えるようにするため、MSYS2のMinGWバイナリディレクトリをシステムの環境変数 PATH に追加します。
    • 「システムの環境変数」を検索して開きます。
    • 「環境変数」ボタンをクリックします。
    • システム環境変数のリストから Path を選択し、「編集」をクリックします。
    • 「新規」をクリックし、MSYS2をインストールしたディレクトリ内のMinGWバイナリディレクトリ（例: C:\msys64\ucrt64\bin または C:\msys64\mingw64\bin）を追加します。
    • VS Codeやコマンドプロンプトを起動している場合は、設定を反映させるために再起動してください。
    • コマンドプロンプトやPowerShellで g++ --version や gdb --version を実行し、バージョン情報が表示されれば成功です。

macOSの場合: Xcode Command Line Tools のインストール

macOSでは、Xcodeに含まれるCommand Line ToolsにGCC, Clang, GDB, LLDBなどの開発ツールが含まれています。

  1. ターミナルを開く:
    • Launchpadから「ターミナル」を起動します。
  2. Command Line Tools のインストール:
    • 以下のコマンドを実行します。
      bash
      xcode-select --install
    • ソフトウェア使用許諾契約に同意するダイアログが表示されるので、指示に従います。
    • インストールが完了するまで待ちます。
  3. 確認:
    • ターミナルで g++ --version や clang++ --version、lldb --version を実行し、バージョン情報が表示されれば成功です。macOSのデフォルトはClangですが、GCCも含まれています。VS CodeのC++拡張機能は通常、ClangまたはGCCを自動検出します。

Linuxの場合: build-essential のインストール

多くのLinuxディストリビューションでは、C++開発に必要なツールが build-essential パッケージとしてまとめられています。

  1. ターミナルを開く:
    • お使いのディストリビューションのターミナルを起動します。
  2. build-essential のインストール:
    • Debian/Ubuntu系:
      bash
      sudo apt update
      sudo apt install build-essential gdb
      （gdb は build-essential に含まれていない場合があるため明示的に指定します）
    • Fedora/CentOS/RHEL系:
      bash
      sudo dnf groupinstall "Development Tools"
      # または
      sudo yum groupinstall "Development Tools"
      これらのコマンドはGCC, G++, GDBなどの基本的な開発ツールをまとめてインストールします。
  3. 確認:
    • ターミナルで g++ --version や gcc --version、gdb --version を実行し、バージョン情報が表示されれば成功です。

注意: 上記のインストールは基本的なものです。特定のライブラリ（例: Boost, OpenCVなど）やビルドシステム（例: CMake, Make）が必要な場合は、それぞれの方法でインストールしてください。

Step 1: VS Code のインストールと基本設定

開発ツールの準備ができたら、いよいよVS Codeをインストールします。

  1. VS Code のダウンロード:
    • VS Codeの公式サイト (https://code.visualstudio.com/) にアクセスし、お使いのOSに応じたインストーラーをダウンロードします。
  2. VS Code のインストール:
    • ダウンロードしたインストーラーを実行し、指示に従ってインストールします。Windowsの場合、「Code を Path に追加」のチェックボックスをオンにしておくと、コマンドプロンプトから code . コマンドでVS Codeを開けるようになり便利です。
  3. VS Code の起動:
    • インストールが完了したらVS Codeを起動します。

Step 2: C++ 開発に必要な拡張機能のインストール

VS CodeでC++開発を快適に行うには、専用の拡張機能が不可欠です。

  1. 拡張機能ビューを開く:
    • VS Codeの左側にあるサイドバーから、拡張機能アイコン（四角がいくつか重なったようなアイコン）をクリックします（または Ctrl+Shift+X / Cmd+Shift+X）。
  2. C/C++ 拡張機能の検索とインストール:
    • 検索バーに C++ と入力します。
    • Microsoft が提供している公式の C/C++ 拡張機能が表示されます。これを選択し、「Install」ボタンをクリックします。
    • この拡張機能は、C++のコード補完（IntelliSense）、コード整形、デバッグ機能など、C++開発の核となる機能を提供します。
  3. その他の便利な拡張機能（任意）:
    • C++ Extension Pack: Microsoft公式のC/C++拡張機能と、CMake Tools、Remote Developmentなどの関連拡張機能がまとめられたパックです。まとめてインストールしたい場合に便利です。
    • CMake Tools: CMake を使用してプロジェクトを管理する場合に必須です。CMakeプロジェクトの構成、ビルド、テスト、デバッグをVS Code上から直接行えるようになります。
    • Code Runner: 簡単な単一ファイルを実行したい場合に便利です。ショートカットキー一つでコードをコンパイル・実行できます。（ただし、本格的な開発では tasks.json やビルドシステムの使用が推奨されます）
    • clang-format: コードの自動整形に使われます。C/C++拡張機能も基本的な整形機能を持っていますが、clang-formatはより詳細な設定が可能です。
    • Better Comments: コメントを目立たせたり色分けしたりして、コードの可読性を向上させます。

これらの拡張機能をインストールすることで、VS Codeが強力なC++開発環境へと変貌します。

Step 3: シンプルなC++プロジェクトの作成と基本ワークフロー

まずは簡単な「Hello, World!」プログラムを作成し、VS Code上での基本的な開発ワークフロー（コード作成、コンパイル、実行）を体験してみましょう。

  1. プロジェクトフォルダの作成:
    • PC上の適当な場所に、新しいフォルダを作成します（例: cpp_project）。
  2. VS Code でフォルダを開く:
    • VS Code を起動し、メニューから File -> Open Folder... を選択し、先ほど作成したフォルダを選択します。
    • または、VS Code の統合ターミナルやコマンドプロンプトを開き、作成したフォルダに移動して code . コマンドを実行します。
  3. 新しいファイルの作成:
    • エクスプローラービュー（左側サイドバーの一番上のアイコン、Ctrl+Shift+E / Cmd+Shift+E）で、フォルダ名の横にマウスカーソルを合わせると表示される「New File」アイコンをクリックします。
    • ファイル名を main.cpp として Enter を押します。

  4. コードの記述:

    • main.cpp ファイルに以下のコードを記述します。

    “`cpp

    include // iostream ライブラリをインクルード

    int main() {
    // 標準出力にメッセージを表示
    std::cout << “Hello, VS Code C++ Development!” << std::endl;
    return 0; // プログラムの正常終了を示す
    }
    ``
    * コードを入力すると、C/C++拡張機能がIntelliSense機能を提供しているのがわかるはずです。キーワードの補完、括弧の自動補完、エラーの波線表示などが行われます。
    5. **ファイルの保存:**
    *    Ctrl+S/Cmd+S` でファイルを保存します。

これで、C++のソースコードファイルが作成されました。

Step 4: コードのコンパイル（ビルド）

C++のソースコードをコンピュータが実行できる形式（実行可能ファイル）に変換するプロセスを「コンパイル」または「ビルド」と呼びます。VS Codeでは、統合ターミナルを使う方法と、VS Codeのビルドタスク機能（tasks.json）を使う方法があります。

方法 1: 統合ターミナルで手動コンパイル

最もシンプルな方法は、VS Codeの統合ターミナルを開いてコマンドを直接入力することです。

  1. 統合ターミナルを開く:
    • メニューから Terminal -> New Terminal を選択します（または Ctrl+@ / Cmd+@）。
    • ターミナルが開かれ、カレントディレクトリがプロジェクトフォルダになっていることを確認します。
  2. コンパイルコマンドの実行:
    • g++（または clang++）コマンドを使用して main.cpp をコンパイルし、実行可能ファイルを作成します。実行可能ファイルの名前を main とする場合、以下のコマンドを実行します。
      • Windows (MSYS2/MinGW):
        bash
        g++ main.cpp -o main.exe
        （.exe はWindowsの実行可能ファイルの標準的な拡張子です）
      • macOS/Linux:
        bash
        g++ main.cpp -o main
        （g++ の代わりに clang++ を使っても構いません）
    • コマンドが成功すると、プロジェクトフォルダ内に main または main.exe という名前の実行可能ファイルが生成されます。

方法 2: VS Code ビルドタスク（tasks.json）を使用する

手動でのコンパイルは簡単ですが、引数が増えたり、複数のファイルをコンパイルする必要が出てきたりすると手間がかかります。VS Codeには、このような定型的な作業（ビルド、テスト、デプロイなど）を自動化するための「タスク」機能があります。タスクは tasks.json というファイルで定義します。

  1. ビルドタスクの設定:

    • メニューから Terminal -> Configure Tasks... を選択します。
    • いくつかの選択肢が表示されます。「Create tasks.json file from template」を選択します。
    • 次にテンプレートの選択肢が表示されます。「Others」を選択します。（GCC/Clang用のテンプレートも存在しますが、基本から理解するために「Others」が便利です）
    • tasks.json ファイルが .vscode フォルダ内に生成され、エディターで開かれます。デフォルト内容は以下のようになっています。

    json
    {
    "version": "2.0.0",
    "tasks": [
    {
    "label": "echo",
    "type": "shell",
    "command": "echo Hello"
    }
    ]
    }
    2. C++コンパイルタスクの定義:
    * 既存のタスク定義を編集または新しいタスクを追加して、C++のコンパイルコマンドを実行するタスクを作成します。以下は、main.cpp をコンパイルして main（Windowsの場合は main.exe）という実行可能ファイルを生成するタスクの例です。既存の “echo” タスクを置き換えても構いません。

    json
    {
    "version": "2.0.0",
    "tasks": [
    {
    "label": "build main", // タスクの名前。VS CodeのUIに表示される
    "type": "shell", // 実行するコマンドの種類 (shell: シェルコマンドとして実行)
    "command": "g++", // 実行するコマンド名
    "args": [ // コマンドの引数
    "main.cpp", // コンパイル対象のソースファイル
    "-o", // 出力ファイル名を指定するオプション
    "main", // 出力ファイル名 (Windowsでは "main.exe")
    "-g", // デバッグ情報を含めるオプション (デバッグに必須)
    "-Wall", // 警告を全て表示するオプション (推奨)
    "-std=c++17" // C++標準を指定 (必要に応じて変更)
    ],
    "options": { // その他のオプション
    "cwd": "${workspaceFolder}" // コマンドを実行するディレクトリをプロジェクトルートに設定
    },
    "group": {
    "kind": "build", // このタスクをビルドタスクとして分類
    "isDefault": true // デフォルトのビルドタスクに設定 (Ctrl+Shift+B で実行可能になる)
    },
    "presentation": {
    "reveal": "always" // タスク実行時にターミナルを表示
    },
    "problemMatcher": [ // コンパイラのエラー出力をVS Codeの「問題」ビューに表示するための設定
    "$gcc" // GCC/Clang のエラー出力形式に合わせた定義済みマッチャーを使用
    ]
    }
    ]
    }
    * 重要な引数:
    * -o <output_filename>: 生成される実行可能ファイルの名前を指定します。
    * -g: デバッグに必要な情報を実行可能ファイルに含めます。デバッグを行う場合は必ずこのフラグを付けます。
    * -Wall: すべての一般的な警告を表示します。コードの潜在的な問題を検出するのに役立ちます。開発中は常につけておくことを推奨します。
    * -std=<standard>: 使用するC++の規格を指定します (例: c++11, c++14, c++17, c++20)。
    * Windowsで main.exe を出力したい場合は、"main" の部分を "main.exe" に変更してください。
    * problemMatcher: "$gcc" は、コンパイラからのエラーメッセージ（ファイル名、行番号、エラー内容など）をVS Codeの「問題」ビューに解析して表示してくれる便利な機能です。

  2. ビルドタスクの実行:

    • tasks.json を保存します。
    • メニューから Terminal -> Run Build Task を選択します（またはショートカットキー Ctrl+Shift+B / Cmd+Shift+B）。
    • VS Codeが tasks.json 内の group.isDefault: true に設定されたタスク（この例では “build main”）を実行します。
    • ターミナルパネルが表示され、コンパイルコマンドの実行状況が表示されます。
    • エラーがなければ、プロジェクトフォルダ内に main または main.exe という実行可能ファイルが生成されます。エラーが発生した場合は、ターミナルの出力と「問題」ビューを確認してください。

複数のファイルをコンパイル・リンクする場合の tasks.json

プロジェクトが大きくなり、複数のソースファイル（.cpp）に分かれるのが一般的です。この場合、通常は各ソースファイルを個別にオブジェクトファイル（.o または .obj）にコンパイルし、最後にそれらのオブジェクトファイルをまとめてリンクして一つの実行可能ファイルを作成します。

例として、main.cpp と myfunc.cpp があり、myfunc.cpp に定義された関数を main.cpp から呼び出す場合を考えます。

myfunc.h:
“`cpp

ifndef MYFUNC_H

define MYFUNC_H

// 関数の宣言 (プロトタイプ宣言)
void print_message(const char* msg);

endif // MYFUNC_H

“`

myfunc.cpp:
“`cpp

include “myfunc.h” // ヘッダーファイルをインクルード

include

// 関数の定義
void print_message(const char* msg) {
std::cout << “Message: ” << msg << std::endl;
}
“`

main.cpp:
“`cpp

include

include “myfunc.h” // 自作ヘッダーファイルをインクルード

int main() {
std::cout << “Hello from main!” << std::endl;
print_message(“This is from a separate function.”); // myfunc.cpp の関数を呼び出し
return 0;
}
“`

この場合の tasks.json は、各 .cpp ファイルをオブジェクトファイルにコンパイルするタスクと、それらのオブジェクトファイルをリンクして実行可能ファイルを作成するタスクの、合計2つのタスクを定義するのが一般的です。あるいは、まとめてコンパイル・リンクする1つのタスクでも可能です。後者の方がシンプルなので、ここではまとめて行うタスクを示します。

json
{
"version": "2.0.0",
"tasks": [
{
"label": "build project", // プロジェクト全体のビルドタスク
"type": "shell",
"command": "g++",
"args": [
"main.cpp",
"myfunc.cpp", // 複数のソースファイルを指定
"-o",
"myprogram", // 出力ファイル名 (Windowsでは "myprogram.exe")
"-g",
"-Wall",
"-std=c++17"
],
"options": {
"cwd": "${workspaceFolder}"
},
"group": {
"kind": "build",
"isDefault": true
},
"presentation": {
"reveal": "always"
},
"problemMatcher": [
"$gcc"
]
}
]
}

このように、args にコンパイルしたいすべての .cpp ファイルを指定すれば、まとめてコンパイル・リンクが行われます。

より複雑なプロジェクトや、ライブラリへの依存関係が多いプロジェクトでは、MakefileやCMakeといったビルドシステムを利用するのが一般的です。次でCMakeを使った方法にも触れます。

方法 3: CMake を使用する (CMake Tools 拡張機能)

CMake は、様々なOSやコンパイラに対応したビルドシステムです。プロジェクトの構成を CMakeLists.txt というファイルに記述することで、複雑なビルド手順を自動化できます。大規模なC++プロジェクトでは、ほぼ必須と言って良いツールです。VS Codeの CMake Tools 拡張機能を使うと、VS CodeからシームレスにCMakeプロジェクトを操作できます。

  1. CMake のインストール:
    • Windows: MSYS2を使っている場合 pacman -S mingw-w64-ucrt-x86_64-cmake でインストールできます。または公式サイトからインストーラーをダウンロード。
    • macOS: brew install cmake (Homebrew使用) または公式サイトからダウンロード。
    • Linux: sudo apt install cmake または sudo dnf install cmake など。
  2. VS Code で CMake Tools 拡張機能をインストール:
    • Step 2 を参照してインストールします。

  3. CMakeLists.txt ファイルの作成:

    • プロジェクトフォルダに CMakeLists.txt という名前のファイルを作成し、以下の内容を記述します。

    “`cmake

    必要なCMakeの最小バージョンを指定

    cmake_minimum_required(VERSION 3.10)

    プロジェクト名を指定

    project(MyCppProject VERSION 1.0)

    C++標準を指定 (ここではC++17)

    set(CMAKE_CXX_STANDARD 17)
    set(CMAKE_CXX_STANDARD_REQUIRED TRUE)

    実行可能ファイルを定義

    実行ファイル名と、それに含まれるソースファイルを指定

    add_executable(myprogram main.cpp myfunc.cpp)

    もしインクルードディレクトリが必要な場合は追加

    include_directories(include)

    ``
    *    add_executableコマンドの第一引数が生成される実行可能ファイルの名前になります。第二引数以降に、実行可能ファイルに含めるすべてのソースファイル（.cpp）を指定します。
    4. **CMake プロジェクトの構成 (Configure):**
    *    CMakeLists.txtを保存すると、VS Code の右下に「Configure project」のようなプロンプトが表示されることがあります。表示されない場合は、VS Code のステータスバー（一番下）にある CMake 関連の表示をクリックするか、コマンドパレット (Ctrl+Shift+P/Cmd+Shift+P) を開いてCMake: Configureと入力して実行します。
    * CMake Tools が自動的にコンパイラなどを検出し、ビルドに必要なファイル群（Makefileなど）を    buildというようなフォルダ内に生成します。
    * コンフィギュレーションが成功すると、ステータスバーに選択されたキット（使用するコンパイラ/デバッガの組み合わせ）とビルドターゲット（通常はプロジェクト名または    add_executableで指定した名前）が表示されます。
    5. **CMake プロジェクトのビルド (Build):**
    * ステータスバーのビルドターゲット名の横にあるビルドボタン（ハンマーのアイコン）をクリックします。
    * または、コマンドパレットで    CMake: Buildと入力して実行します。
    * CMake Tools がビルドコマンド（例:    makeやninja）を実行し、プロジェクトをビルドします。
    * ビルドが成功すると、実行可能ファイルが    build` フォルダ内の適切な場所に生成されます。

CMake Tools 拡張機能は、tasks.json を手動で設定するよりも、C++プロジェクトの管理を効率化し、デバッグ設定（launch.json）との連携もスムーズに行えます。

Step 5: プログラムの実行

コンパイルが成功し、実行可能ファイルが生成されたら、プログラムを実行してみましょう。

方法 1: 統合ターミナルで実行

手動コンパイルの場合と同様に、統合ターミナルで実行可能ファイルを直接指定して実行します。

  1. 統合ターミナルを開く:
    • Ctrl+@ / Cmd+@ で開きます。
  2. 実行可能ファイルの場所へ移動:
    • tasks.json でビルドした場合、実行可能ファイルは通常プロジェクトルートに生成されます。
    • CMake でビルドした場合、実行可能ファイルは通常 build フォルダ内（OSによってはさらにサブフォルダ内）に生成されます。CMake Tools 拡張機能を使っている場合は、ステータスバーの実行ターゲットの横にある実行ボタン（再生アイコン）をクリックすると、自動的に適切なパスで実行してくれます。
  3. 実行コマンド:
    • プロジェクトルートにある場合 (tasks.jsonでビルド):
      • Windows: ./main.exe
      • macOS/Linux: ./main
    • CMakeのビルドディレクトリにある場合 (CMake Toolsでビルド、例: buildフォルダ内):
      • Windows: ./build/myprogram.exe
      • macOS/Linux: ./build/myprogram
      • (実際のパスはCMakeの設定や環境によります)

方法 2: Code Runner 拡張機能で実行（簡単な場合のみ）

Code Runner 拡張機能を使用している場合、エディター上でコードを開いている状態で右クリックし、「Run Code」を選択するか、ショートカットキー (Ctrl+Alt+N / Cmd+Option+N) を押すだけで、コードをコンパイルして実行できます。これは単一のファイルで、標準入力/出力のみを使うような簡単なプログラムには便利ですが、複数のファイル、コマンドライン引数、デバッグなどが必要な本格的な開発には向きません。

方法 3: VS Code デバッグ機能で実行（推奨）

VS Codeのデバッグ機能を使うと、プログラムを実行するだけでなく、実行中の状態を詳細に監視できます。デバッグ構成ファイル（launch.json）を作成することで、実行可能ファイルのパス、コマンドライン引数などを細かく設定できます。これは、プログラムの実行と同時にデバッグも行えるため、最も推奨される方法です。デバッグ方法については次のセクションで詳しく説明します。

Step 6: プログラムのデバッグ

デバッグは、プログラムのバグ（不具合）を見つけ、修正するために非常に重要なプロセスです。VS Codeは強力なデバッグ機能を提供しており、プログラムの実行を一時停止させたり、変数の値を調べたり、ステップ実行したりすることができます。

デバッグを行うには、launch.json というファイルにデバッグ構成を定義します。

  1. デバッグビューを開く:
    • VS Codeの左側にあるサイドバーから、デバッグアイコン（虫のアイコン）をクリックします（または Ctrl+Shift+D / Cmd+Shift+D）。

  2. launch.json ファイルの作成:

    • デバッグビューのRun and Debugボタンをクリックするか、上部のRunドロップダウンから「create a launch.json file」を選択します。
    • 環境を選択するプロンプトが表示されますので、「C++ (GDB/LLDB)」または「C++ (Windows)」などを選択します。通常、C/C++拡張機能が適切なデバッガ構成を自動検出します。
    • launch.json ファイルが .vscode フォルダ内に生成され、エディターで開かれます。内容は選択した環境によって異なりますが、基本的な構造は以下のようになります。

    json
    {
    "version": "0.2.0",
    "configurations": [
    {
    "name": "(gdb) Launch", // デバッグ構成の名前。ドロップダウンに表示される
    "type": "cppdbg", // デバッグの種類 (C++ デバッグ)
    "request": "launch", // リクエストの種類 (プログラムを起動してデバッグ)
    "program": "${workspaceFolder}/main", // 実行可能ファイルへのパス (Windowsでは ${workspaceFolder}/main.exe)
    "args": [], // プログラムに渡すコマンドライン引数の配列
    "stopAtEntry": false, // プログラム開始時にエントリーポイントで停止するか
    "cwd": "${workspaceFolder}", // プログラム実行時のカレントディレクトリ
    "environment": [], // プログラムに渡す環境変数の配列
    "externalConsole": false, // 外部コンソールを使用するか (Windowsで入力が必要な場合にtrueにすることがある)
    "MIMode": "gdb", // 使用するデバッグインターフェース (gdb または lldb)
    "miDebuggerPath": "/path/to/gdb", // デバッガ実行ファイルへのパス (システムPATHに設定されていれば不要)
    "setupCommands": [ // デバッグセッション開始時に実行するGDB/LLDBコマンド
    {
    "description": "Enable pretty-printing for gdb",
    "text": "-enable-pretty-printing",
    "ignoreFailures": true
    }
    ],
    "preLaunchTask": "build main" // デバッグ開始前に実行するタスク (tasks.jsonで定義したタスクのラベル)
    }
    // 複数のデバッグ構成をここに定義できる
    ]
    }
    * 重要な設定項目:
    * name: デバッグ構成を識別するための名前です。デバッグビューのドロップダウンに表示されます。
    * type: デバッグアダプターの種類です。C++の場合は cppdbg を使用します。
    * request: デバッグのモードです。launch はプログラムを起動してデバッグ、attach はすでに実行中のプロセスにアタッチしてデバッグします。通常は launch を使用します。
    * program: デバッグする実行可能ファイルへのパスを指定します。tasks.json や CMake でビルドした実行可能ファイルのパスを正確に指定します。${workspaceFolder} はプロジェクトルートディレクトリへのパスを表すVS Codeの変数です。
    * args: プログラムにコマンドライン引数を渡したい場合、文字列の配列としてここに指定します。
    * stopAtEntry: true にすると、プログラムの main 関数の先頭で実行が一時停止します。最初は false で問題ありません。
    * cwd: プログラムを実行するカレントディレクトリを指定します。通常は ${workspaceFolder} で良いでしょう。
    * MIMode: 使用するデバッグインターフェースを指定します。Windows/Linuxでは gdb、macOSでは lldb を選択するのが一般的です。
    * miDebuggerPath: デバッガ (gdb または lldb) 実行ファイルへのパスを明示的に指定したい場合に設定します。システム環境変数 PATH にデバッガへのパスが設定されていれば通常は不要です。
    * preLaunchTask: デバッグを開始する前に実行したいタスク（例: ビルドタスク）を指定します。tasks.json で定義したタスクの label と同じ文字列を指定します。これにより、コードを修正してもデバッグ実行前に自動的にビルドされるようになり便利です。

    • 先ほど作成した main.cpp の例であれば、program を ${workspaceFolder}/main (Windowsは ${workspaceFolder}/main.exe) に設定し、preLaunchTask を "build main" に設定します（tasks.json のタスクラベルが "build main" の場合）。

    • 複数のファイルをコンパイル・リンクする例 (myprogram) の場合は、program を ${workspaceFolder}/myprogram (Windowsは ${workspaceFolder}/myprogram.exe) に、preLaunchTask を "build project" に設定します。

    • CMake を使用している場合、CMake Tools 拡張機能は launch.json の設定を補助してくれます。program のパスは通常 ${command:cmake.launchTargetPath} というように、CMake Tools が解決したビルドターゲットのパスを参照するようになります。preLaunchTask は不要になります（CMake Tools 自身がビルドを管理するため）。CMake Tools で生成された launch.json テンプレートを使用するのが最も簡単です。

  3. ブレークポイントの設定:

    • プログラムの実行を一時停止させたいコード行の左側にあるエディターの余白部分をクリックします。赤い丸が表示され、ブレークポイントが設定されたことを示します。
    • ブレークポイントは複数設定できます。

  4. デバッグの開始:

    • launch.json ファイルを保存します。
    • デバッグビューの上部にあるデバッグ構成のドロップダウンから、実行したい構成名（例: (gdb) Launch）が選択されていることを確認します。
    • 再生ボタン（緑色の三角形）をクリックします（または F5 キーを押します）。
    • preLaunchTask が設定されていれば、まずビルドタスクが実行されます。
    • ビルド成功後、設定した program がデバッガによって起動されます。
    • プログラムは最初のブレークポイントに到達すると、そこで一時停止します。

  5. デバッグ中の操作:

    • プログラムがブレークポイントで停止すると、デバッグビューのツールバーに以下の操作ボタンが表示されます。
      • Continue (F5): 次のブレークポイントまで実行を再開します。ブレークポイントがなければプログラムの終了まで実行します。
      • Step Over (F10): 現在の行を実行し、関数呼び出しの中に入らずに次の行に進みます。
      • Step Into (F11): 現在の行を実行し、関数呼び出しがあればその関数の内部に入ります。
      • Step Out (Shift+F11): 現在の関数から抜け出し、呼び出し元のコードに戻ります。
      • Restart (Ctrl+Shift+F5 / Cmd+Shift+F5): プログラムを最初から実行し直します。
      • Stop (Shift+F5 / Cmd+Shift+F5): デバッグセッションを終了し、プログラムの実行を停止します。
    • 変数ビュー: デバッグビューの左上には「Variables」パネルがあります。現在のスコープ（関数やブロック）内で有効なローカル変数やグローバル変数の値を表示します。変数の内容を展開して構造体や配列の要素を確認することもできます。
    • ウォッチビュー: 「Watch」パネルでは、特定の変数や式の値を継続的に監視できます。デバッグ中に値がどのように変化するかを確認するのに便利です。プラスボタンをクリックして監視したい変数名や式を入力します。
    • コールスタックビュー: 「Call Stack」パネルは、現在実行が一時停止している場所に至るまでの関数呼び出しの経路を表示します。各スタックフレームをクリックすることで、その関数が呼び出された時点のスコープ（ローカル変数など）を確認できます。
    • ブレークポイントビュー: 「Breakpoints」パネルでは、現在設定されているブレークポイントの一覧を表示・管理できます。ブレークポイントの一時的な無効化や削除が可能です。
    • デバッグコンソール: ターミナルパネルの横に「Debug Console」タブが表示されることがあります。プログラムからの標準出力や、デバッガへのコマンド入力（GDB/LLDBコマンドなど）に使用できます。

これらのデバッグ機能を使うことで、プログラムの実行フローを追いかけたり、予期しない変数の値を確認したりして、問題の原因を特定できます。

Step 7: IntelliSense の設定（c_cpp_properties.json）

C/C++拡張機能の最も便利な機能の一つがIntelliSenseです。コードの入力中に候補を表示したり、エラーや警告をリアルタイムで検出したり、定義元へジャンプしたりといった機能を提供します。これらの機能が正しく動作するためには、コンパイラへのパスや、プロジェクトで使用するヘッダーファイルやライブラリのインクルードパスをVS Codeに知らせる必要があります。この設定は .vscode/c_cpp_properties.json ファイルで行います。

通常、C/C++拡張機能はインストールされているコンパイラを自動検出し、基本的な c_cpp_properties.json を生成しますが、プロジェクト固有の設定が必要な場合があります。

  1. c_cpp_properties.json ファイルの作成/編集:

    • コマンドパレット (Ctrl+Shift+P / Cmd+Shift+P) を開きます。
    • C/C++: Edit Configurations (UI) または C/C++: Edit Configurations (JSON) と入力して選択します。UIエディターの方が直感的ですが、詳細な設定はJSONエディターの方が柔軟です。
    • .vscode フォルダ内に c_cpp_properties.json ファイルが生成/開かれます。

  2. 設定の理解と編集:

    • c_cpp_properties.json は、複数のデバッグ構成と同様に configurations という配列を持ちます。それぞれの構成（例: “Win32”, “Linux”）に対して異なる設定を定義できます。
    • 主要な設定項目は以下の通りです。

    json
    {
    "configurations": [
    {
    "name": "Win32", // 構成の名前
    "includePath": [
    "${workspaceFolder}/**", // プロジェクトルート以下の全てのサブディレクトリ
    "C:/msys64/ucrt64/include/**" // 例: MSYS2 MinGW-w64 の標準ライブラリパス
    // その他、プロジェクトで使う外部ライブラリのインクルードパスなどを追加
    ],
    "defines": [
    "_DEBUG",
    "UNICODE",
    "_UNICODE"
    // プリプロセッサ定義を追加
    ],
    "windowsSdkVersion": "10.0.19041.0", // Windows SDK を使用する場合
    "compilerPath": "C:/msys64/ucrt64/bin/g++.exe", // 使用するコンパイラ実行ファイルへの正確なパス
    "cStandard": "c11", // C 標準を指定
    "cppStandard": "c++17", // C++ 標準を指定
    "intelliSenseMode": "windows-gcc-x64" // IntelliSense モード。OS, コンパイラ, アーキテクチャを考慮
    },
    {
    "name": "Linux", // Linux 構成の例
    "includePath": [
    "${workspaceFolder}/**",
    "/usr/include/**" // Linux システムの標準インクルードパス
    // 必要に応じて他のパスを追加
    ],
    "defines": [],
    "compilerPath": "/usr/bin/g++", // Linux の g++ パス
    "cStandard": "c11",
    "cppStandard": "c++17",
    "intelliSenseMode": "linux-gcc-x64" // Linux の IntelliSense モード
    }
    // macOS 構成なども追加可能
    ],
    "version": 4
    }
    * name: 構成の名前です。VS Codeウィンドウ右下にあるステータスバーに表示され、クリックして切り替えられます。
    * includePath: 最も重要。C/C++のヘッダーファイルがあるディレクトリへのパスを文字列の配列として指定します。VS Codeがコード補完やエラー検出のためにこれらのディレクトリを検索します。${workspaceFolder} はプロジェクトのルートディレクトリ、** は全てのサブディレクトリを再帰的に検索することを意味します。プロジェクトで使用する標準ライブラリや外部ライブラリのヘッダーパスをここに追加しないと、「iostream が見つかりません」といったエラーが表示されます。
    * defines: プリプロセッサシンボルを文字列の配列として指定します。#ifdef や #ifndef ディレクティブに影響します。
    * compilerPath: 使用するコンパイラ実行ファイルへの正確なパスを指定します。この設定は、IntelliSenseが使用する標準インクルードパスやプリプロセッサ定義をコンパイラから自動的に取得するために使用されます。システムPATHに設定されていても、ここに明示的に指定することでIntelliSenseの精度が向上する場合があります。
    * cStandard, cppStandard: 使用するC/C++の規格を指定します。
    * intelliSenseMode: 使用するOS、コンパイラ、アーキテクチャに最適なIntelliSenseモードを指定します。例えば、WindowsでGCCを使う場合は windows-gcc-x64、LinuxでGCCなら linux-gcc-x64、macOSでClangなら macos-clang-x64 などです。この設定はIntelliSenseの動作に大きく影響します。

  3. IntelliSense の更新:

    • c_cpp_properties.json を保存すると、C/C++拡張機能は新しい設定を読み込み、IntelliSenseエンジンを再起動します。ステータスバーのC/C++表示が更新され、IntelliSenseが正しく機能するようになるはずです。
    • もし .vscode フォルダがない状態でプロジェクトを開いた場合は、VS Codeが自動的に基本的な c_cpp_properties.json を生成しようとすることがあります。また、コマンドパレットからいつでも手動で生成・編集できます。
    • CMake Tools を使用している場合、CMake Tools は CMakeLists.txt を解析し、自動的に c_cpp_properties.json を生成・更新してくれます。この場合、手動で編集する必要はほとんどありません。

IntelliSenseが正しく設定されると、コードの入力が格段にスムーズになり、コンパイルエラーになる前に問題を早期に発見できるようになります。

Step 8: その他の便利な機能とワークフロー

VS CodeにはC++開発をさらに効率化する様々な機能があります。

  • コード整形:
    • Shift+Alt+F / Shift+Option+F でドキュメント全体を整形できます。C/C++拡張機能は基本的な整形ルールを持っていますが、clang-format 拡張機能や設定を使用すると、より詳細な整形スタイルを適用できます（例: Googleスタイル、LLVMスタイルなど）。
    • ファイル保存時に自動的に整形を行う設定 (editor.formatOnSave: true) も便利です。
  • スニペット:
    • よく使うコードのひな形を素早く挿入できます。例えば、「main」と入力してTabキーを押すと main 関数の基本構造が挿入されるなどです。C/C++拡張機能にも標準のスニペットが含まれています。
  • Peek Definition / Go to Definition:
    • 関数やクラス、変数の上で右クリックし、「Peek Definition」（定義をポップアップ表示）や「Go to Definition」（定義元ファイルにジャンプ）を選択すると、コードの定義を素早く参照できます。
  • Find All References:
    • 変数や関数がコード中のどこで使われているかを一覧表示します。
  • Rename Symbol:
    • 変数名や関数名などを一括で安全にリネームできます。
  • 統合ターミナルでの作業:
    • tasks.json やデバッグ機能だけでなく、統合ターミナルで make, cmake, git といった様々なコマンドを実行できます。複数のターミナルを開いて作業することも可能です。
  • Git 統合:
    • VS CodeはGitとの連携機能が充実しています。ソース管理ビュー (Ctrl+Shift+G / Cmd+Shift+G) で、変更ファイルの確認、ステージング、コミット、ブランチ操作、リモートリポジトリとの同期などがGUIで簡単に行えます。C++プロジェクトでも当然ながらGitは必須のツールです。

これらの機能を活用することで、VS CodeでのC++開発ワークフローをより効率的で快適なものにできます。

トラブルシューティングとよくある問題

VS CodeやC++開発環境の構築では、いくつかの一般的な問題に遭遇することがあります。

  1. g++ や clang++ などコンパイラが見つかりません:

    • エラーメッセージ例: “command ‘g++’ not found”
    • 原因: コンパイラが正しくインストールされていないか、環境変数 PATH にコンパイラ実行ファイルへのパスが設定されていない。
    • 解決策:
      • Step 0 に戻り、コンパイラ（MinGW/MSYS2, Xcode Command Line Tools, build-essentialなど）が正しくインストールされているか確認します。
      • システムの環境変数 PATH に、コンパイラ実行ファイル（例: g++.exe, g++）が含まれるディレクトリが追加されているか確認します。設定を変更した場合は、VS Codeやターミナルを再起動してください。
      • tasks.json や launch.json の command や program に、コンパイラや実行ファイルの絶対パスを指定してみる。

  2. インクルードファイルが見つかりません（例: <iostream> が波線になる）:

    • エラーメッセージ例: “#include <iostream> is not found”
    • 原因: C/C++拡張機能が標準ライブラリやプロジェクト固有のヘッダーファイルの場所を認識できていない。c_cpp_properties.json の設定が不適切。
    • 解決策:
      • Step 7 を参照し、.vscode/c_cpp_properties.json ファイルを開きます。
      • includePath に、標準ライブラリ（例: MSYS2 MinGW-w64 の ucrt64\include や mingw64\include、Linux の /usr/include など）や、プロジェクトで使っているヘッダーファイルがあるディレクトリへのパスが正しく設定されているか確認します。${workspaceFolder}/** はほとんどの場合含めるべきです。
      • compilerPath に、使用しているコンパイラの正確なパスが設定されているか確認します。設定されていれば、IntelliSenseがコンパイラから標準インクルードパスを自動取得できます。
      • intelliSenseMode が使用しているOS、コンパイラ、アーキテクチャに合っているか確認します（例: windows-gcc-x64, linux-gcc-x64, macos-clang-x64）。
      • c_cpp_properties.json を保存し、VS Code のステータスバーの C/C++ 表示が更新されるのを待ちます。問題が解決しない場合は、コマンドパレットから C/C++: Reset IntelliSense Cache and Rescan Includes を試してみてください。

  3. ビルドタスク (tasks.json) が失敗します:

    • 原因: tasks.json の command や args の設定が間違っている。ファイルパスが間違っている。コンパイルエラーが発生している。
    • 解決策:
      • ターミナルパネルでビルドタスクの出力メッセージを詳しく確認します。コンパイラが出力したエラーメッセージ（通常はファイル名、行番号、エラー内容を含む）が表示されているはずです。
      • tasks.json の command で指定したコマンド名（例: g++）が、統合ターミナルで手動で実行できるか確認します。
      • args で指定したファイル名やオプションが正しいか確認します。ファイルパスは ${workspaceFolder} などの変数を使って、プロジェクトルートからの相対パスで指定するのが安全です。
      • cwd が正しく設定されているか確認します。通常は ${workspaceFolder} で良いでしょう。

  4. デバッグが開始できません (launch.json) またはブレークポイントで停止しません:

    • エラーメッセージ例: “Unable to start debugging. check your launch.json configuration.”
    • 原因: launch.json の設定が間違っている。実行可能ファイルへのパス (program) が間違っている。コンパイル時にデバッグ情報 (-g) が含まれていない。使用するデバッガ (MIMode, miDebuggerPath) の設定が間違っている。
    • 解決策:
      • .vscode/launch.json ファイルを開き、設定を確認します。
      • program で指定した実行可能ファイルへのパスが正しいか確認します。ファイルが存在しない、または古い可能性があります。preLaunchTask を設定して、デバッグ実行前に必ず最新の実行可能ファイルがビルドされるようにすると良いでしょう。
      • コンパイルタスク (tasks.json または CMake) で、実行可能ファイルをビルドする際に -g フラグ を付けているか確認します。デバッグ情報がないとデバッガはブレークポイントを設定したり変数を調べたりできません。
      • MIMode (gdb, lldb) と miDebuggerPath が、お使いのOSとコンパイラ環境に合っているか確認します。特に miDebuggerPath は、デバッガ実行ファイルへの正確なパス（例: C:/msys64/ucrt64/bin/gdb.exe）を指定する必要がある場合があります。
      • ブレークポイントが正しく設定されているか確認します（赤い丸が表示されているか）。ブレークポイントを設定できない行（コメント行、空行など）には設定できません。
      • プログラムが非常に短い場合（例: “Hello, World!” を出力してすぐに終了する場合）、ブレークポイントに到達する前に終了してしまうことがあります。その場合は、main 関数の先頭で強制的に停止する stopAtEntry: true を launch.json に追加してみるか、プログラムの最後に std::cin.get(); などを追加して一時停止させてみると良いでしょう（ただし、これはデバッグのための一時的な手段です）。
      • 外部コンソール (externalConsole: true) が必要なプログラム（例: 標準入力を受け付けるプログラムで、VS Codeのデバッグコンソールが入力に対応していない場合など）では、この設定を確認します。

これらの問題のほとんどは、VS Codeの出力パネル（特にTerminalタブやDebug Consoleタブ）、Problemsビュー、そして各設定ファイル（tasks.json, launch.json, c_cpp_properties.json）の内容を注意深く確認することで解決できます。

まとめ

この記事では、VS CodeをC++開発環境として活用するための詳細な手順を解説しました。

  1. 開発環境の準備: C++コンパイラ、デバッガ、ビルドツールをOSに合わせてインストールしました（MinGW/MSYS2, Xcode Command Line Tools, build-essential）。
  2. VS Code のインストールと設定: VS Code本体と、C++開発に必須の拡張機能（C/C++など）をインストールしました。
  3. 基本ワークフロー: 簡単なC++プログラムを作成しました。
  4. コンパイル（ビルド）: 統合ターミナルでの手動コンパイル、VS Codeのビルドタスク（tasks.json）、そしてビルドシステムCMakeを使った方法を学びました。tasks.json の設定方法、特に command, args, -g, -Wall オプションの重要性を理解しました。
  5. 実行: 統合ターミナルやデバッグ機能を使ってプログラムを実行する方法を確認しました。
  6. デバッグ: VS Codeの強力なデバッグ機能の使い方、デバッグ構成ファイル（launch.json）の設定方法、ブレークポイント、変数、コールスタックの確認方法などを学びました。program, MIMode, preLaunchTask, -g フラグの関連性を理解しました。
  7. IntelliSense の設定: コード補完やエラー検出に不可欠な c_cpp_properties.json ファイルの役割と設定方法（includePath, compilerPath, intelliSenseMode など）を学びました。
  8. その他の機能: コード整形、スニペット、定義ジャンプ、Git統合といった便利な機能にも触れました。
  9. トラブルシューティング: よくある問題とその解決策を具体的に示しました。

VS Codeは、これらの設定ファイルを適切に構成することで、フル機能のIDEに匹敵する快適なC++開発環境を提供します。最初は tasks.json や launch.json、c_cpp_properties.json の設定に戸惑うかもしれませんが、一度理解してしまえば、プロジェクトのニーズに合わせて柔軟にカスタマイズできるようになります。

この記事が、皆様のVS Codeを使ったC++開発の助けとなれば幸いです。ぜひ、VS CodeとC/C++拡張機能の強力な機能を活用して、効率的で楽しいC++開発を進めてください。

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール