C++ 言語仕様ガイド

#include <cstdint>
#include <iostream>

int main() {
    int           a = 42;
    long long     b = 9'223'372'036'854'775'807LL; // C++14: 数値区切り
    double        c = 3.14;
    bool          d = true;
    std::size_t   e = sizeof(int); // インデックス・サイズは size_t
    int32_t  x = -100;   // 確定 32bit
    uint64_t y = 100ULL; // 確定 64bit 符号なし
    std::cout << a << " " << b << " " << c << "
";
    std::cout << std::boolalpha << d << "
"; // "true"
}

auto x = 42;       // int
auto y = 3.14;     // double
auto s = "hello";  // const char* （std::string ではない！）

std::vector<int> v = {1, 2, 3};
auto it = v.begin(); // std::vector<int>::iterator

// 参照で受け取る場合は明示
auto& ref   = v[0];       // int&（コピーなし）
const auto& cref = v[0];  // const int&（読み取り専用）

// decltype
int a = 1;
decltype(a) b = 2; // int

const int MAX = 100;          // 実行時定数
constexpr int BUF = 256;      // コンパイル時定数

constexpr int square(int n) { return n * n; }

int arr[BUF];                 // OK: constexpr なので配列サイズに使える
template<int N> struct Foo {};
Foo<square(4)> f;             // OK: コンパイル時に 16 が確定

const int rt = someFunc();    // OK: 実行時に決まる
// constexpr int err = someFunc(); // NG: constexpr 関数でなければ不可

double d = 3.7;
int i = static_cast<int>(d);       // 3（切り捨て）

// reinterpret_cast: ビットレベルの再解釈（危険）
uintptr_t addr = reinterpret_cast<uintptr_t>(&d);

// const_cast: const を外す（元が const なら UB）
const int ci = 42;
// int& ri = const_cast<int&>(ci); // 元が const なので UB！

// dynamic_cast: 実行時の安全なダウンキャスト（仮想関数を持つ型のみ）
Base* b = new Derived();
Derived* dp = dynamic_cast<Derived*>(b); // 成功: 非 null
if (!dp) { /* 変換失敗 */ }

// C++17: if 初期化文（スコープを限定できる）
if (auto it = map.find(key); it != map.end()) {
    use(it->second); // it はこの if ブロック内にスコープが限定
}

// switch の fall-through
switch (n) {
    case 1:
        doA();
        [[fallthrough]]; // 意図的な fall-through を明示
    case 2:
        doB();
        break;
    default:
        doDefault();
}

std::vector<std::string> names = {"Alice", "Bob", "Carol"};

// コピーなし読み取り
for (const auto& name : names) {
    std::cout << name << "
";
}

// 変更する場合
for (auto& name : names) {
    name += "!";
}

// インデックス付き: 従来の for
for (std::size_t i = 0; i < names.size(); ++i) {
    std::cout << i << ": " << names[i] << "
";
}

// goto による多重ループ脱出（C++ では稀）
for (int i = 0; i < N; ++i) {
    for (int j = 0; j < M; ++j) {
        if (found(i, j)) goto done;
    }
}
done:;

// 推奨: ラムダで包んで return
auto search = [&]() -> std::pair<int,int> {
    for (int i = 0; i < N; ++i)
        for (int j = 0; j < M; ++j)
            if (found(i, j)) return {i, j};
    return {-1, -1};
};
auto [r, c] = search();

void print(int n)              { std::cout << "int: " << n; }
void print(double d)           { std::cout << "double: " << d; }
void print(const std::string& s){ std::cout << "str: " << s; }

print(42);      // int: 42
print(3.14);    // double: 3.14
print("hi");    // str: hi

// デフォルト引数（末尾から省略可能）
void connect(const std::string& host, int port = 80, bool tls = false);

connect("example.com");            // port=80, tls=false
connect("example.com", 443, true); // 全部指定

int offset = 10;

// キャプチャ（コピー）
auto addOffset = [offset](int x) { return x + offset; };

// キャプチャ（参照）
auto increment = [&offset]() { ++offset; };

// STL アルゴリズムへの渡し方
std::vector<int> v = {3, 1, 4, 1, 5};
std::sort(v.begin(), v.end(), [](int a, int b){ return a > b; }); // 降順

// std::function で型消去（オーバーヘッドあり）
std::function<int(int)> fn = addOffset;
std::cout << fn(5) << "
"; // 15

// ヘッダに書ける（ODR 違反にならない）
inline int clamp(int v, int lo, int hi) {
    return v < lo ? lo : v > hi ? hi : v;
}

// constexpr 関数: コンパイル時に評価可能
constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

constexpr int f5 = factorial(5); // コンパイル時に 120
int arr[factorial(4)];           // 配列サイズにも使える

// 実行時にも呼べる
int n = 6;
int fn = factorial(n); // 実行時に計算

int x = 42;
int* p = &x;         // p は x のアドレスを保持
std::cout << *p;     // 42（デリファレンス）
*p = 100;            // x も 100 になる

// nullptr チェック
int* q = nullptr;
if (q) { /* null でなければ処理 */ }

// 構造体メンバへのアクセス
struct Point { int x, y; };
Point pt{1, 2};
Point* pp = &pt;
std::cout << pp->x;  // (*pp).x と同じ

int a = 1;
int& ref = a;  // ref は a の別名
ref = 99;      // a == 99

// const 参照: コピーなし読み取り
void printStr(const std::string& s) {
    std::cout << s; // コピーなし
}

// 参照を返す関数（変更可能）
int& getFirst(std::vector<int>& v) { return v[0]; }
getFirst(v) = 999;  // v[0] を直接変更

int x = 1, y = 2;

const int* p1 = &x;  // "const な int へのポインタ"
// *p1 = 9;           // NG: 指す先を変更不可
p1 = &y;             // OK: p1 自体は変えられる

int* const p2 = &x;  // "int へのconstポインタ"
*p2 = 9;             // OK: 指す先は変えられる
// p2 = &y;           // NG: p2 自体は変えられない

const int* const p3 = &x; // 両方 const

int add(int a, int b) { return a + b; }

// 関数ポインタ
int (*fp)(int, int) = add;
fp(1, 2); // 3

// auto で簡略化
auto fp2 = add; // int(*)(int,int)

// using でエイリアス
using BinOp = int(*)(int, int);
BinOp op = add;

// std::function: ラムダも格納可
std::function<int(int,int)> fn = [](int a, int b){ return a + b; };
fn(3, 4); // 7

// C 配列（非推奨: 関数に渡すと decay する）
int ca[5] = {1, 2, 3, 4, 5};
// sizeof(ca)/sizeof(ca[0]) で要素数取得（危険）

// std::array（推奨: 固定長）
#include <array>
std::array<int, 5> arr = {1, 2, 3, 4, 5};
arr.size();    // 5（メンバ関数でサイズ取得）
arr.at(10);    // 範囲チェック付き（越えると std::out_of_range）

// std::vector（動的サイズ）
std::vector<int> v = {1, 2, 3};
v.push_back(4);
v.size(); // 4

// C++20: std::span（サイズ付き非所有ビュー）
#include <span>
void process(std::span<int> data) { /* 配列もvectorも受け取れる */ }

#include <string>
#include <string_view>

std::string s = "Hello, World!";
s += " Bye";               // 連結
s.size();                  // 文字数
s.substr(0, 5);            // "Hello"
s.find("World");           // 7（見つからなければ std::string::npos）
s.empty();                 // false

// string_view: コピーなし参照
std::string_view sv = s;
void readOnly(std::string_view v); // const std::string& より軽量

// raw string リテラル（バックスラッシュ・改行そのまま）
std::string path  = R"(C:UsersaliceDocuments)";
std::string regex = R"(d+.d+)";

class Person {
public:
    Person(std::string name, int age) : name_(name), age_(age) {}

    const std::string& name() const { return name_; }
    int age() const { return age_; }
    void birthday() { ++age_; }

private:
    std::string name_;
    int age_;
};

Person p("Alice", 30);
p.birthday();
std::cout << p.name() << " " << p.age() << "
"; // Alice 31

class Buffer {
public:
    // 初期化リスト: コンストラクタ本体前に初期化
    Buffer(std::size_t size, char fill = 0)
        : size_(size), data_(new char[size]) {
        std::fill(data_, data_ + size_, fill);
    }

    // 委譲コンストラクタ (C++11)
    Buffer() : Buffer(256) {}

    ~Buffer() { delete[] data_; } // デストラクタで解放

private:
    std::size_t size_;
    char* data_;
};

class Counter {
public:
    void increment() { ++count_; }         // 非 const: 状態変更
    int value() const { return count_; }   // const: 変更不可

    // mutable: const 関数内でも変更可
    int cached() const {
        if (!cached_) { cache_ = expensive(); cached_ = true; }
        return cache_;
    }

    static int instances() { return s_count_; } // クラスメソッド

private:
    int count_ = 0;
    static int s_count_;       // .cpp で定義が必要
    mutable bool cached_ = false;
    mutable int cache_ = 0;
};

class NonCopyable {
public:
    NonCopyable() = default;
    ~NonCopyable() = default;

    // コピー禁止
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;

    // ムーブは許可
    NonCopyable(NonCopyable&&) = default;
    NonCopyable& operator=(NonCopyable&&) = default;
};

NonCopyable a;
// NonCopyable b = a; // コンパイルエラー
NonCopyable c = std::move(a); // OK

class Animal {
public:
    explicit Animal(std::string name) : name_(std::move(name)) {}
    const std::string& name() const { return name_; }
    virtual std::string sound() const { return "..."; }
    virtual ~Animal() = default; // 仮想デストラクタ必須

private:
    std::string name_;
};

class Dog : public Animal {
public:
    explicit Dog(std::string name) : Animal(std::move(name)) {}
    std::string sound() const override { return "Woof"; }
};

std::unique_ptr<Animal> a = std::make_unique<Dog>("Rex");
std::cout << a->sound(); // "Woof"（多態性）

class Shape {
public:
    virtual double area() const = 0;  // 純粋仮想: インスタンス化不可
    virtual void draw() const {}      // デフォルト実装あり
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    explicit Circle(double r) : r_(r) {}
    double area() const override { return 3.14159 * r_ * r_; }

private:
    double r_;
};

// final: これ以上継承・オーバーライドを禁止
class SpecialCircle final : public Circle {
public:
    using Circle::Circle;
};

Shape* s = new Circle(5.0);

// ポインタ: 失敗時は nullptr
if (Circle* c = dynamic_cast<Circle*>(s)) {
    std::cout << "Circle, area=" << c->area();
}

// 参照: 失敗時は std::bad_cast
try {
    Circle& c = dynamic_cast<Circle&>(*s);
} catch (const std::bad_cast& e) {
    std::cerr << "Bad cast
";
}

delete s;

class Vec2 {
public:
    double x, y;
    Vec2(double x, double y) : x(x), y(y) {}

    Vec2 operator+(const Vec2& o) const { return {x+o.x, y+o.y}; }
    Vec2& operator+=(const Vec2& o) { x+=o.x; y+=o.y; return *this; }
    bool operator==(const Vec2& o) const { return x==o.x && y==o.y; }

    // 出力演算子: friend 非メンバ関数
    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)

class MyBuf {
public:
    explicit MyBuf(std::size_t n) : data_(new int[n]), size_(n) {}

    // コピーコンストラクタ（ディープコピー）
    MyBuf(const MyBuf& o) : data_(new int[o.size_]), size_(o.size_) {
        std::copy(o.data_, o.data_ + size_, data_);
    }
    // コピー代入（コピー&スワップイディオム）
    MyBuf& operator=(MyBuf o) { swap(o); return *this; }

    // ムーブコンストラクタ
    MyBuf(MyBuf&& o) noexcept : data_(o.data_), size_(o.size_) {
        o.data_ = nullptr; o.size_ = 0;
    }
    // ムーブ代入
    MyBuf& operator=(MyBuf&& o) noexcept { swap(o); return *this; }

    ~MyBuf() { delete[] data_; }

private:
    void swap(MyBuf& o) noexcept {
        std::swap(data_, o.data_); std::swap(size_, o.size_);
    }
    int* data_;
    std::size_t size_;
};

#include <compare>

class Point {
public:
    int x, y;
    // <=> を定義すると <, >, <=, >= が自動生成
    auto operator<=>(const Point&) const = default;
    bool operator==(const Point&) const = default;
};

Point a{1, 2}, b{1, 3};
std::cout << (a < b);  // true（x が等しければ y で比較）
std::cout << (a == b); // false

// 単一オブジェクト
int* p = new int(42);
delete p;
p = nullptr; // dangling pointer 防止

// 配列
int* arr = new int[10]{};
delete[] arr; // delete[] を使う（delete だと UB）

// 確保失敗: std::bad_alloc がスロー
try {
    int* big = new int[1'000'000'000'000LL];
} catch (const std::bad_alloc& e) {
    std::cerr << "Out of memory
";
}

// nothrow バージョン（失敗時 nullptr）
int* q = new (std::nothrow) int;
if (!q) { /* メモリ確保失敗 */ }

// RAII の例: ファイルハンドラ
class FileHandle {
public:
    explicit FileHandle(const char* path)
        : fp_(std::fopen(path, "r")) {
        if (!fp_) throw std::runtime_error("cannot open");
    }
    ~FileHandle() { if (fp_) std::fclose(fp_); } // 例外でも必ず閉じる

    FILE* get() { return fp_; }

    // コピー禁止（ハンドルの二重解放を防ぐ）
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;

private:
    FILE* fp_;
};

{
    FileHandle f("data.txt");
    // 例外が来ても ~FileHandle() が呼ばれてクローズされる
} // スコープを抜けると自動クローズ

// よくある未定義動作の例（これらを書いてはいけない）

// 1. 符号付き整数オーバーフロー（unsigned は wrap-around で定義済み）
int x = INT_MAX;
// int y = x + 1; // UB!

// 2. 境界外アクセス
int arr[5];
// arr[5] = 0; // UB!

// 3. ヌルポインタデリファレンス
int* p = nullptr;
// *p = 42; // UB!

// 4. ダングリング参照
int& dangle() {
    int local = 1;
    return local; // UB: ローカル変数の参照を返す
}

// 5. 初期化前の値を読む
int uninit;
// std::cout << uninit; // UB!

#include <memory>

auto p = std::make_unique<int>(42);
std::cout << *p;  // 42（スコープ終了時に自動解放）

// 所有権の移転
auto q = std::move(p); // p は nullptr になる
if (!p) std::cout << "p is null
";

// カスタムデリータ
auto fp = std::unique_ptr<FILE, decltype(&fclose)>(
    fopen("f.txt", "r"), &fclose);

// ファクトリ関数パターン
std::unique_ptr<Shape> makeShape(ShapeType t) {
    switch (t) {
        case CIRCLE: return std::make_unique<Circle>(1.0);
        default:     return std::make_unique<Square>(1.0);
    }
}

auto sp1 = std::make_shared<std::string>("hello");
auto sp2 = sp1;              // 参照カウント: 2
std::cout << sp1.use_count(); // 2

// weak_ptr: 循環参照防止
struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node>   prev; // weak でないと循環参照でリーク
};

// weak_ptr の使い方
std::weak_ptr<std::string> wp = sp1;
if (auto locked = wp.lock()) { // expired してなければ shared_ptr
    std::cout << *locked;
}

#include <stdexcept>

double divide(double a, double b) {
    if (b == 0.0) throw std::invalid_argument("division by zero");
    return a / b;
}

try {
    double r = divide(10.0, 0.0);
} catch (const std::invalid_argument& e) {
    std::cerr << "Invalid: " << e.what() << "
";
} catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << "
";
} catch (...) {
    std::cerr << "Unknown exception
";
}

// 独自例外クラス
class AppError : public std::runtime_error {
public:
    AppError(int code, const std::string& msg)
        : std::runtime_error(msg), code_(code) {}
    int code() const { return code_; }
private:
    int code_;
};

void cleanup() noexcept { /* 例外を投げない */ }

// ムーブには noexcept を付けるべき（vector の最適化に影響）
class MyClass {
public:
    MyClass(MyClass&& o) noexcept : data_(o.data_) {
        o.data_ = nullptr;
    }
};

// 例外安全性の 3 レベル:
// 1. Basic guarantee: 例外後もリソースリークなし（最低保証）
// 2. Strong guarantee: 例外後は操作前の状態（トランザクション的）
// 3. No-throw guarantee: 例外が発生しない（noexcept）

std::vector<int> v;
v.reserve(100);           // メモリ事前確保（サイズは変わらない）
v.push_back(1);
v.emplace_back(2);        // その場で構築（std::string 等でコピー不要）
v.pop_back();
v.insert(v.begin(), 0);  // 先頭挿入（O(n)）
v.erase(v.begin());      // 先頭削除（O(n)）

v[0];        // 範囲チェックなし（高速）
v.at(0);     // 範囲チェックあり（越えると std::out_of_range）
v.front();   // 先頭要素
v.back();    // 末尾要素
v.data();    // 生ポインタ（C API に渡す場合）

std::unordered_map<std::string, int> scores;
scores["Alice"] = 90;

// 安全なアクセス: [] はキーがなければデフォルト値で挿入してしまう
if (auto it = scores.find("Carol"); it != scores.end()) {
    std::cout << it->second;
} else {
    std::cout << "not found";
}

// 挿入（既存キーは上書きしない）
auto [it, ok] = scores.try_emplace("Eve", 95); // C++17

// C++17 構造化束縛で全要素走査
for (const auto& [key, val] : scores) {
    std::cout << key << ": " << val << "
";
}

// set: 重複なし・ソート済み
std::set<int> s = {3, 1, 4, 1, 5}; // {1, 3, 4, 5}
s.insert(9);
s.count(3);   // 0 か 1
s.contains(3); // C++20: bool

// queue: FIFO
std::queue<std::string> q;
q.push("first"); q.push("second");
q.front(); // "first"
q.pop();   // front を削除

// stack: LIFO
std::stack<int> st;
st.push(1); st.push(2);
st.top(); // 2
st.pop(); // 2 を削除

// priority_queue: 最大値優先
std::priority_queue<int> pq;
pq.push(3); pq.push(1); pq.push(4);
pq.top(); // 4

std::vector<int> v = {1, 2, 3, 4, 5};

// begin/end: 前から走査
for (auto it = v.begin(); it != v.end(); ++it) { ... }

// rbegin/rend: 後ろから走査
for (auto it = v.rbegin(); it != v.rend(); ++it) { ... }

// イテレータアダプタ
#include <iterator>
// ostream_iterator で出力
std::copy(v.begin(), v.end(),
    std::ostream_iterator<int>(std::cout, " ")); // 1 2 3 4 5

// back_inserter でコンテナ末尾に追加
std::vector<int> out;
std::copy(v.begin(), v.end(), std::back_inserter(out));

#include <algorithm>
#include <numeric>

std::vector<int> v = {5, 3, 1, 4, 2};
std::sort(v.begin(), v.end());                            // 昇順
std::sort(v.begin(), v.end(), std::greater<int>());       // 降順

auto it = std::find(v.begin(), v.end(), 3);
if (it != v.end()) { /* 見つかった */ }

// Erase-Remove イディオム: 条件に合う要素を削除
v.erase(std::remove_if(v.begin(), v.end(),
    [](int x){ return x % 2 == 0; }), v.end());

// transform: 変換
std::vector<int> doubled;
std::transform(v.begin(), v.end(), std::back_inserter(doubled),
    [](int x){ return x * 2; });

// accumulate: 集約（初期値が必要）
int sum = std::accumulate(v.begin(), v.end(), 0);

#include <ranges>

std::vector<int> v = {1, 2, 3, 4, 5, 6};

// パイプライン（遅延評価: 走査時まで計算しない）
auto result = v
    | std::views::filter([](int x){ return x % 2 == 0; }) // 偶数
    | std::views::transform([](int x){ return x * x; });  // 二乗

for (int x : result) {
    std::cout << x << " "; // 4 16 36
}

// ranges::sort: begin()/end() 省略可
std::ranges::sort(v);
auto it = std::ranges::find(v, 3);
bool found = std::ranges::contains(v, 3); // C++23

template<typename T>
T maximum(T a, T b) { return a > b ? a : b; }

maximum(3, 5);         // T = int（推論）
maximum(3.0, 5.0);     // T = double
maximum<int>(3, 5);    // T を明示

// 複数の型パラメータ
template<typename T, typename U>
auto add(T a, U b) -> decltype(a + b) { return a + b; }

// 非型パラメータ（値をテンプレート引数に）
template<std::size_t N>
void printArray(const int (&arr)[N]) {
    for (std::size_t i = 0; i < N; ++i) std::cout << arr[i] << " ";
}
int a[] = {1, 2, 3};
printArray(a); // N = 3 が推論

template<typename T>
class Stack {
public:
    void push(T val) { data_.push_back(std::move(val)); }
    T pop() { T v = std::move(data_.back()); data_.pop_back(); return v; }
    bool empty() const { return data_.empty(); }
    std::size_t size() const { return data_.size(); }
private:
    std::vector<T> data_;
};

Stack<int> si;
si.push(1); si.push(2);

// 完全特殊化: bool に対して別実装
template<>
class Stack<bool> {
    // ビット単位で保存する効率的な実装...
};

#include <concepts>

// concept の定義
template<typename T>
concept Addable = requires(T a, T b) { a + b; };

template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

// concept で制約されたテンプレート関数
template<Addable T>
T sum(T a, T b) { return a + b; }

// requires 節でも書ける
template<typename T>
    requires Numeric<T>
T square(T x) { return x * x; }

sum(1, 2);        // OK: int は Addable
// sum(std::vector<int>{}, {}); // エラー: Addable を満たさない（明快なエラー）

// 可変引数テンプレート
template<typename... Args>
void print(Args&&... args) {
    (std::cout << ... << args) << "
"; // C++17 フォールド式
}
print(1, " ", 2.0, " ", "hello"); // 1 2 hello

// 型の数を取得
template<typename... Ts>
constexpr std::size_t count() { return sizeof...(Ts); }
count<int, double, std::string>(); // 3

// 完全転送と組み合わせ（make_unique の実装例）
template<typename T, typename... Args>
std::unique_ptr<T> myMakeUnique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

std::string a = "hello";
std::string b = std::move(a); // a のバッファを b に移す。a は空文字列に

// 関数の戻り値は自動でムーブ（RVO/NRVO でさらに最適化）
std::vector<int> makeVec() {
    std::vector<int> v = {1, 2, 3};
    return v; // コンパイラが最適化（コピーなし）
}

// 関数引数でのムーブ（所有権の移転）
class Repo {
    std::vector<int> data_;
public:
    void store(std::vector<int> v) { data_ = std::move(v); }
};
Repo r;
std::vector<int> big(1000);
r.store(std::move(big)); // big の中身を移転

// 完全転送: 引数の値カテゴリを保持して渡す
template<typename T, typename... Args>
std::unique_ptr<T> myMakeUnique(Args&&... args) {
    return std::unique_ptr<T>(
        new T(std::forward<Args>(args)...)
    );
}

struct Widget {
    Widget(int x, std::string s) {}
};

auto w = myMakeUnique<Widget>(42, std::string("hello"));
// 42 は int&&（右辺値）として転送
// std::string("hello") は string&&（右辺値）として転送

std::string make() {
    std::string s = "hello";
    return s; // NRVO: s のコンストラクタは 1 回だけ（コピー・ムーブなし）
}

// C++17 必須のコピー省略
std::string s = make(); // コピーもムーブも発生しない

// 注意: std::move して返すと NRVO を妨害する場合がある
std::string makeBad() {
    std::string s = "hello";
    return std::move(s); // NRVO が無効になる可能性（パフォーマンス低下）
}

// 構造化束縛
auto [x, y] = std::make_pair(1, 2.0);
auto [it, ok] = myMap.insert({"key", 42}); // C++17

std::tuple<int, std::string, double> t{1, "hi", 3.14};
auto [id, name, score] = t;

// if constexpr（コンパイル時分岐）
template<typename T>
std::string describe(T val) {
    if constexpr (std::is_integral_v<T>) {
        return "integer: " + std::to_string(val);
    } else if constexpr (std::is_floating_point_v<T>) {
        return "float: " + std::to_string(val);
    } else {
        return "other";
    }
}

#include <optional>
#include <variant>

// optional: 値なし状態を表現
std::optional<int> findFirst(const std::vector<int>& v, int key) {
    for (int x : v) if (x == key) return x;
    return std::nullopt;
}
auto r = findFirst({1,2,3}, 2);
if (r) std::cout << *r;    // 2
r.value_or(-1);            // なければ -1

// variant: 型安全な共用体
using Val = std::variant<int, double, std::string>;
Val v = 42;
v = "hello";

std::visit([](auto&& x) {
    std::cout << x << "
"; // 型に応じた処理
}, v);

if (std::holds_alternative<std::string>(v)) {
    std::cout << std::get<std::string>(v);
}

// モジュール（C++20）
// math.ixx
export module math;
export int add(int a, int b) { return a + b; }

// main.cpp
import math;
int r = add(1, 2);

// コルーチン（C++23 の std::generator 利用例）
// #include <generator>
// std::generator<int> fibonacci() {
//     int a = 0, b = 1;
//     while (true) {
//         co_yield a;
//         std::tie(a, b) = std::make_tuple(b, a + b);
//     }
// }
// for (int n : fibonacci() | std::views::take(10)) {
//     std::cout << n << " "; // 0 1 1 2 3 5 8 13 21 34
// }