
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";
}
#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";
}
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
}
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; // エラー!
}
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 << " ";
}
}
#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を付けた場合、この行はエラーになる
}
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;
}
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"; // 実行時計算でもよい
}
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;
}
#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";
}
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