C++キーワードは言語が予約した特別な単語であり、変数名や関数名などに使用できません。これらはプログラムの動作、型、フローなどを制御します。

1. 基本データ型(最もよく使う)

キーワード 意味(初心者向け) 例 / 説明 注意事項
bool 真偽型で、true / false のみ bool ok = true; 条件判断の核心
char 単一文字(通常1バイト) char c = 'A'; シングルクォートを使う
wchar_t ワイド文字(中国語などのサポートによく使う) wchar_t wc = L'中'; 2または4バイト、プラットフォームによる
char8_t UTF-8文字(C++20で追加) char8_t c8 = u8'好'; 現代のUnicodeプログラミング
char16_t UTF-16文字(C++11)
char32_t UTF-32文字(C++11)
int 整数(通常4バイト) int age = 18; 最もよく使う整数型
short 短整数(通常2バイト) short s = 1000; 省スペース時に使う
long 長整数(少なくとも4バイト、一般的には8バイト) long l = 1234567890L; Lサフィックスを付ける
long long より長い整数(少なくとも8バイト、C++11で正式化) long long big = 1LL<<60; 大きな数値を扱う
float 単精度浮動小数点数 float f = 3.14f; fサフィックスを付ける
double 倍精度浮動小数点数(デフォルトの浮動小数点型) double pi = 3.1415926535; 精度がより高い
void 型なし(関数が値を返さない、ポインタの汎用など) void func(); 関数宣言によく見られる
unsigned 符号なし(intやlongなどと組み合わせる) unsigned int id = 4000000000u; 範囲がより広いが、負数を表せない

2. 変数/オブジェクトのライフサイクルとストレージ(Storage & Duration)

キーワード 意味(初心者向け) 例 / 一般的な使い方 現代的な推奨
auto コンパイラに型を自動推論させる(C++11以降で最も重要な使い方) auto x = 3.14; → double 強く推奨、コードを書く際に最もよく使う
const 定数、変更不可 const int MAX = 100; #define より安全で、型チェックがある
static 静的ストレージ(ファイル内共有、クラスメンバー共有、関数内で値を保持) static int count = 0; クラス静的メンバーはクラス外で初期化が必要
extern 変数/関数が別の場所で定義されていることを宣言(複数ファイルで使用) extern int globalVar; 複数ファイルのプロジェクトでよく使う
thread_local 各スレッドが自分専用のものを持つ(C++11) マルチスレッドプログラミング
register レジスタに置くことを推奨(現代のコンパイラはほとんど無視) 基本的に使わない、時代遅れ
mutable constメンバー関数がそのメンバーを変更するのを許可する クラス内の特殊な場面

3. クラスとオブジェクト指向の核心(OOP基礎)

キーワード 意味(初心者向け) 例 / 説明 重要度
class クラスを定義する(デフォルトでprivate) class Student { ... }; ★★★★★
struct 構造体を定義する(デフォルトでpublic、Cと互換) struct Point { int x,y; }; ★★★★
public パブリックメンバー、誰でもアクセスできる
private プライベートメンバー、このクラスとフレンドだけがアクセスできる
protected プロテクトメンバー、このクラス + サブクラス + フレンドがアクセスできる
this 現在のオブジェクトを指すポインタ this->age = 18; 同名の引数を区別するためによく使う
friend フレンド(private/protectedへのアクセスを許可) friend class Utils; 使うことは少なく、カプセル化を壊すので慎重に
virtual 仮想関数(多態性を実現) virtual void draw() = 0; 多態性の核心
override これがオーバーライドであると明示的に宣言(C++11、付けることを推奨) void draw() override; スペルミスを防ぐ
final 継承の禁止/オーバーライドの禁止(C++11) class My final {} 設計意図が明確
explicit 暗黙変換を禁止(単一引数コンストラクタで最も一般的) explicit MyClass(int x); 意図しない変換を防ぐ

4. メモリ管理とポインタ関連

キーワード 意味(初心者向け) 例 / 説明 現代的な推奨
new 動的メモリ割り当て(ポインタを返す) int* p = new int(5); できるだけスマートポインタを使う
delete newで割り当てたメモリを解放 delete p; delete[] arr; ペアで使い、メモリリークを避ける
nullptr ヌルポインタ定数(C++11、NULLの代わりとして推奨) int* ptr = nullptr; 強く推奨

5. 強制型変換(4種のcast、安全性は減少)

キーワード 意味(初心者向け) 安全性 推奨される使用シーン
static_cast コンパイル時変換(関連する型、数値変換など) 高 日常で最もよく使う
const_cast constやvolatileを付け外しする 中 ほとんど使わない、危険
dynamic_cast 実行時に安全なダウンキャスト(多態クラス) 高 継承体系の中で型をチェック
reinterpret_cast 低水準で危険なビットパターンの再解釈(ポインタ間の任意変換) 低 ほとんど使わない(ハードウェア連携など)

6. フロー制御(最も基礎)

キーワード 意味(初心者向け) 例
if / else 条件判断(条件を満たせば実行、満たさなければ別の部分を実行) int a = 8; if (a > 10) { cout << "大于10"; } else { cout << "不大于10"; }
switch 多分岐選択(整数/列挙型/char型のみサポート) int score = 9; switch (score) { case 9: cout << "优秀"; break; default: cout << "普通"; }
case / default switch内の分岐ラベル(caseは値に一致、defaultは一致しなかったすべてのケースに一致) char ch = 'a'; switch (ch) { case 'a': cout << "字母A"; break; default: cout << "其他字符"; }
for カウント/範囲ループ(ループ回数が既知のシーンに適する) for (int i=0; i<10; i++) { cout << i; }(カウントループ)
vector<int> v={1,2,3}; for (int num : v) { cout << num; }(範囲ループ)
while 先に判断してから実行(ループ回数が未知、条件を満たす間だけループ) int i=1; while (i<=5) { cout << i; i++; }
do まず少なくとも1回実行し、それから判断(ループ回数が未知、最初の実行を保証) int i=1; do { cout << i; i++; } while (i<=5);
break 現在のループ/switch分岐を抜ける(直接終了し、後続の内容は実行しない) for (int i=0; i<10; i++) { if (i==5) break; cout << i; }(ループを抜ける)
switch (score) { case 9: break; }(switch分岐を抜ける)
continue 今回のループの残りをスキップし、直接次のループへ進む for (int i=0; i<10; i++) { if (i%2==0) continue; cout << i; }(奇数だけを出力)
return 関数の結果を返す(戻り値のある関数)またはvoid関数を途中で終了させる int add(int a, int b) { return a + b; }(関数の結果を返す)
void print() { if (1) return; cout << "此行不会执行"; }(void関数を途中で終了)

7. 例外処理(現代C++でもよく使うが、第一選択ではない)

try / catch / throw

8. テンプレートと現代のジェネリック(中上級)

template、typename、concept(C++20)、requires(C++20)

9. その他重要だが、それほど頻繁に出現しないもの

  • constexpr(C++11):コンパイル時定数/関数
  • inline:関数のインライン化を推奨(現代ではヘッダーファイル定義によく使う)
  • enum:列挙型(現代ではenum classを推奨)
  • namespace / using:名前空間管理
  • sizeof:型/オブジェクトのバイトサイズを求める
  • typeid:実行時型情報(ほとんど使わない)
  • asm:インラインアセンブリ(ほとんど使わない)
  • goto:ジャンプ(強く非推奨、構造を壊す)
  • export:C++20以前のテンプレートエクスポート(現在はほぼ無意味)

例

1. auto(自動型推論)

コンパイラに型を書かせて、コードをより簡潔にし、間違いを減らす。

例

#include <iostream>
#include <vector>
#include <string>

int main() {
    auto a = 42;                // int に推論される
    auto b = 3.14;              // double に推論される
    auto c = "hello";           // const char* に推論される
    auto d = std::string("world"); // std::string に推論される
    auto vec = std::vector{1, 2, 3}; // std::vector<int> に推論される

    std::cout << a << " " << b << " " << c << " " << d << "\n";
    for (auto x : vec) {        // 範囲for文ではautoがよく使われる
        std::cout << x << " ";
    }
    std::cout << "\n";
}

出力:

42 3.14 hello world
1 2 3

2. const(定数)

変数が誤って変更されるのを防ぎ、より安全なコードを書けます。

例

#include <iostream>

int main() {
    const int MAX = 100;     // 初期化必須、変更不可
    // MAX = 200; // エラー!変更できません

    const double PI = 3.14159;
    std::cout << "円周率 ≈ " << PI << "\n";

    int x = 10;
    const int* p = &x;       // ポインタが指す内容は変更不可
    // *p = 20; // エラー!
    x = 30;                  // ただしx自体は変更可能
    std::cout << *p << "\n";
}
圆周率 ≈ 3.14159
30

3. static(静的)

変数を「より長く生かす」もので、カウントやデータ共有によく使われます。

例

#include <iostream>

void counter() {
    static int count = 0;   // 一度だけ初期化され、関数が終了しても破棄されない
    count++;
    std::cout << "第 " << count << " 回目の呼び出し\n";
}

int main() {
    counter();   // 1
    counter();   // 2
    counter();   // 3
}

出力:

第 1 次调用
第 2 次调用
第 3 次调用

4. nullptr(現代のヌルポインタ)

NULL より安全で明確であり、型の混乱を避けられます。

例

#include <iostream>

int main() {
    int* p1 = NULL;       // 旧式(非推奨)
    int* p2 = nullptr;    // 現代C++の推奨記法

    if (p2 == nullptr) {
        std::cout << "p2 はヌルポインタ\n";
    }

    // nullptr はポインタにのみ代入でき、整数には代入できない
    // int x = nullptr; // エラー!
}

出力:

p2 是空指针

5. range-based for(for(auto : ) 範囲forループ)

コンテナを走査する最も簡単で安全な方法です。

例

#include <iostream>
#include <vector>

int main() {
    std::vector<int> scores {85, 92, 78, 95};

    // 従来の書き方
    for (size_t i = 0; i < scores.size(); ++i) {
        std::cout << scores[i] << " ";
    }
    std::cout << "\n";

    // 現代の書き方(推奨)
    for (auto score : scores) {
        std::cout << score << " ";
    }
    std::cout << "\n";

    // 要素を変更する場合は参照を使う
    for (auto& score : scores) {
        score += 5;
    }
    for (auto score : scores) {
        std::cout << score << " ";
    }
}

出力:

85 92 78 95 
85 92 78 95 
90 97 83 100

6. explicit(暗黙変換の禁止)

意図しない型変換によるバグを防ぎます。explicit を付けるとより厳密になります。

例

#include <iostream>

class Distance {
private:
    double meters;
public:
    // explicit Distance(double m) : meters(m) {} // explicitを付けるとより安全
    Distance(double m) : meters(m) {}               // 付けないと暗黙変換される

    double get() const { return meters; }
};

void print(double d) {
    std::cout << "距離: " << d << " メートル\n";
}

int main() {
    Distance d = 500;          // コンストラクタがexplicitでない場合、これは許可される
    print(d);                  // Distance を double に暗黙変換
    // print(500); // explicitを付けた場合、この行はエラーになる
}

出力(explicitなしの場合):

距离: 500 米

7. override(仮想関数の明示的なオーバーライド)

override を書くことで、コンパイラが本当に仮想関数をオーバーライドしているかチェックしてくれます。

例

#include <iostream>

class Animal {
public:
    virtual void speak() const {
        std::cout << "何らかの動物の鳴き声\n";
    }
};

class Dog : public Animal {
public:
    void speak() const override {          // overrideを付けるのが最も安全
        std::cout << "ワンワン!\n";
    }
};

int main() {
    Animal* pet = new Dog();
    pet->speak();
    delete pet;
}

出力:

ワンワンワン!

8. constexpr(コンパイル時計算)

計算をコンパイル時に完了させ、プログラムをより高速かつ安全にします。

例

#include <iostream>

constexpr int factorial(int n) {
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

int main() {
    constexpr int f5 = factorial(5);   // コンパイル時に 120 を計算
    std::cout << "5! = " << f5 << "\n";

    int x = 6;
    // constexpr int f6 = factorial(x); // エラー!xは定数ではない
    std::cout << "6! = " << factorial(x) << "\n"; // 実行時計算でもよい
}

出力:

5! = 120
6! = 720

9. using(名前空間 + 型エイリアス)

using は名前空間を簡略化できるだけでなく、読みやすい型エイリアスも作れます。

例

#include <iostream>
#include <vector>

// 従来のtypedef
typedef std::vector<int> IntVec;

// 現代のusing(より柔軟で、テンプレート化可能)
using StringVec = std::vector<std::string>;

int main() {
    using std::cout;           // cout だけを導入
    using std::endl;

    IntVec v1 {1, 2, 3};
    StringVec v2 {"りんご", "バナナ"};

    cout << v1.size() << " " << v2.size() << endl;
}

出力:

3 2

10. enum class(強型付け列挙型)

普通の enum より安全で、誤って整数と混同されることがありません。

例

#include <iostream>

enum class Color { Red, Green, Blue };   // 強い型付けなので、intに暗黙変換されない

int main() {
    Color c = Color::Green;

    // if (c == 1) {} // エラー!intと直接比較できない
    if (c == Color::Green) {
        std::cout << "緑です\n";
    }

    // intに変換したい場合は明示的な変換が必要
    std::cout << "内部値: " << static_cast<int>(c) << "\n";
}

出力:

是绿色
底层值: 1