C++20 Concepts 入門

---

# はじめに

以前、**「C++20/23 の導入効果 ～従来との比較～」** という記事を書きました。そこでは C++20 以降の新機能全般について概説し、従来のコードと比較しながらどのように開発効率やコード品質が向上するかを紹介しました。  

筆者はC++でたまにコンパイル時にテンプレートエラーが発生し、その原因特定に苦労することがあります。そこで今回は自分の勉強を兼ねて、**エラーメッセージが分かりづらく修正の手がかりがつかみにくい** という状況を改善する手段として、特に **Concepts** に焦点を当てて深掘りします。サンプルコードやよくある質問、そして従来の代表的な手法である **SFINAE(後述)** の解説を交えながら、より実践的な使い方やメリット、注意点を解説していきます。

---

## なぜ Concepts が必要なのか？

C++ にはもともと強力なテンプレート機能がありますが、制約を設けないまま「どんな型でも受け付ける」としてしまうと、意図しない型まで受け付けてしまう場合があります。また、その結果生じるコンパイルエラーが膨大かつ難解になりがちで、原因の特定に時間がかかることもしばしばです。  

こうした問題を解消するために C++20 で導入されたのが **Concepts** です。Concepts を用いると、**「型パラメータにどのような要件を課すのか」** を明示的に記述できるようになります。そのおかげで、**コンパイルエラーが分かりやすくなり、コードの意図をより明確に示せる** のが最大の利点です。

---

# サンプルコード

以下では、Concepts の簡単な使用例をいくつか紹介します。まずは基本的な定義の仕方、関数・クラスへの適用方法を確認してみましょう。

## 1. 基本的な Concept 定義と適用

### 1-1. Concept の定義

```cpp
#include <concepts>
#include <iostream>
#include <type_traits>

// ユーザー定義の Concept: 例えば加算演算子が使える型かどうか
template <typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
};

// 上記のように "a + b" が有効で、その結果が T に変換可能かどうかをチェックする
```

ここでは、`Addable` という Concept を定義し、`a + b` 演算子が有効かつその結果が `T` に変換可能であることを要件にしています。

### 1-2. 関数テンプレートへの適用

```cpp
// このテンプレートは加算演算子が定義されている型 T にのみ適用される
template <Addable T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(1, 2) << std::endl;                // OK (int は + 演算可能)
    std::cout << add(std::string("A"), std::string("B")) << std::endl; // OK (string + string)
    // std::cout << add(std::cout, std::cerr) << std::endl; // コンパイルエラー (演算子+が定義されていない)
}
```

`std::cout` や `std::cerr` はストリームオブジェクトであり、`+` 演算子が定義されていません。そのため `Addable` の要件を満たさず、コンパイルエラーになります。従来の SFINAE などを用いた場合に比べ、エラーメッセージがより明確になることが期待できます。

### 1-3. `requires` 式を用いた記述

Concept は、より細かい制約を書く場合に `requires` 式を使うと分かりやすくなります。

```cpp
#include <concepts>
#include <iostream>

// 例: イテレータっぽい振る舞いをチェックする Concept
template <typename T>
concept MyIterator = requires(T it) {
    // デリファレンスできるか
    { *it } -> std::convertible_to<typename T::value_type>;
    // 前置インクリメントができるか
    { ++it } -> std::same_as<T&>;
};

template <MyIterator It>
void print_first_value(It it) {
    // イテレータとして想定しているので、*it を問題なく取得できるはず
    std::cout << *it << std::endl;
}
```

この例では、「デリファレンス（`*it`）ができる」「前置インクリメント（`++it`）ができる」といったイテレータらしい操作を要件として定義しています。`MyIterator` に合致しない型を引数に渡すと、コンパイル時にエラーとなります。

---

## 2. 関数テンプレートの引数に Concept を直接適用する

C++20 では、引数を `auto` と書きつつ Concept で制約を掛ける構文も可能です。

```cpp
#include <concepts>
#include <iostream>
#include <string>

void print_length(std::integral auto x) {
    // integral であれば int, long, long long などあらゆる整数型を受け付ける
    std::cout << "Integral: " << x << std::endl;
}

template <std::integral T>
void print_length_template(T x) {
    std::cout << "Integral (template): " << x << std::endl;
}

int main() {
    print_length(42);           // OK (int は integral)
    //print_length(3.14);       // NG: double は integral ではない
    print_length_template(42);  // 上と同様の結果
}
```

`std::integral` は標準ライブラリが提供する Concept のひとつで、整数型かどうかを判定します。こうした標準の Concept を活用することで、コードの可読性と保守性が大幅に向上します。

---

## 3. 複数の Concept を組み合わせる

`&&`（AND）や `||`（OR）を用いて複合的な Concept を定義することもできます。

```cpp
#include <concepts>
#include <type_traits>

// 複数条件を組み合わせた Concept
template <typename T>
concept SignedAndAddable = 
    std::integral<T> && 
    std::is_signed_v<T> &&  // 符号付きかどうか
    requires(T a, T b) {
        { a + b } -> std::same_as<T>;
    };

SignedAndAddable auto sum(SignedAndAddable auto a, SignedAndAddable auto b) {
    return a + b;
}

int main() {
    int a = 1, b = 2;
    sum(a, b);         // OK（int は符号付き整数で + が定義されている）
    
    //unsigned int ua = 1, ub = 2;
    //sum(ua, ub);      // エラー（unsigned int は符号なしのため不適合）
}
```

この例では、「整数型である (`std::integral`)」「符号付きである (`std::is_signed_v<T>`)」「`+` 演算が可能で、その結果型が `T` と同じ」を組み合わせた Concept を定義しています。こうした柔軟な条件設定ができるのも Concepts の魅力です。

---

## 4. クラス・メンバ関数のテンプレートに適用する

クラスのテンプレートパラメータやメンバ関数にも Concept を適用できます。

```cpp
#include <concepts>
#include <iostream>

template <typename T>
concept Printable = requires(T x) {
    { x.print() } -> std::same_as<void>;
};

class PrintableClass {
public:
    void print() {
        std::cout << "I am PrintableClass" << std::endl;
    }
};

class NonPrintableClass {
public:
    void show() {
        std::cout << "I am NonPrintableClass" << std::endl;
    }
};

template <Printable T>
void do_print(T t) {
    t.print(); 
}

int main() {
    PrintableClass pc;
    do_print(pc);            // OK

    NonPrintableClass npc;
    // do_print(npc);        // コンパイルエラー (print() が定義されていないため)
}
```

`Printable` という Concept では、「`print()` メンバ関数があって、それが `void` を返すこと」を要件としています。要件を満たさないクラスはコンパイル時に弾かれます。

---

## 5. Concepts を使った場合と使わない場合のエラーメッセージの違い

ここでは、**Concepts** を使う場合と使わない場合のコンパイルエラーがどのように異なるかを見ていきます。

### 5-1. Concepts を使わない場合のエラーメッセージ

#### SFINAE などを多用した従来の書き方

C++ ではテンプレートパラメータに一切の制約を設けず「何でも受け付ける」ように書くことができます。しかし、その場合にコンパイル時に要件を満たさない型を渡すと、**膨大なテンプレートエラー** が発生しがちです。

```cpp
template <typename T>
auto add(T a, T b) -> decltype(a + b) {
    return a + b;
}

int main() {
    // 例えば "a + b" 演算が存在しない型同士を渡した場合
    // ...
}
```

こうしたコードをコンパイルすると、  
- 「演算子 + が定義されていない」  
- 「SFINAE によってこのオーバーロードが除外された」  
- 「候補テンプレートが不適合だった」  

など、**テンプレート内部のあらゆる場所で発生したエラーの断片が大量に出力** されることがあります。最終的にどの行で何が問題だったのかを読み解くのに時間がかかり、原因特定が難しくなるケースが多々あります。

### 5-2. Concepts を使う場合のエラーメッセージ

一方、**Concepts** を使うと「型パラメータにどのような要件を課すのか」が明確に宣言されているため、**エラー時により直接的かつ分かりやすいメッセージが出力される** ことが期待できます。

```cpp
#include <concepts>
#include <iostream>
#include <string>

template <typename T>
concept Addable = requires(T x, T y) {
    { x + y } -> std::convertible_to<T>;
};

template <Addable T>
T add(T a, T b) {
    return a + b;
}

int main() {
    // 例えば、演算子+が定義されていないクラス型を渡した場合
    // コンパイル時に「この型は Addable を満たしていません」という趣旨の
    // 明確なエラーが出力される
}
```

コンパイラによってメッセージの文言は異なりますが、多くの場合「`T` は `Addable` コンセプトを満たしていません」のように、  
- どの Concept が問題となっているのか  
- どの行で定義された Concept か  
- 具体的に何が満たされていないのか（演算子+が見つからない、戻り値型が合わない など）  

をはっきり示してくれます。**SFINAE(後述)** 時のように再帰的にテンプレートが展開される過程で生じたエラーが大量に表示されるよりも、原因箇所に直行しやすいという利点があります。

### 5-3. エラー内容が変わるポイントまとめ

1. **要件が直接表現される**  
   - 「この型パラメータは、定義した Concept（要件）を満たしていません」とダイレクトに指摘される。  
   - どの行・どの Concept で失敗したかが明確に把握しやすい。

2. **不要なテンプレート展開のエラーメッセージが出にくい**  
   - SFINAE などを使う場合は、テンプレートが複数回展開される過程で全ての失敗がログに出力されることが多い。  
   - Concepts による制約チェックはコンパイラが “最初に” 行うため、複雑なテンプレート内部に入る前に「不適合」として弾いてくれる。

3. **デバッグ効率が向上する**  
   - エラー原因を調べるために膨大なログを読み解く必要が少なくなる。  
   - 特に大規模プロジェクトや複雑なライブラリを扱う際に、テンプレートエラーの原因追跡が格段に楽になる。

このように、**Concepts を使うと“型の要件違反”が明確化され、エラーメッセージの読解が大幅に楽になる**のが大きなメリットの一つです。テンプレートの仕組み自体を複雑にすることなく、コンパイル時に要件をコンパクトに宣言できるため、結果として開発者の負担を減らし、保守性を高めることにつながります。

---

# (参考) SFINAE とは？

**SFINAE (Substitution Failure Is Not An Error)** は、C++ のテンプレートメタプログラミングで長年使われてきた重要なテクニックです。テンプレートのパラメータに特定の型や式を代入した際、その型や式がテンプレートの要件（型チェックや式の存在など）を満たさない場合でも、それをすぐにコンパイルエラーにせず「このテンプレートの選択肢から外す」という挙動を取らせる仕組みです。

### 具体例

```cpp
#include <type_traits>
#include <iostream>

// このテンプレートは、T::type という型が存在するかどうかをチェックする
template <typename T>
auto has_inner_type(int) -> decltype(std::declval<typename T::type>(), std::true_type{});

template <typename T>
auto has_inner_type(...) -> std::false_type;

struct WithInnerType {
    using type = int;
};

struct WithoutInnerType {
};

int main() {
    // has_inner_type<WithInnerType>(0) の場合
    //   -> decltype(std::declval<typename T::type>(), std::true_type{}) が有効なので true_type が返る
    // has_inner_type<WithoutInnerType>(0) の場合
    //   -> typename T::type が存在しないため、上記の宣言は Substitution Failure となり
    //      コンパイルエラーではなく、もう一方（...）のオーバーロードが選ばれて false_type が返る
    std::cout << decltype(has_inner_type<WithInnerType>(0))::value << std::endl;   // 1
    std::cout << decltype(has_inner_type<WithoutInnerType>(0))::value << std::endl; // 0
}
```

- `has_inner_type(int)` は「`typename T::type` が有効ならば `std::true_type` を返す」という宣言ですが、`T::type` が存在しない型を渡した場合、そこでコンパイルエラーにはならず **“置換失敗”**（Substitution Failure）として扱われ、この候補は無効になります。  
- 代わりに `has_inner_type(...)` のほうのオーバーロードが選ばれ、`std::false_type` が返ることでコンパイラはエラーを起こさずコンパイルを続行します。

これが **“Substitution Failure Is Not An Error”**（置換失敗はエラーではない）という仕組みです。SFINAE によって、同じ関数名や型名のオーバーロード候補を「コンパイル途中で要件を満たさなかったら無視する」形で切り替えるため、**型特性の判定** や **条件付き実装の分岐** などを実現できるのです。

### SFINAE と Concepts の関係

- SFINAE は従来から使われており、**柔軟かつ強力** ですが、テンプレートエラー時のメッセージが非常に複雑になりやすいという難点があります。  
- Concepts は、**SFINAE で実現していた「型パラメータの要件チェック」を、より宣言的にかつわかりやすく書ける** ようにする機能です。  
- 既存の SFINAE ベースのコードは無理にすべて書き換える必要はありませんが、**新規開発や大規模リファクタリングのタイミングで Concepts を導入** すると、コードの可読性やメンテナンス性、エラーの分かりやすさが大きく向上する可能性があります。

---

# よくある質問（FAQ）

### Q1. Concepts を使わずに書いてきたコードはすべて書き直す必要がありますか？
**A1. いいえ。** 既存のテンプレートコードをすべて書き換える必要はありません。Concepts は **「型パラメータの要件を分かりやすく表現する」** ための仕組みであり、既存の SFINAE ベースのコードが正しく機能しているなら、そのままでも問題ありません。徐々に導入するのがおすすめです。

### Q2. Concepts はコンパイル時間に影響しますか？
**A2. 多少影響する可能性があります。** ただし、SFINAE を多用した複雑なコードより、Concepts を使用した方がコンパイルエラーの検出が早まり、結果的にエラーメッセージの読解やバグ修正にかかる時間を大幅に削減できる場合もあります。大規模プロジェクトではむしろビルド効率が上がるケースも報告されています。

### Q3. すべての型パラメータに対して Concept を付けるべきですか？
**A3. ケースバイケースです。** 必要以上に厳密な Concept を設定すると柔軟性が下がります。一方でライブラリ的なコードや大型プロジェクトでは、要件を明確に示すことで保守性が高まります。状況に応じてバランスよく使い分けるのが最適です。

### Q4. 標準ライブラリにはどんな Concept が用意されていますか？
**A4.** C++20 から `<concepts>` ヘッダなどに複数の標準 Concept が追加されています。代表例として、
- `std::integral`, `std::floating_point` などの算術型判定  
- `std::unsigned_integral`, `std::signed_integral`  
- `std::same_as<A, B>` などの型の同一性チェック  
- `std::convertible_to<A>` などの型変換可否チェック  
などがあります。また `<ranges>` ヘッダにはイテレータやレンジを扱うための Concept（`std::ranges::input_range` など）も用意されています。

### Q5. メタプログラミングのコードは必ず Concepts に変えるべきですか？
**A5. 必ずしもそうではありません。** メタプログラミングの世界では、SFINAE や `std::enable_if`、`type_traits` などを使いこなした既存コードが安定して動いている場合も多いです。Concepts に書き換えることで可読性が上がるメリットもありますが、無理に書き換えると工数が増えたりバグが紛れ込むリスクもあります。必要に応じて部分的に導入するのが賢明です。

### Q6. ランタイム性能に影響はありますか？
**A6. 基本的にありません。** Concepts はコンパイル時に要件をチェックする仕組みであり、ランタイムの動作そのものには影響を与えません。適合しない型はコンパイル時点で弾かれるため、実行時のパフォーマンスが変わることはほとんどありません。むしろ、型要件が明確に定義されることで、コンパイラが最適化を行いやすくなる場合があります。

### Q7. SFINAE と Concepts は併用できますか？
**A7. はい、併用可能です。** 既に SFINAE を多用しているコードに対して、急にすべてを Concepts に置き換えるのは難しい場合もあります。SFINAE がまだ有効に活用されている箇所はそのまま残し、新しく書くコードやアップデートする部分で Concepts を導入するなど、段階的に移行することが推奨されます。徐々に移行することでリスクを軽減しつつ、Concepts のメリットを享受できます。

---

# C++23 における Concepts の追加・変更点

C++20 で Concepts の仕組みが定義されて以降、C++23 では主に以下のような **標準ライブラリレベル** での微調整や修正が行われています。大きな言語仕様の変更や破壊的変更はありません。

- **標準ライブラリのレンジ系 Concept の調整**  
  `<ranges>` ヘッダ内のコンセプト（`std::ranges::range`, `std::ranges::input_range` など）の要件定義がより明確化され、不具合修正が行われました。  

- **`std::three_way_comparable` 関連の調整**  
  三方比較演算子（スペースシップ演算子）と組み合わせて使うコンセプトに、実装上の修正や明確化が加えられました。  

- **一部コンセプト名・記述の変更**  
  提案段階での名称変更や、要件の曖昧さを解消するための修正などが行われています。  

基本的には C++20 の Concepts と同じ使い方で問題ありません。C++23 のコンパイラを使用する場合、より安定した挙動とわかりやすいエラーメッセージが期待できます。

---

# まとめ

- **Concepts は「型パラメータの要件」を明示できる機能** で、従来の SFINAE を多用したコードよりもエラー内容が明確化され、可読性や保守性が向上します。  
- 過度に厳密な制約を課しすぎると汎用性が損なわれる場合があるため、プロジェクトの規模や性質に応じてバランスよく導入することが大切です。  
- C++23 において大きな Concept 周りの仕様変更はありませんが、標準ライブラリでの細かい修正や改善が行われ、さらに安定・明確化が進んでいます。  
- 既存コードに Concepts を徐々に取り入れることで、**開発体験（DX）** やデバッグ効率を高める可能性があります。  
- ランタイム性能に関してはほとんど影響がなく、コンパイル時のチェックが充実することでエラーメッセージが分かりやすくなり、結果的に開発時間の短縮にも寄与します。

---

以上