C++ コーディング標準（C++ Core Guidelines）

C++ Core Guidelinesに基づくモダンC++（C++17/20/23）の包括的なコーディング標準。型安全性、リソース安全性、不変性、明確性を強制実行します。

使用する場合

• 新しいC++コードを書く場合（クラス、関数、テンプレート）
• 既存のC++コードをレビューまたはリファクタリングする場合
• C++プロジェクトでアーキテクチャ上の決定を行う場合
• C++コードベースで一貫したスタイルを強制実行する場合
• 言語機能の選択を行う場合（例：enum vs enum class、生ポインタ vs スマートポインタ）

使用してはいけない場合

• C++以外のプロジェクト
• モダンC++機能を採用できないレガシーCコードベース
• 特定のガイドラインがハードウェアの制限と競合する組み込み/ベアメタル環境（選択的に適応）

貫通する原則

これらのテーマはガイドライン全体を通じて繰り返し出現し、基礎を構成します：

1. いたるところで RAII を使用 (P.8, R.1, E.6, CP.20)：リソースのライフサイクルをオブジェクトのライフサイクルにバインド
2. デフォルトで不変性 (P.10, Con.1-5, ES.25)：const/constexpr から始める；可変性は例外
3. 型安全性 (P.4, I.4, ES.46-49, Enum.3)：型システムを使用してコンパイル時にエラーを防止
4. 意図を表現する (P.3, F.1, NL.1-2, T.10)：名前、型、コンセプトは目的を伝える
5. 複雑性を最小化 (F.2-3, ES.5, Per.4-5)：シンプルなコードが正しいコード
6. ポインタセマンティクスより値セマンティクス (C.10, R.3-5, F.20, CP.31)：値で返すとスコープ内オブジェクトを優先

哲学とインターフェース (P.*, I.*)

主要ルール

ルール	概要
P.1	直接コードで考えを表現する
P.3	意図を表現する
P.4	理想的には、プログラムは静的型安全であるべき
P.5	実行時チェックより逆時チェックを優先
P.8	リソースをリークしない
P.10	可変データより不変データを優先
I.1	インターフェースを明確にする
I.2	const以外のグローバル変数を避ける
I.4	インターフェースを正確で強く型付けする
I.11	生ポインタまたは参照による所有権の移譲をしない
I.23	関数のパラメータ数を少なく保つ

すべき事

// P.10 + I.4: 不変で強く型付けされたインターフェース
struct Temperature {
    double kelvin;
};

Temperature boil(const Temperature& water);

してはいけない事

// 弱いインターフェース：所有権不明確、単位不明確
double boil(double* temp);

// const以外のグローバル変数
int g_counter = 0;  // I.2 違反

関数 (F.*)

主要ルール

ルール	概要
F.1	意味のある操作を適切に命名された関数にパッケージ化
F.2	関数は単一の論理操作を実行
F.3	関数を短く単純に保つ
F.4	関数がコンパイル時に評価される可能性がある場合、constexpr として宣言
F.6	関数が例外をスローしない場合、noexcept として宣言
F.8	純粋関数を優先
F.16	「入力」パラメータの場合、安価にコピー可能な型は値で、その他は const& で渡す
F.20	「出力」値の場合、出力パラメータより戻り値を優先
F.21	複数の「出力」値を返す場合、出力パラメータより構造体を優先
F.43	ローカルオブジェクトへのポインタまたは参照を返さない

パラメータ渡し

// F.16：安価な型は値で、その他は const&
void print(int x);                           // 安価：値で
void analyze(const std::string& data);       // 高価：const&で
void transform(std::string s);               // シンク：値で（ムーブされる）

// F.20 + F.21：戻り値、出力パラメータは不可
struct ParseResult {
    std::string token;
    int position;
};

ParseResult parse(std::string_view input);   // 良好：構造体を返す

// 悪い：出力パラメータ
void parse(std::string_view input,
           std::string& token, int& pos);    // これを避ける

純粋関数と constexpr

// F.4 + F.8：純粋で constexpr が可能な場合
constexpr int factorial(int n) noexcept {
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

static_assert(factorial(5) == 120);

アンチパターン

• 関数から T&& を返す (F.45)
• va_arg / C形式の可変長パラメータを使用 (F.55)
• 他のスレッドに渡されるラムダで参照キャプチャ (F.53)
• const T を返す（ムーブセマンティクスを抑制） (F.49)

クラスとクラス階層 (C.*)

主要ルール

ルール	概要
C.2	不変式がある場合は class、データメンバが独立に変動する場合は struct
C.9	メンバの露出を最小化
C.20	デフォルト操作の定義を避けられるなら、そうする（ゼロルール）
C.21	コピー/ムーブ/デストラクタのいずれかを定義または =delete した場合、すべてを処理（ファイブルール）
C.35	基底クラスデストラクタ：public virtual または protected non-virtual
C.41	コンストラクタは完全に初期化されたオブジェクトを作成
C.46	単一パラメータコンストラクタを explicit として宣言
C.67	ポリモーフィッククラスは public なコピー/ムーブを禁止
C.128	仮想関数：virtual、override、final のいずれか1つを正確に指定

ゼロルール

// C.20：コンパイラに特殊メンバを生成させる
struct Employee {
    std::string name;
    std::string department;
    int id;
    // デストラクタ、コピー/ムーブコンストラクタ、代入演算子は不要
};

ファイブルール

// C.21：リソースを管理する場合、5つすべてを定義
class Buffer {
public:
    explicit Buffer(std::size_t size)
        : data_(std::make_unique<char[]>(size)), size_(size) {}

    ~Buffer() = default;

    Buffer(const Buffer& other)
        : data_(std::make_unique<char[]>(other.size_)), size_(other.size_) {
        std::copy_n(other.data_.get(), size_, data_.get());
    }

    Buffer& operator=(const Buffer& other) {
        if (this != &other) {
            auto new_data = std::make_unique<char[]>(other.size_);
            std::copy_n(other.data_.get(), other.size_, new_data.get());
            data_ = std::move(new_data);
            size_ = other.size_;
        }
        return *this;
    }

    Buffer(Buffer&&) noexcept = default;
    Buffer& operator=(Buffer&&) noexcept = default;

private:
    std::unique_ptr<char[]> data_;
    std::size_t size_;
};

クラス階層

// C.35 + C.128：仮想デストラクタ、override を使用
class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;  // C.121：純粋インターフェース
};

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

private:
    double radius_;
};

アンチパターン

• コンストラクタ/デストラクタで仮想関数を呼び出す (C.82)
• 非自明な型で memset/memcpy を使用 (C.90)
• 仮想関数とオーバーライド関数で異なるデフォルトパラメータを指定 (C.140)
• データメンバを const または参照にする（ムーブ/コピーを抑制） (C.12)

リソース管理 (R.*)

主要ルール

ルール	概要
R.1	RAII を使用してリソースを自動管理
R.3	生ポインタ (T*) は非所有
R.5	スコープ内オブジェクトを優先；不要にヒープに割り当てない
R.10	malloc()/free() を避ける
R.11	明示的な new と delete を避ける
R.20	所有権を表現するために unique_ptr または shared_ptr を使用
R.21	共有所有権がない限り、shared_ptr より unique_ptr を優先
R.22	shared_ptr を作成するために make_shared() を使用

スマートポインタ使用

// R.11 + R.20 + R.21：スマートポインタでRAII
auto widget = std::make_unique<Widget>("config");  // 単一所有権
auto cache  = std::make_shared<Cache>(1024);        // 共有所有権

// R.3：生ポインタ＝非所有オブザーバ
void render(const Widget* w) {  // w を所有しない
    if (w) w->draw();
}

render(widget.get());

RAII パターン

// R.1：リソース獲得は初期化
class FileHandle {
public:
    explicit FileHandle(const std::string& path)
        : handle_(std::fopen(path.c_str(), "r")) {
        if (!handle_) throw std::runtime_error("Failed to open: " + path);
    }

    ~FileHandle() {
        if (handle_) std::fclose(handle_);
    }

    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    FileHandle(FileHandle&& other) noexcept
        : handle_(std::exchange(other.handle_, nullptr)) {}
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            if (handle_) std::fclose(handle_);
            handle_ = std::exchange(other.handle_, nullptr);
        }
        return *this;
    }

private:
    std::FILE* handle_;
};

アンチパターン

• 裸の new/delete (R.11)
• C++コードでの malloc()/free() (R.10)
• 単一の式で複数のリソース割り当て (R.13 -- 例外安全性リスク)
• unique_ptr で十分な場合に shared_ptr を使用 (R.21)

式とステートメント (ES.*)

主要ルール

ルール	概要
ES.5	スコープを小さく保つ
ES.20	常にオブジェクトを初期化
ES.23	{} 初期化構文を優先
ES.25	修正する意図がない限り、オブジェクトを const または constexpr として宣言
ES.28	const 変数の複雑な初期化にはラムダを使用
ES.45	マジックナンバーを避ける；シンボリック定数を使用
ES.46	縮小変換を避ける
ES.47	0 または NULL より nullptr を使用
ES.48	C形式の強制型変換を避ける
ES.50	const を廃棄しない

初期化

// ES.20 + ES.23 + ES.25：常に初期化、{} を優先、デフォルトで const
const int max_retries{3};
const std::string name{"widget"};
const std::vector<int> primes{2, 3, 5, 7, 11};

// ES.28：複雑な const 初期化にはラムダ
const auto config = [&] {
    Config c;
    c.timeout = std::chrono::seconds{30};
    c.retries = max_retries;
    c.verbose = debug_mode;
    return c;
}();

アンチパターン

• 初期化されていない変数 (ES.20)
• ポインタとして 0 または NULL を使用 (ES.47 -- nullptr を使用)
• C形式の強制型変換 (ES.48 -- static_cast、const_cast など使用)
• const を廃棄 (ES.50)
• 名前付き定数なしのマジックナンバー (ES.45)
• 符号付きと符号なしの算術を混在 (ES.100)
• ネストされたスコープで名前を再利用 (ES.12)

エラーハンドリング (E.*)

主要ルール

ルール	概要
E.1	設計の早期段階でエラーハンドリング戦略を確立
E.2	関数が割り当てられたタスクを実行できないことを表現するために例外をスロー
E.6	RAII を使用してリークを防止
E.12	例外をスローすることが不可能または受け入れられない場合、noexcept を使用
E.14	特別に設計されたユーザー定義型を例外として使用
E.15	値でスロー、参照でキャッチ
E.16	デストラクタ、解放、swap は失敗してはならない
E.17	すべての関数ですべての例外をキャッチしようとしない

例外階層

// E.14 + E.15：カスタム例外型、値でスロー、参照でキャッチ
class AppError : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};

class NetworkError : public AppError {
public:
    NetworkError(const std::string& msg, int code)
        : AppError(msg), status_code(code) {}
    int status_code;
};

void fetch_data(const std::string& url) {
    // E.2：失敗を表現するためにスロー
    throw NetworkError("connection refused", 503);
}

void run() {
    try {
        fetch_data("https://api.example.com");
    } catch (const NetworkError& e) {
        log_error(e.what(), e.status_code);
    } catch (const AppError& e) {
        log_error(e.what());
    }
    // E.17：ここですべてをキャッチしない -- 予期しないエラーは伝播させる
}

アンチパターン

• int または文字列リテラルなどの組み込み型をスロー (E.14)
• 値でキャッチ（スライスのリスク） (E.15)
• エラーを静かに飲み込む空のキャッチブロック
• フロー制御に例外を使用 (E.3)
• グローバル状態（errno など）に基づくエラーハンドリング (E.28)

定数と不変性 (Con.*)

すべてのルール

ルール	概要
Con.1	デフォルトでオブジェクトを不変にする
Con.2	デフォルトでメンバ関数を const にする
Con.3	デフォルトで const へのポインタと参照を渡す
Con.4	構造化後に変わらない値に const を使用
Con.5	コンパイル時に計算可能な値に constexpr を使用

// Con.1 から Con.5：デフォルトで不変
class Sensor {
public:
    explicit Sensor(std::string id) : id_(std::move(id)) {}

    // Con.2：デフォルトで const メンバ関数
    const std::string& id() const { return id_; }
    double last_reading() const { return reading_; }

    // 変異が必要な場合のみ非const
    void record(double value) { reading_ = value; }

private:
    const std::string id_;  // Con.4：構造化後に変わらない
    double reading_{0.0};
};

// Con.3：const 参照で渡す
void display(const Sensor& s) {
    std::cout << s.id() << ": " << s.last_reading() << '\n';
}

// Con.5：コンパイル時定数
constexpr double PI = 3.14159265358979;
constexpr int MAX_SENSORS = 256;

並行と並列 (CP.*)

主要ルール

ルール	概要
CP.2	データレースを避ける
CP.3	書き込み可能データの明示的な共有を最小化
CP.4	スレッドではなくタスクの観点から考える
CP.8	同期に volatile を使用しない
CP.20	RAII を使用、普通の lock()/unlock() は使用しない
CP.21	複数のミューテックスを取得するには std::scoped_lock を使用
CP.22	ロック保持中に未知のコードを呼び出さない
CP.42	条件なしに待たない
CP.44	lock_guard と unique_lock に必ず名前を付ける
CP.100	絶対必要でない限り、ロックフリープログラミングを使用しない

安全なロック

// CP.20 + CP.44：RAII ロック、常に名前付き
class ThreadSafeQueue {
public:
    void push(int value) {
        std::lock_guard<std::mutex> lock(mutex_);  // CP.44：名前付き！
        queue_.push(value);
        cv_.notify_one();
    }

    int pop() {
        std::unique_lock<std::mutex> lock(mutex_);
        // CP.42：常に条件付きで待機
        cv_.wait(lock, [this] { return !queue_.empty(); });
        const int value = queue_.front();
        queue_.pop();
        return value;
    }

private:
    std::mutex mutex_;             // CP.50：ミューテックスとそのデータ
    std::condition_variable cv_;
    std::queue<int> queue_;
};

複数のミューテックス

// CP.21：複数のミューテックスに std::scoped_lock （デッドロックなし）
void transfer(Account& from, Account& to, double amount) {
    std::scoped_lock lock(from.mutex_, to.mutex_);
    from.balance_ -= amount;
    to.balance_ += amount;
}

アンチパターン

• 同期に volatile を使用 (CP.8 -- ハードウェアI/O専用)
• スレッドの分離 (CP.26 -- ライフサイクル管理がほぼ不可能)
• 名前なしのロック保護：std::lock_guard<std::mutex>(m); は即座に破棄 (CP.44)
• ロック保持中にコールバックを呼び出す (CP.22 -- デッドロックリスク)
• 深い専門知識なしでロックフリープログラミング (CP.100)

テンプレートとジェネリックプログラミング (T.*)

主要ルール

ルール	概要
T.1	抽象化レベルを向上させるためにテンプレートを使用
T.2	複数のパラメータ型のアルゴリズムを表現するためにテンプレートを使用
T.10	すべてのテンプレートパラメータに対してコンセプトを指定
T.11	可能な限り標準コンセプトを使用
T.13	シンプルなコンセプトの場合、速記記法を優先
T.43	typedef より using を優先
T.120	確実に必要な場合のみテンプレートメタプログラミングを使用
T.144	関数テンプレートを特化させない（代わりにオーバーロード）

コンセプト (C++20)

#include <concepts>

// T.10 + T.11：標準コンセプトでテンプレートを制約
template<std::integral T>
T gcd(T a, T b) {
    while (b != 0) {
        a = std::exchange(b, a % b);
    }
    return a;
}

// T.13：速記コンセプト構文
void sort(std::ranges::random_access_range auto& range) {
    std::ranges::sort(range);
}

// ドメイン固有の制約のためのカスタムコンセプト
template<typename T>
concept Serializable = requires(const T& t) {
    { t.serialize() } -> std::convertible_to<std::string>;
};

template<Serializable T>
void save(const T& obj, const std::string& path);

アンチパターン

• 見える名前空間での制約なしテンプレート (T.47)
• 関数テンプレートをオーバーロードせずに特化 (T.144)
• constexpr で十分な場合にテンプレートメタプログラミングを使用 (T.120)
• using ではなく typedef を使用 (T.43)

標準ライブラリ (SL.*)

主要ルール

ルール	概要
SL.1	可能な限りライブラリを使用
SL.2	他のライブラリより標準ライブラリを優先
SL.con.1	Cアレイより std::array または std::vector を優先
SL.con.2	デフォルトで std::vector を優先
SL.str.1	文字シーケンスを所有するために std::string を使用
SL.str.2	文字シーケンスを参照するために std::string_view を使用
SL.io.50	endl を避ける（'\n' を使用 -- endl は強制フラッシュ）

// SL.con.1 + SL.con.2：Cアレイより vector/array を優先
const std::array<int, 4> fixed_data{1, 2, 3, 4};
std::vector<std::string> dynamic_data;

// SL.str.1 + SL.str.2：string は所有、string_view は参照
std::string build_greeting(std::string_view name) {
    return "Hello, " + std::string(name) + "!";
}

// SL.io.50：endl ではなく '\n' を使用
std::cout << "result: " << value << '\n';

列挙型 (Enum.*)

主要ルール

ルール	概要
Enum.1	マクロより列挙型を優先
Enum.3	プレーン enum より enum class を優先
Enum.5	列挙型の項に全大文字を使用しない
Enum.6	名前なしの列挙型を避ける

// Enum.3 + Enum.5：スコープ付き列挙型、全大文字なし
enum class Color { red, green, blue };
enum class LogLevel { debug, info, warning, error };

// 悪い：プレーン列挙型は名前をリーク、全大文字はマクロと衝突
enum { RED, GREEN, BLUE };           // Enum.3 + Enum.5 + Enum.6 違反
#define MAX_SIZE 100                  // Enum.1 違反 -- constexpr を使用

ソースファイルと命名 (SF., NL.)

主要ルール

ルール	概要
SF.1	コードファイルは .cpp、インターフェースファイルは .h
SF.7	ヘッダファイルのグローバルスコープで using namespace と書かない
SF.8	すべての .h ファイルは #include ガード を使用
SF.11	ヘッダファイルは自己完結型
NL.5	名前で型情報をエンコードしない（ハンガリアン記法を使用しない）
NL.8	一貫した命名スタイルを使用
NL.9	マクロ名のみに ALL_CAPS を使用
NL.10	underscore_style 命名を優先

ヘッダファイルガード

// SF.8：インクルードガード（または #pragma once）
#ifndef PROJECT_MODULE_WIDGET_H
#define PROJECT_MODULE_WIDGET_H

// SF.11：自己完結型 -- このヘッダが必要とするすべてをインクルード
#include <string>
#include <vector>

namespace project::module {

class Widget {
public:
    explicit Widget(std::string name);
    const std::string& name() const;

private:
    std::string name_;
};

}  // namespace project::module

#endif  // PROJECT_MODULE_WIDGET_H

命名規則

// NL.8 + NL.10：一貫した underscore_style
namespace my_project {

constexpr int max_buffer_size = 4096;  // NL.9：マクロでないので全大文字でない

class tcp_connection {                 // underscore_style クラス
public:
    void send_message(std::string_view msg);
    bool is_connected() const;

private:
    std::string host_;                 // メンバの末尾アンダースコア
    int port_;
};

}  // namespace my_project

アンチパターン

• ヘッダファイルのグローバルスコープで using namespace std; (SF.7)
• インクルード順序に依存するヘッダファイル (SF.10, SF.11)
• ハンガリアン記法、例えば strName、iCount (NL.5)
• マクロ以外の要素に ALL_CAPS を使用 (NL.9)

パフォーマンス (Per.*)

主要ルール

ルール	概要
Per.1	根拠なく最適化しない
Per.2	過度に早く最適化しない
Per.6	測定データなしでパフォーマンスを主張しない
Per.7	最適化を容易にするよう設計
Per.10	静的型システムに依存
Per.11	計算を実行時からコンパイル時に移動
Per.19	予測可能な方法でメモリにアクセス

ガイドライン

// Per.11：可能な場合、コンパイル時計算
constexpr auto lookup_table = [] {
    std::array<int, 256> table{};
    for (int i = 0; i < 256; ++i) {
        table[i] = i * i;
    }
    return table;
}();

// Per.19：キャッシュフレンドリーな連続データを優先
std::vector<Point> points;           // 良好：連続
std::vector<std::unique_ptr<Point>> indirect_points; // 悪い：ポインタチェーシング

アンチパターン

• パフォーマンス分析データなしでの最適化 (Per.1, Per.6)
• 明確な抽象化より「賢い」低レベルコードを選択 (Per.4, Per.5)
• データレイアウトとキャッシュ動作を無視 (Per.19)

クイックリファレンスチェックリスト

C++の作業を完了としてマークする前に：

• [ ] 裸の new/delete がない -- スマートポインタまたは RAII を使用 (R.11)
• [ ] オブジェクトは宣言時に初期化 (ES.20)
• [ ] 変数はデフォルトで const/constexpr (Con.1, ES.25)
• [ ] メンバ関数は可能な限り const (Con.2)
• [ ] プレーン enum ではなく enum class を使用 (Enum.3)
• [ ] 0/NULL ではなく nullptr を使用 (ES.47)
• [ ] 縮小変換がない (ES.46)
• [ ] C形式の強制型変換がない (ES.48)
• [ ] 単一パラメータコンストラクタは explicit (C.46)
• [ ] ゼロルールまたはファイブルール が適用 (C.20, C.21)
• [ ] 基底クラスデストラクタは public virtual または protected non-virtual (C.35)
• [ ] テンプレートはコンセプトで制約 (T.10)
• [ ] ヘッダファイルのグローバルスコープに using namespace がない (SF.7)
• [ ] ヘッダファイルはガードがあり自己完結型 (SF.8, SF.11)
• [ ] ロックは RAII (scoped_lock/lock_guard) を使用 (CP.20)
• [ ] 例外は自定義型で、値でスロー、参照でキャッチ (E.14, E.15)
• [ ] std::endl ではなく '\n' を使用 (SL.io.50)
• [ ] マジックナンバーがない (ES.45)