はじめに
Hello World
すべての C++ プログラムは main() から始まります。<iostream> は std::cout(標準出力)と std::cin(標準入力)を提供します。std:: プレフィックスは標準名前空間を参照します;using namespace std; で回避できますが、グローバル名前空間を汚染するためヘッダでは推奨されません。
#include <iostream>
int main() {
std::cout << "Hello, World!" << std::endl;
return 0;
}変数と auto
auto は初期化子から型を推論します(C++11)。型が明らかまたは冗長な場合(イテレータ)に auto を使用します。const は値を不変にし;constexpr はコンパイル時に評価し、バイナリに埋め込まれる真の定数にします。
int age = 30;
double pi = 3.14159;
char grade = 'A';
bool is_dev = true;
std::string name = "Alice";
auto x = 42; // int
auto y = 3.14; // double
const double TAX = 0.08;入力と出力
std::getline はスペースを含む完全な行を読み取りますが、std::cin >> は空白で停止します。両者を混用するとバッファに改行が残ります;getline と >> の間に std::cin.ignore() を呼び出して破棄してください。
#include <iostream>
#include <string>
int main() {
std::string name;
int age;
std::cout << "Name: ";
std::getline(std::cin, name);
std::cout << "Age: ";
std::cin >> age;
std::cout << "Hi " << name << ", " << age << "\n";
}参照
参照は初期化時に必ず割り当てられ、別のオブジェクトに再割り当てできないエイリアスです。参照渡しはコピーを回避し、呼び出し側の変数を変更できます。高コストなコピーを避けるため、読み取り専用パラメータには const T& を使用します。
int x = 10;
int &ref = x; // alias for x
ref = 20;
std::cout << x; // 20
void increment(int &n) { n++; }
int a = 5;
increment(a); // a is now 6型変換
C スタイルのキャストより static_cast を優先してください — 明示的でコンパイル時にチェックされ、意図が明確になります。std::stoi、std::stod は文字列を数値に変換;std::to_string は逆を行います。不正入力での std::out_of_range に注意してください。
double d = 3.99;
int i = (int)d; // C-style: 3
int j = static_cast<int>(d); // C++: 3
int n = 65;
char c = static_cast<char>(n); // 'A'
// string <-> number
int num = std::stoi("42");
std::string s = std::to_string(3.14);文字列
std::string の基礎
std::string は自身のメモリを管理し、必要に応じて成長します。C の char 配列とは異なり、長さを手動管理しません。.find() は部分文字列が見つからない場合 std::string::npos(巨大な値)を返すため、常に npos と比較してください。
#include <string>
std::string s = "Hello";
std::cout << s.length(); // 5
std::cout << s[0]; // H
s += ", World!";
std::cout << s; // Hello, World!
std::cout << s.substr(0, 3); // Hel
std::cout << s.find("World"); // 7比較と検索
比較は辞書順です。.find() は前方検索、.rfind() は後方検索します。両方とも見つからない場合 std::string::npos を返すため、結果を boolean として扱うのではなく常に npos と比較してください。
std::string a = "apple", b = "banana";
if (a == b) { /* equal */ }
if (a < b) { /* apple comes before banana */ }
if (a.find("pp") != std::string::npos) {
std::cout << "found\n";
}
size_t pos = a.rfind("p"); // last occurrenceStringstream
stringstream は文字列と型付き値の橋渡しをし、フォーマットされた文字列の構築(バッファのような)や空白区切りのトークンの解析に便利です。直接操作より遅いですが、シリアライズとデシリアライズに非常に柔軟です。
#include <sstream>
// Build a string
std::ostringstream oss;
oss << "Name=" << "Alice" << "&Age=" << 30;
std::string result = oss.str();
// Parse tokens
std::istringstream iss("10 20 30");
int a, b, c;
iss >> a >> b >> c; // a=10, b=20, c=30Raw 文字列と複数行
Raw 文字列リテラル R"(...)" はバックスラッシュと引用符を文字通りに扱い、正規表現パターン、Windows ファイルパス、JSON/XML テンプレートに最適です。括弧内の区切り文字は任意で、例えば R"x(...)x" で ) を内部に含められます。
std::string raw = R"(C:\Users\name\file.txt)";
// No need to escape backslashes
std::string json = R"({
"name": "Alice",
"age": 30
})";char 配列と std::string
C スタイルの char 配列は手動サイズ管理が必要でエラーが起きやすいです(バッファオーバーフロー)。std::string を優先してください;const char* を期待する C API とのインターフェースには .c_str() を使用します。c_str() は文字列が存続し未変更の間のみ有効なことに注意してください。
char cstr[] = "Hello"; // null-terminated, size 6
std::string cppstr = "Hello";
#include <cstring>
std::cout << strlen(cstr); // 5
std::cout << cppstr.length(); // 5
std::string from_c = cstr; // C -> C++
const char* to_c = cppstr.c_str(); // C++ -> C数値と数学
整数型と浮動小数点型
正確なサイズがプラットフォーム間で重要な場合は <cstdint> 固定幅型(int32_t、int64_t)を使用します。' 桁区切り(C++14)は大きな数値の可読性を向上させます。double がデフォルトの浮動小数点型で、精度のために float より推奨されます。
#include <cstdint>
int32_t a = 100;
int64_t big = 9'000'000'000LL;
uint8_t byte = 255;
size_t sz = sizeof(a); // 4
float f = 1.5f; // 4 bytes
double d = 3.14159265; // 8 bytes (preferred)数値制限
<limits> は数値プロパティの型特性を提供します。ハードコードされた INT_MAX マクロの代わりにこれらを使用してください。epsilon() は浮動小数点で区別できる最小の差を与え、許容値付きで double を比較するのに便利です。
#include <limits>
std::cout << std::numeric_limits<int>::max(); // 2147483647
std::cout << std::numeric_limits<int>::min(); // -2147483648
std::cout << std::numeric_limits<double>::infinity();
std::cout << std::numeric_limits<double>::epsilon();数学関数
<cmath> は標準数学関数を提供します。C++ で整数オーバーフローは未定義動作です — int64_t を使用するか境界をチェックしてください。金融コードでは、浮動小数点は不正確なため — 整数セントまたは decimal ライブラリを検討してください。
#include <cmath>
double x = 2.5;
std::pow(x, 3); // 15.625
std::sqrt(x); // 1.581
std::abs(-5); // 5
std::floor(3.7); // 3.0
std::ceil(3.2); // 4.0
std::round(3.5); // 4.0
std::fmod(10.5, 3); // 1.5乱数
モダン C++ は rand() の代わりに <random> ライブラリを使用します。mt19937 は高品質な PRNG です。分布(uniform_int、uniform_real、normal)は rand() % N を悩ませるモジュロバイアスなしに生ビットを目的の範囲にマッピングします。
#include <random>
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister engine
std::uniform_int_distribution<int> dist(1, 100);
for (int i = 0; i < 5; i++) {
std::cout << dist(gen) << " ";
}整数オーバーフローとキャスト
符号付き整数オーバーフローは C++ で未定義動作です(コンパイラは発生しないと仮定して最適化する可能性があります)。乗算 前に常に広い型にキャストするか、境界をチェックしてください。符号なしオーバーフローは 2^n を法としてラップアラウンドし、よく定義されています。
int a = 100'000;
int b = a * a; // overflow! undefined behavior
long long safe = (long long)a * a; // OK
// Check before multiplying
if (a > 0 && b > INT_MAX / a) {
// would overflow, handle it
}制御フロー
If / Else
C++17 は初期化子付き if を導入しました:if (auto it = m.find(k); it != m.end()) { ... }。これにより変数が if/else ブロックにスコープされ、周囲のスコープをクリーンに保ち、誤った再利用を防ぎます。
int score = 85;
if (score >= 90) {
std::cout << "A\n";
} else if (score >= 80) {
std::cout << "B\n";
} else {
std::cout << "C\n";
}Switch
意図しないフォールスルーを防ぐため常に break を含めてください。C++17 の [[fallthrough]] 属性は意図的なフォールスルーを文書化し警告を抑制します。switch は整数型と enum 型で動作し、文字列や float では動作しません。
int day = 3;
switch (day) {
case 1: std::cout << "Mon"; break;
case 2: std::cout << "Tue"; break;
case 3: std::cout << "Wed"; break;
default: std::cout << "Other";
}For ループ
範囲ベース for はコンテナをクリーンに反復します。要素のコピーを避けるため const auto& を使用します(文字列や大きなオブジェクトに重要)。要素をその場で変更するには auto&(非 const 参照)を使用します。
// Classic for
for (int i = 0; i < 5; i++) {
std::cout << i << " ";
}
// Range-based for (C++11)
std::vector<int> v = {1, 2, 3};
for (int n : v) std::cout << n;
for (const auto &n : v) std::cout << n; // no copyWhile と Do-While
while は実行前に条件をチェック;do-while はチェック前に本体を少なくとも1回実行します。do-while は入力検証とメニューループに便利です — 本体が条件評価の前に実行される必要があるため。
int n = 5;
while (n > 0) {
std::cout << n-- << " ";
}
int x;
do {
std::cin >> x;
} while (x < 0); // runs at least onceBreak、Continue とネストされたループ
break は最も近い囲むループを終了;continue は次の反復にスキップします。C++ には Java のようなラベル付き break がありません;フラグ変数を使用するか、ループを関数に抽出して return でネストループから抜けます。
for (int i = 0; i < 10; i++) {
if (i == 3) continue; // skip 3
if (i == 7) break; // stop at 7
std::cout << i << " "; // 0 1 2 4 5 6
}
// C++ has no labeled break; use a flag
bool found = false;
for (int i = 0; i < n && !found; i++) {
for (int j = 0; j < m; j++) {
if (matrix[i][j] == target) { found = true; break; }
}
}関数とラムダ
定義と複数戻り値
C++17 の構造化束縛(auto [a, b] = ...)はタプル、ペア、構造体をクリーンに展開します。C++17 以前は std::tie または出力パラメータを使用します。値渡しでの戻りはコピー省略(RVO)により安価です。
#include <tuple>
std::tuple<int, int> divide(int a, int b) {
return {a / b, a % b};
}
auto [q, r] = divide(17, 5); // q=3, r=2 (C++17)デフォルトと inline
デフォルト引数により呼び出し側は末尾パラメータを省略できます。inline はコンパイラに関数をインライン展開するヒントです;モダンコンパイラは最適化フラグに基づいて自身で決定するため、inline は主に ODR(単一定義規則)に関するものです。
inline int power(int base, int exp = 2) {
int r = 1;
for (int i = 0; i < exp; i++) r *= base;
return r;
}
// power(3) == 9, power(2, 5) == 32関数のオーバーロード
オーバーロードにより関数は名前を共有できますがパラメータ型で異なります。コンパイラはオーバーロード解決で最適なマッチを選びます。曖昧なオーバーロードはコンパイルエラーを引き起こします;本体が型間で同一の場合はテンプレートを優先してください。
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }
std::string add(std::string a, std::string b) { return a + b; }
add(1, 2); // int version
add(1.5, 2.5); // double version
add("a", "b"); // string versionラムダ式
ラムダはインラインで匿名関数オブジェクトを作成します。[] は変数をキャプチャ:[=] 値で、[&] 参照で、[x] 特定を値で、[&x] 特定を参照で。STL アルゴリズムとコールバックに不可欠です。参照キャプチャ時のダングリング参照に注意してください。
auto square = [](int x) { return x * x; };
std::cout << square(5); // 25
int factor = 3;
auto multiply = [factor](int x) { return x * factor; };
std::vector<int> v = {1, 2, 3};
std::for_each(v.begin(), v.end(), [](int n) {
std::cout << n << " ";
});関数ポインタと std::function
std::function(<functional> から)は任意の callable を保持します :関数、ラムダ、ファンクタ。生の関数ポインタより柔軟ですが、型消去のための小さなランタイムオーバーヘッドがあります。コールバックとコンテナへの callable 格納に使用します。
#include <functional>
int add(int a, int b) { return a + b; }
int (*fp)(int, int) = add; // raw function pointer
std::function<int(int, int)> f = add; // flexible wrapper
f = [](int a, int b) { return a * b; };
std::cout << f(3, 4); // 12STL コンテナ
vector
vector は動的配列でデフォルトのコンテナ選択です。push_back は償却 O(1) です。.at() は境界チェックを行い(std::out_of_range をスロー)、operator[] は行いません。サイズが分かっている場合は再割り当てを避けるため事前に reserve() を呼び出してください。
#include <vector>
std::vector<int> v = {1, 2, 3};
v.push_back(4);
v.pop_back();
v.size(); // 3
v[0] = 0;
v.at(5); // throws std::out_of_range
for (int n : v) std::cout << n;map と unordered_map
map はキーをソート済みに保ちます(O(log n) 操作);unordered_map はハッシュを使用します(平均 O(1))。順序付き反復または範囲クエリが必要な場合は map を;純粋なルックアップ速度には unordered_map を使用します。unordered_map の反復は順不同です。
#include <map>
#include <unordered_map>
std::map<std::string, int> ordered; // sorted by key (red-black tree)
ordered["Alice"] = 30;
std::unordered_map<std::string, int> hashed; // hash table
hashed["Bob"] = 25;
for (auto &[k, v] : ordered) { // C++17 structured binding
std::cout << k << ":" << v;
}set と unordered_set
set はユニークなソート済み要素を格納します(O(log n))。unordered_set はハッシュベース版です(平均 O(1))。重複排除とメンバーシップテストに使用します。lower_bound/upper_bound で順序付きセットの範囲クエリが可能です。
#include <set>
std::set<int> s = {3, 1, 4, 1, 5};
// s contains: 1, 3, 4, 5 (sorted, unique)
s.insert(2);
s.erase(1);
if (s.count(4)) std::cout << "found";
auto it = s.lower_bound(3); // first >= 3array と deque
array は固定サイズのスタック割り当て配列で STL インターフェースを持ちます(C 配列より安全、ポインタへの崩壊なし)。deque(両端キュー)は両端で の O(1) push/pop をサポートし、先頭が O(n) の vector とは異なります。
#include <array>
#include <deque>
std::array<int, 3> arr = {1, 2, 3}; // fixed size, stack-allocated
arr.size(); // 3
std::deque<int> dq = {1, 2, 3};
dq.push_front(0);
dq.push_back(4);
// dq: 0, 1, 2, 3, 4tuple と pair
tuple は任意の型の異種値を保持します。pair は2要素タプルです。構造化束縛(C++17)で名前付き変数に分解します。要素が(キー、値)のペアである map の反復時に一般的です。
#include <tuple>
std::tuple<int, std::string, double> t = {1, "Alice", 3.14};
auto [id, name, val] = t; // C++17 structured binding
std::pair<int, int> p = {1, 2};
std::cout << p.first << p.second;
auto [a, b] = std::make_pair(10, 20);ポインタとメモリ
生ポインタ
ポインタはメモリアドレスを格納します。& はアドレスを取得し、* はデリファレンスします。ポインタ演算は配列で動作します。生ポインタは所有権を追跡せず、リークやダングリングポインタを引き起こします — 所有リソースにはスマートポインタを優先してください。
int x = 10;
int *ptr = &x; // address of x
std::cout << *ptr; // 10 (dereference)
*ptr = 20;
std::cout << x; // 20
int arr[] = {1, 2, 3};
int *p = arr;
std::cout << *(p + 1); // 2参照とポインタ
参照はより安全(null にならず、常に有効)でクリーンな構文を持ちます。関数パラメータと戻り値には参照を使用します。null が意味のある状態の場合や、指す先を再割り当てする必要がある場合にポインタを使用します。
int x = 10;
int &ref = x; // must init, cannot reseat
int *ptr = &x; // can be null, can reassign
ref = 20; // x = 20
*ptr = 30; // x = 30
// References cannot be null, safer for parameters
void foo(const std::string &s); // preferred
void bar(std::string *s); // s might be nullunique_ptr
unique_ptr はヒープオブジェクトの単独所有権です。コピーできず、ムーブのみ可能です。スコープ外に出ると自動的に削除します(RAII)。これがほとんどのユースケースのデフォルトスマートポインタです — 生ポインタに対してゼロオーバーヘッド。
#include <memory>
auto p = std::make_unique<int>(42);
std::cout << *p; // 42
// auto p2 = p; // ERROR: cannot copy
auto p2 = std::move(p); // transfer ownership
// p is now nullptrshared_ptr と weak_ptr
shared_ptr は参照カウントを使用;最後の shared_ptr が破棄されるとオブジェク トが解放されます。weak_ptr はカウントに影響せずに観察し、参照サイクルを断ち切ります。shared_ptr のサイクルは避けてください(カウントがゼロに到達しないためリークします)。
#include <memory>
auto a = std::make_shared<int>(42);
auto b = a; // both point to same object
std::cout << a.use_count(); // 2
std::weak_ptr<int> w = a; // observer, no ownership
if (auto locked = w.lock()) {
std::cout << *locked; // 42
}RAII と new/delete
RAII はリソースライフタイムをオブジェクトスコープに結び付けます:コンストラクタが取得し、デストラクタが解放します。これにより例外が伝播してもクリーンアップが保証されます。手動 new/delete より vector とスマートポインタを優先してください — それらが RAII を実装します。
// Manual new/delete (avoid in modern C++)
int *p = new int(42);
delete p;
// RAII: resource acquisition is initialization
class Buffer {
int *data;
public:
Buffer(size_t n) : data(new int[n]) {}
~Buffer() { delete[] data; } // auto cleanup
};
// Modern: use containers/smart pointers instead
std::vector<int> buf(100); // no manual delete neededクラスと OOP
クラスとコンストラクタ
メンバ初期化リスト(: name(...)、age(...))は本体実行前にメンバを初期化し、本体内での代入より効率的です。getter に const を付け、const オブジェクトでの呼び出しを許可します。std::move で文字列パラメータのコピーを回避します。
class Person {
std::string name;
int age;
public:
Person(std::string n, int a) : name(std::move(n)), age(a) {}
std::string getName() const { return name; }
int getAge() const { return age; }
};
Person p("Alice", 30);
std::cout << p.getName();アクセス修飾子とカプセル化
private メンバはクラス内のみアクセス可能;protected はサブクラスを許可;public はすべてに公開。カプセル化は実装の詳細を隠し、安定したインターフェースを公開します。デフォルトで private にし、必要なもののみ公開してください。
class Account {
private:
double balance;
protected:
std::string owner;
public:
Account(double b) : balance(b) {}
double getBalance() const { return balance; }
void deposit(double amt) { if (amt > 0) balance += amt; }
};継承と virtual
virtual はランタイムポリモーフィズムを可能にします — Animal* 経由で speak() を呼び出すと Dog のバージョンにディスパッチします。ベースクラスには常に仮想デストラクタを宣言し、ベースポインタ経由の削除で派生デストラクタが呼ばれるようにしてください。override でタイプミスをキャッチします。
class Animal {
public:
virtual void speak() { std::cout << "..."; }
virtual ~Animal() = default; // virtual destructor!
};
class Dog : public Animal {
public:
void speak() override { std::cout << "Woof"; }
};
Animal *a = new Dog();
a->speak(); // Woof (polymorphism)
delete a;抽象クラスとインターフェース
純粋仮想関数(= 0)はクラスを抽象的にします — インスタンス化できません。純粋仮想関数のみを持つクラスは Java のインターフェースのように動作します。具象サブクラスはすべての純粋仮想関数を実装するか、抽象のままです。
class Shape {
public:
virtual double area() const = 0; // pure virtual
virtual ~Shape() = default;
};
class Circle : public Shape {
double r;
public:
Circle(double r) : r(r) {}
double area() const override {
return 3.14159 * r * r;
}
};演算子オーバーロード
演算子オーバーロードによりユーザー型が +、<<、== などで動作できます。意味が直感的な場合(数学型、イテレータ)のみオーバーロードしてください。<< 演算子は friend 経由でストリーム出力によくオーバーロードされ、cout << myObject を可能にします。
class Vec2 {
double x, y;
public:
Vec2(double x, double y) : x(x), y(y) {}
Vec2 operator+(const Vec2 &o) const {
return {x + o.x, y + o.y};
}
friend std::ostream &operator<<(std::ostream &os, const Vec2 &v) {
return os << "(" << v.x << "," << v.y << ")";
}
};
Vec2 a(1, 2), b(3, 4);
std::cout << a + b; // (4,6)テンプレートとジェネリクス
関数テンプレート
関数テンプレートはコンパイル時に型固有のバージョンを生成します。コンパイラは引数から T を推論します;明示的に指定もできます。 テンプレートはゼロコスト抽象です — ランタイムオーバーヘッドなしですが、コンパイル時間とバイナリサイズが増加します。
template <typename T>
T max_val(T a, T b) {
return (a > b) ? a : b;
}
std::cout << max_val(3, 7); // int: 7
std::cout << max_val(3.14, 2.71); // double: 3.14
std::cout << max_val<std::string>("a", "b"); // explicitクラステンプレート
クラステンプレートは型全体でクラスをパラメータ化します。標準コンテナ(vector、map)はすべてテンプレートです。コンパイラがコード生成に完全な定義を必要とするため、テンプレートコードはヘッダに置く必要があります(または明示的インスタンス化を使用)。
template <typename T>
class Stack {
std::vector<T> data;
public:
void push(T v) { data.push_back(v); }
T pop() { T v = data.back(); data.pop_back(); return v; }
bool empty() const { return data.empty(); }
};
Stack<int> si;
si.push(1); si.push(2);
Stack<std::string> ss;
ss.push("hi");テンプレートの特殊化
完全特殊化は特定の型にカスタム実装を提供します。部分特殊化(クラステンプレートのみ)は型のカテゴリ(例:すべてのポインタ型)にカスタマイズします。最適化や特別扱いに便利です。
template <typename T>
T identity(T x) { return x; }
// Full specialization for bool
template <>
bool identity<bool>(bool x) {
std::cout << "bool!";
return x;
}
identity(42); // generic
identity(true); // specialized可変長テンプレート
可変長テンプレートはパラメータパック(...)経由で任意の数の引数を受け取ります。各引数を処理するために再帰します。C++17 のフォールド式で簡素化されます:(std::cout << ... << args)。std::make_shared、std::tuple で多用されます。
template <typename T>
void print(T v) { std::cout << v << "\n"; }
template <typename T, typename... Args>
void print(T first, Args... rest) {
std::cout << first << ", ";
print(rest...); // recurse
}
print(1, "hello", 3.14); // 1, hello, 3.14コンセプト(C++20)
コンセプト(C++20)は読みやすい要件でテンプレートパラメータを制約し、難解な enable_if/SFINAE を置き換えます。制約が満たされない場合、はるかに明確なエラーメッセージを生成します。std::integral、std::floating_point、std::convertible_to のような標準コンセプトを使用してください。
#include <concepts>
template <std::integral T>
T add(T a, T b) { return a + b; }
template <typename T>
requires std::floating_point<T>
T half(T x) { return x / 2; }
// Abbreviated form
auto square(std::integral auto x) { return x * x; }STL アルゴリズム
sort と find
STL アルゴリズムはイテレータ範囲 [begin, end) で動作します。sort は O(n log n) です。find は線形;ソート済み範囲には binary_search/lower_bound(O(log n))を使用します。カスタム順序付けにはカスタムコンパレータ(ラムダまたは std::greater)を渡します。
#include <algorithm>
std::vector<int> v = {3, 1, 4, 1, 5, 9};
std::sort(v.begin(), v.end()); // 1 1 3 4 5 9
std::sort(v.begin(), v.end(), std::greater<>()); // descending
auto it = std::find(v.begin(), v.end(), 4);
if (it != v.end()) std::cout << "found";transform と for_each
transform は各要素を新しい値にマッピングします(関数型言語の map のように)。for_each は副作用に関数を適用します。C++20 の ranges は begin/end イテレータなしでよりクリーンなパイプラインスタイルの v | views::transform(...) を可能にします。
std::vector<int> v = {1, 2, 3, 4};
std::vector<int> squared(v.size());
std::transform(v.begin(), v.end(), squared.begin(),
[](int x) { return x * x; });
// squared: 1 4 9 16
std::for_each(v.begin(), v.end(), [](int &x) { x *= 2; });
// v: 2 4 6 8accumulate と count
accumulate(<numeric> から)は演算で範囲をフォールドします。第3引数が初期値で結果型を決定します — double 合計には 0.0 を使用します。count は値に等しい要素数を返します;count_if は述語を使用します。
#include <numeric>
std::vector<int> v = {1, 2, 3, 4, 5};
int sum = std::accumulate(v.begin(), v.end(), 0); // 15
int product = std::accumulate(v.begin(), v.end(), 1,
std::multiplies<>()); // 120
int cnt = std::count(v.begin(), v.end(), 3); // 1copy、remove と unique
remove は実際には消去しません — マッチしない要素を前にシフトし新しい終端イテレータを返します。erase-remove イディオムのために .erase() とペアにします。unique は同様に連続重複を圧縮します;完全に重複排除するには先に sort してください。
std::vector<int> v = {1, 2, 3, 4, 5};
std::vector<int> dest;
std::copy(v.begin(), v.end(), std::back_inserter(dest));
auto end = std::remove(v.begin(), v.end(), 3); // erase-remove idiom
v.erase(end, v.end());
std::vector<int> u = {1, 1, 2, 2, 3};
u.erase(std::unique(u.begin(), u.end()), u.end()); // 1 2 3min、max と clamp
min/max は2つの値また は初期化リストの小さい方/大きい方を返します。minmax は両方をペアで返します。clamp(C++17)は値を範囲に制限し、手動の if/else 境界チェックを置き換えます — 入力検証と UI 座標に便利です。
int a = 3, b = 7;
std::cout << std::max(a, b); // 7
std::cout << std::min(a, b); // 3
auto [mn, mx] = std::minmax({3, 1, 4, 1, 5}); // mn=1, mx=5
int score = 105;
int clamped = std::clamp(score, 0, 100); // 100エラー処理
例外:try/catch
値で例外をスローし、スライスを避けるため const 参照でキャッチします。std::exception をキャッチするとベースクラス経由ですべての標準例外をキャッチします。例外は通常の制御フローではなく例外的なケース用です — スロー時にオーバーヘッドがあります。
#include <stdexcept>
try {
int x = 10, y = 0;
if (y == 0) throw std::runtime_error("division by zero");
std::cout << x / y;
} catch (const std::exception &e) {
std::cerr << "Error: " << e.what();
}標準例外階層
<stdexcept> は標準例外型を提供します。logic_error はプログラマエラー用(実行前に検出可能);runtime_error は予期しない実行時条件用です。標準 catch ブロックと統合するため、カスタム例外を std::runtime_error から派生させてください。
#include <stdexcept>
throw std::runtime_error("runtime error");
throw std::logic_error("logic error");
throw std::out_of_range("index out of range");
throw std::invalid_argument("bad argument");
throw std::bad_alloc(); // thrown by new on allocation failure
// std::exception is the base; .what() returns the messageカスタム例外
カスタム例外を標準ベースから派生させ、catch(const std::exception&) と統合します。デバッグに役立つコンテキストフィールド(ファイルパス、エラーコード)を追加します。what() が動作するよう、常にメッセージをベースコンストラクタに渡してください。
class FileError : public std::runtime_error {
public:
FileError(const std::string &msg, const std::string &path)
: std::runtime_error(msg + ": " + path), path_(path) {}
const std::string &path() const { return path_; }
private:
std::string path_;
};
try { throw FileError("not found", "data.txt"); }
catch (const FileError &e) {
std::cerr << e.what() << " at " << e.path();
}noexcept と RAII の安全性
noexcept は関数がスローしないことを約束し、コンパイラ最適化を可能にします。スローした場合、std::terminate が呼ばれます。RAII はスタック巻き戻し中にデストラクタが実行されることを保証し、例外がコールスタックを伝播してもリソースが解放されます。
void safe_op() noexcept {
// guaranteed not to throw
}
void risky() {
std::vector<int> v(1000); // RAII: cleanup on exception
throw std::runtime_error("oops");
// v's destructor still runs during stack unwinding
}アサーション
assert() はデバッグビルドで条件をチェックします;リリース(NDEBUG 定義時)では削除されるため、本番チェックには使用しないでください。バグを示す内部不変条件に使用します。ユーザー向け検証には、例外をスローするかエラーコードを返してください。
#include <cassert>
double sqrt_safe(double x) {
assert(x >= 0 && "sqrt of negative");
return std::sqrt(x);
}
// In release builds (NDEBUG defined), assert is removedファイル I/O とストリーム
ファイルの読み込み
ifstream は読み取り用にファイルを開きます。オープン成功を常に確認してください(!file は失敗時に true と評価)。getline はスペースを含む行単位で読み取ります。ストリームのデストラクタが自動的にファイルを閉じます(RAII)ので、手動クローズは不要です。
#include <fstream>
#include <string>
std::ifstream file("input.txt");
if (!file) { std::cerr << "cannot open"; return 1; }
std::string line;
while (std::getline(file, line)) {
std::cout << line << "\n";
}ファイルの書き込み
ofstream はファイルに書き込み、デフォルトで切り詰めます。追記には std::ios::app を、バイナリモードには std::ios::binary を使用します。<< 演算子は std::cout と全く同じように動作します。out.flush() または std::endl(フラッシュもする)でフラッシュします。
#include <fstream>
std::ofstream out("output.txt");
if (!out) return 1;
out << "Line 1\n";
out << "Value: " << 42 << "\n";
out.close(); // optional, destructor closes
// Append mode: std::ofstream("f.txt", std::ios::app);文字列ストリーム
ostringstream は混合型から文字列を構築します(バッファのように)。istringstream は文字列を型付き値に解析します。直接文字列操作より遅いですが、シリアライズ、URL 構築、トークン解析に非常に便利です。
#include <sstream>
// Build a string from mixed types
std::ostringstream oss;
oss << "Name=" << "Alice" << "&Age=" << 30;
std::string url = oss.str();
// Parse tokens from a string
std::istringstream iss("10 20 30");
int a, b, c;
iss >> a >> b >> c;バイナリファイル
バイナリモードは改行変換を回避し、テキストよりコンパクトです。write/read は char* とバイト数を取ります — 構造体には reinterpret_cast を使用します。注意:バイナリファイルはアーキテクチャ間でポータブルではありません(エンディアン、構造体パディングが異なります)。
#include <fstream>
struct Record { int id; double value; };
// Write
std::ofstream out("data.bin", std::ios::binary);
Record r{1, 3.14};
out.write(reinterpret_cast<char*>(&r), sizeof(r));
// Read
std::ifstream in("data.bin", std::ios::binary);
Record r2;
in.read(reinterpret_cast<char*>(&r2), sizeof(r2));フォーマット出力(C++20 fmt)
std::format(C++20)は Python スタイルのフォーマット文字列を C++ にもたらし、厄介な iomanip マニピュレータを置き換えます。古いコードには <iomanip> が setprecision、setw、setfill を提供します。{fmt} ライブラリは同じ構文の C++20 以前の人気のある代替です。
#include <format> // C++20
std::string s = std::format("Hello, {}! You are {}.", "Alice", 30);
std::cout << std::format("{:.2f}", 3.14159); // 3.14
std::cout << std::format("{:>10}", "right"); // padded
// Pre-C++20: use iomanip
#include <iomanip>
std::cout << std::fixed << std::setprecision(2) << 3.14159;スマートポインタ
unique_ptr - 排他的所有権
unique_ptr はデフォルトのスマートポインタです — 所有者が1人で十分な場合に使用 します。生ポインタに対してゼロオーバーヘッドです。make_unique が推奨されます(例外安全)。コピーできず、ムーブのみ可能。カスタムデリータで FILE* やソケットのような C リソースの RAII を可能にします。
#include <memory>
std::unique_ptr<int> p1 = std::make_unique<int>(42);
// std::unique_ptr<int> p2 = p1; // ERROR: cannot copy
std::unique_ptr<int> p2 = std::move(p1); // OK: transfer ownership
// p1 is now nullptr
// Custom deleter
auto deleter = [](FILE* f) { if (f) fclose(f); };
std::unique_ptr<FILE, decltype(deleter)> fp(fopen("f.txt", "r"), deleter);shared_ptr - 共有所有権
shared_ptr は参照カウントを使用 — 複数のポインタが同じオブジェクトを所有できます。参照カウントが 0 になるとオブジェクトは破棄されます。make_shared が推奨されます(オブジェクト + 制御ブロックの単一割り当て)。アトミック参照カウントと制御ブロックのため unique_ptr より重いです。所有権が真に共有される場合に使用します。
#include <memory>
auto p1 = std::make_shared<int>(42);
auto p2 = p1; // OK: both share ownership
std::cout << *p1 << " " << p1.use_count(); // 42 2
// Control block holds refcount + deleter + allocator
// Refcount is atomic (thread-safe), but object access is NOT
std::shared_ptr<int> p3{new int{10}}; // uses non-array new
// Thread-safe: refcount operations are atomic
// NOT thread-safe: accessing the pointed-to objectweak_ptr - サイクルの切断
weak_ptr は shared_ptr の非所有観察者です。参照カウントを増やしません。lock() で一時的に shared_ptr を取得します(オブジェクトが破棄済みの場合は null を返す)。参照サイクル(例:双方向リスト、親子関係)を断ち切り、メモリリークを防ぐために不可欠です。
#include <memory>
struct Node {
std::shared_ptr<Node> next;
std::weak_ptr<Node> prev; // weak to avoid cycle
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->prev = a; // weak_ptr from shared_ptr
// To use a weak_ptr, lock() into a shared_ptr
if (auto locked = b->prev.lock()) {
std::cout << "prev exists";
} else {
std::cout << "prev expired";
}配列付きスマートポインタ
スマートポインタは配列を管理できます。unique_ptr<T[]> は operator[] と正しい delete[] を提供します。shared_ptr<T[]> は C++17 からサポートされています。ただし、std::vector や std::array がほぼ常に優れています — より安全で使いやすく、自己文書化されています。レガシー API とのインターフェース時にのみスマート配列ポインタを使用してください。
#include <memory>
// C++17: shared_ptr supports arrays
std::shared_ptr<int[]> arr1(new int[10]);
arr1[0] = 42;
// unique_ptr with arrays (partial specialization exists)
std::unique_ptr<int[]> arr2 = std::make_unique<int[]>(10);
arr2[5] = 100;
// Prefer std::array or std::vector over raw arrays
#include <vector>
std::vector<int> v(10); // better choiceenable_shared_from_this
オブジェクトが自身への shared_ptr を返す必要がある場合、enable_shared_from_this が安全な shared_from_this() を提供します。shared_ptr<T>(this) を直接呼び出すと2番目の制御ブロックが作成され、二重解放につながります。オブジェクトは既に shared_ptr で管理されている必要があり、そうでないと shared_from_this() は bad_weak_ptr をスローします。
#include <memory>
class Widget : public std::enable_shared_from_this<Widget> {
public:
std::shared_ptr<Widget> getPtr() {
return shared_from_this(); // safe
// return shared_ptr<Widget>(this); // BAD: double delete
}
};
auto w = std::make_shared<Widget>();
auto w2 = w->getPtr(); // shares ownership, refcount = 2ムーブセマンティクスと右辺値参照
左辺値、右辺値、参照
左辺値はアイデンティティを持ち、単一の式を超えて存続します(名前付きオブジェクト)。右辺値は一時的またはリテラル値です。T& は左辺値にバインド、T&& は右辺値にバインドします。const T& は特別 — 両方にバインドします。この区別の理解がムーブセマンティクスの基盤です。
int x = 10; // x is an lvalue
int& lref = x; // lvalue reference
int&& rref = 20; // rvalue reference (binds to temporary)
// int& bad = 20; // ERROR: can't bind lref to rvalue
const int& cref = 20; // OK: const lref binds to rvalue
int y = x + 5; // (x + 5) is an rvalue (prvalue)
std::string s1 = "hi";
std::string&& rr = std::move(s1); // rr is named rvaluestd::move とムーブコンストラクタ
std::move は何もムーブしません — 右辺値にキャストし、ムーブコンストラクタ/代入が選択されるようにします。ムーブ操作は noexcept にすべきで、コンテナが再割り当て時に使用できるようにします(そうでない場合例外安全性のためにコピーにフォールバック)。ムーブ後、ソースオブジェクトは有効だが未指定の状態にあります。
class Buffer {
int* data;
size_t size;
public:
// Move constructor: steal resources
Buffer(Buffer&& other) noexcept
: data(other.data), size(other.size) {
other.data = nullptr;
other.size = 0;
}
// Move assignment
Buffer& operator=(Buffer&& other) noexcept {
if (this != &other) {
delete[] data;
data = other.data; size = other.size;
other.data = nullptr; other.size = 0;
}
return *this;
}
};
Buffer a(100);
Buffer b = std::move(a); // calls move ctor, a is now empty完全転送
完全転送は値カテゴリ(左辺値 vs 右辺値)を保持しながら引数を別の関数に渡します。推論コンテキストの T&& は「転送参照」です(右辺値参照ではありません)。std::forward<T> は条件付きでキャストします:T が T& の場合は左辺値、T が T&& の場合は右辺値。ファクトリ関数とラッパーに不可欠です。
#include <utility>
template <typename T, typename Arg>
auto make_unique(Arg&& arg) {
return std::unique_ptr<T>(new T(std::forward<Arg>(arg)));
}
template <typename... Args>
void log(Args&&... args) {
// std::forward preserves value category
log_impl(std::forward<Args>(args)...);
}
std::string s = "hello";
log(s); // Arg = std::string& (lvalue)
log(std::string()); // Arg = std::string&& (rvalue)5の法則 / ゼロの法則
5の法則:クラスがリソースを管理する場合、デストラクタ、コピーコンストラクタ、コピー代入、ムーブコンストラクタ、ムーブ代入を定義しなければなりません。ゼロの法則:RAII 型(vector、string、ス マートポインタ)を構成して、コンパイラ生成の特殊メンバが正しくなるように優先します。これでバグの多い手動リソース管理を排除します。
// Rule of Five: if you define any of these, define all 5
class Resource {
int* data;
public:
Resource(size_t n) : data(new int[n]) {}
~Resource() { delete[] data; }
Resource(const Resource& o); // copy ctor
Resource& operator=(const Resource& o); // copy assign
Resource(Resource&& o) noexcept; // move ctor
Resource& operator=(Resource&& o) noexcept; // move assign
};
// Rule of Zero: prefer to use RAII types
class Better {
std::vector<int> data; // handles everything
public:
Better() = default; // compiler-generated funcs are correct
};戻り値最適化(RVO/NRVO)
RVO/NRVO はコンパイラが呼び出し側のストレージに直接戻り値を構築し、コピー/ムーブを完全に回避できるようにします。C++17 は prvalue に対して RVO を必須にしました。return std::move(local) は絶対に書かないでください — NRVO を阻害し、(より遅い)ムーブを強制します。local を名前で返し、コンパイラに最適化させてください。
std::vector<int> makeVec() {
std::vector<int> v;
v.push_back(1); v.push_back(2);
return v; // NRVO: no copy, no move!
}
std::string makeStr() {
return std::string("hello"); // RVO
}
// C++17 guarantees RVO (mandatory copy elision) for prvalues
std::vector<int> v = makeVec(); // constructed in place
// Don't std::move return values—it disables RVO!
std::vector<int> bad() {
std::vector<int> v;
return std::move(v); // WORSE: forces move, blocks NRVO
}並行性(thread、mutex、async)
std::thread の基礎
std::thread は新しい OS スレッドを起動します。スレッドオブジェクトが破棄される前に join()(待機)または detach()(独立実行)を呼び出さなければなりません。引数はデフォルトで値渡しされます — 参照には std::ref を、ムーブ専用型には std::move を使用します。明確な理由がない限り join を優先してください。
#include <thread>
#include <iostream>
void worker(int id) {
std::cout << "Thread " << id << "\n";
}
int main() {
std::thread t1(worker, 1);
std::thread t2([]{ std::cout << "Lambda thread\n"; });
t1.join(); // wait for t1 to finish
t2.join(); // must join or detach before destruction
// t1.detach(); // runs independently (risky)
// Hardware concurrency hint
unsigned n = std::thread::hardware_concurrency();
}ミューテックスと lock guard
共有データは常にミューテックスで保護してください。std::lock_guard は最もシンプルな RAII ロックです — 構築時に取得し、破棄時に解放します。std::scoped_lock(C++17)はデッドロック回避アルゴリズムで複数のミューテックスを安全にロックします。std::unique_lock は条件変数と使用するためのより柔軟性を提供します(手動ロック/アンロック、遅延ロック)。
#include <mutex>
#include <vector>
std::mutex mtx;
std::vector<int> shared;
void safePush(int val) {
// RAII lock: unlocks even if exception thrown
std::lock_guard<std::mutex> lock(mtx);
shared.push_back(val);
} // lock released here
// std::scoped_lock (C++17) locks multiple mutexes deadlock-free
std::mutex m1, m2;
void transfer() {
std::scoped_lock lock(m1, m2); // atomic
}
// std::unique_lock: lockable/unlockable, movable
std::unique_lock<std::mutex> ul(mtx);
ul.unlock();
ul.lock();条件変数
condition_variable はスレッドが条件を待つことを可能にします。スプリアスウェイクアップを処理するため wait() に常に述語を使用してください。wait() 呼び出し時はミューテックスが unique_lock で保持されている必要があり、待機中に解放され、戻り前に再取得されます。notify_one は1つの待機者を起こし、notify_all はすべてを起こします。このパターンはスレッドセーフなキューとプロデューサ-コンシューマパイプラインを実装します。
#include <condition_variable>
#include <queue>
#include <thread>
std::mutex mtx;
std::condition_variable cv;
std::queue<int> tasks;
void producer() {
{
std::lock_guard<std::mutex> lock(mtx);
tasks.push(42);
}
cv.notify_one(); // wake one waiting consumer
}
void consumer() {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, []{ return !tasks.empty(); }); // predicate prevents spurious wakeup
int task = tasks.front();
tasks.pop();
}std::async と future
std::async はタスクを非同期に実行する高レベルの方法で、future を返します。std::launch::async は新しいスレッドを強制;std::launch::deferred は get() で遅延実行します。デフォルトポリシーはどちらかを選ぶ可能性があるため — 予測可能な動作のために明示的にしてください。より制御するには std::promise/future ペアを使用します。破棄前に常に future で get() を呼び出してください、そうしないとデストラクタがブロックする可能性があります。
#include <future>
#include <iostream>
int slowComputation() {
std::this_thread::sleep_for(std::chrono::seconds(1));
return 42;
}
// async policy: may run in new thread or deferred
auto fut = std::async(std::launch::async, slowComputation);
// do other work...
int result = fut.get(); // blocks until ready
// std::launch::async: definitely new thread
// std::launch::deferred: lazy, runs on get()
// std::launch::async | deferred: implementation chooses
// std::promise for manual control
std::promise<int> p;
std::future<int> f = p.get_future();
std::thread([&p]{ p.set_value(10); }).detach();
f.get(); // 10アトミック操作
std::atomic はプリミティブ型のロックフリーなスレッドセーフ操作を提供します。plain int より重いですが、シンプルなカウンタ/フラグにはミューテックスよりはるかに軽いです。メモリ順序付けが可視性に影響:relaxed(順序なし)、acquire/release(同期のペア)、seq_cst(デフォルト、最強)。カウンタ/フラグにはアトミックを;複雑なクリティカルセクションにはミューテックスを使用します。
#include <atomic>
#include <iostream>
std::atomic<int> counter{0};
std::atomic<bool> ready{false};
void worker() {
while (!ready.load(std::memory_order_acquire));
counter.fetch_add(1, std::memory_order_relaxed);
}
// Compare-and-swap (CAS) loop
std::atomic<int> val{0};
int expected = 0;
bool success = val.compare_exchange_weak(
expected, 1,
std::memory_order_acq_rel);
// Atomic is lock-free for most primitive types
static_assert(std::atomic<int>::is_always_lock_free);
// std::atomic_flag: guaranteed lock-free, for spinlocks
std::atomic_flag spin = ATOMIC_FLAG_INIT;
while (spin.test_and_set(std::memory_order_acquire)); // acquire
spin.clear(std::memory_order_release); // releaseテンプレートメタプログラミング
テンプレートの特殊化
テンプレートの特殊化は特定の型にカスタム実装を提供します。完全特殊化はすべてのテンプレートパラメータを固定します。部分特殊化(クラステンプレートのみ)は一部のパラメータを特殊化し、他をジェネリックのままにします。型特性、std::vector<bool>、既知の型の最適化で多用されます。