1. 導論

其實 Concept 在很早就希望被引入 C++ 了. 在 C++ 11 那時候, 針對 Concept 就已經有了不少的 Proposal. 而且當時 C++ 11 確實是打算引入 Concept 的, 只不過後來因為不少原因都被延後了, 直到 C++ 17. 在 Concept 被重新設計之後, C++ 17 本來引入了 Concept, 就像 C++ 20 本來要引入 Contract 是一樣的. 但是後來, 由於各種原因, Concept 進入 C++ 再次被延後, 直到 C++ 20 才正式進入 C++. 在 C++ 20 之前, 佔據主導的是 SFINAE. 但是 SFINAE 的寫法一直不受歡迎. 就連我自己也認為, 這種寫法可以在 C++ 中被選為最不優雅的程式碼之一. 例如, 如果我想要求樣板引入是一個整型型別, 那麼我就需要這樣寫 :

#include <type_traits>

struct S {
    int i;
};
template <typename T, typename std::enable_if<std::is_integral<T>::value, T>::type * = nullptr>
bool operator==(S &s, T t) {
    return s.i == t;
}

即使 C++ 14 引入了 std::enable_if_tstd::is_integral_v 簡化一些, 但是這種寫法仍然非常複雜 :

#include <type_traits>

struct S {
    int i;
};
template <typename T, std::enable_if_t<std::is_integral_v<T>, T> * = nullptr>
bool operator==(S &s, T t) {
    return s.i == t;
}

如果我把 SFINAE 不加在樣板參數列表中, 而是加在函式參數列表的 T 中, 我們是不能直接用 a == b 的形式來呼叫上述的多載轉型運算子的, 因為這是一個不可推導語境. 我們曾在文章《【C++ Template Meta-Programming】到處 SFINAE》中介紹過. 此時, 要想呼叫上面這個轉型運算子, 必須主動給定第一個樣板參數, 才能幫助編碼器進行推導 :

#include <type_traits>

struct S {
    int i;
};
template <typename T>
bool operator==(S &s, std::enable_if_t<std::is_integral_v<T>, T> t) {
    return s.i == t;
}

int main(int argc, char *argv[]) {
    S s;
    auto b1 {s == 0};     //error: invalid operands to binary expression ('S' and 'int'), candidate template ignored: couldn't infer template argument 'T'
    auto b2 {operator==<int>(s, 0)};      //OK
}

如果我不小心給定的 Tdouble 型別, 那麼必定會產生編碼錯誤 :

#include <type_traits>

struct S {
    int i;
};
template <typename T, typename std::enable_if<std::is_integral<T>::value, T>::type * = nullptr>
//candidate template ignored: requirement 'std::is_integral<double>::value' was not satisfied [with T = double], candidate template ignored: requirement 'std::is_integral<S>::value' was not satisfied [with T = S]
bool operator==(S &s, T t) {
    return s.i == t;
}
int main(int argc, char *argv[]) {
    S s {};
    if(s == 0.0) {      //error: invalid operands to binary expression ('S' and 'double')
        //...
    }
}

一旦匯入其它標頭檔並且引入名稱空間 std, 那麼編碼錯誤就令人眼前一亮 :

#include <iostream>

using namespace std;
struct S {
    int i;
};
template <typename T, typename std::enable_if<std::is_integral<T>::value, T>::type * = nullptr>
bool operator==(S &s, T t) {
    return s.i == t;
}
int main(int argc, char *argv[]) {
    S s {};
    if(s == 0.0) {
        //...
    }
}
/*
/Users/jonny/Library/Mobile Documents/com~apple~CloudDocs/Xcode/C++/cpp_debug/main.cpp:14:10: error: invalid operands to binary expression ('S' and 'double')
    if(s == 0.0) {
       ~ ^  ~~~
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/system_error:390:1: note: candidate function not viable: no known conversion from 'S' to 'const std::__1::error_code' for 1st argument
operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/system_error:397:1: note: candidate function not viable: no known conversion from 'S' to 'const std::__1::error_code' for 1st argument
operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/system_error:397:1: note: candidate function (with reversed parameter order) not viable: no known conversion from 'S' to 'const std::__1::error_condition' for 1st argument
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/system_error:405:1: note: candidate function not viable: no known conversion from 'S' to 'const std::__1::error_condition' for 1st argument
operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/system_error:405:1: note: candidate function (with reversed parameter order) not viable: no known conversion from 'S' to 'const std::__1::error_code' for 1st argument
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/system_error:412:1: note: candidate function not viable: no known conversion from 'S' to 'const std::__1::error_condition' for 1st argument
operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
^
/Users/jonny/Library/Mobile Documents/com~apple~CloudDocs/Xcode/C++/cpp_debug/main.cpp:9:6: note: candidate template ignored: requirement 'std::is_integral<double>::value' was not satisfied [with T = double]
bool operator==(S &s, T t) {
     ^
/Users/jonny/Library/Mobile Documents/com~apple~CloudDocs/Xcode/C++/cpp_debug/main.cpp:9:6: note: candidate template ignored: requirement 'std::is_integral<S>::value' was not satisfied [with T = S]
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/utility:576:1: note: candidate template ignored: could not match 'pair<type-parameter-0-0, type-parameter-0-1>' against 'S'
operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/iterator:806:1: note: candidate template ignored: could not match 'reverse_iterator<type-parameter-0-0>' against 'S'
operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/iterator:806:1: note: candidate template ignored: could not match 'reverse_iterator<type-parameter-0-0>' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/iterator:1035:1: note: candidate template ignored: could not match 'istream_iterator<type-parameter-0-0, type-parameter-0-1, type-parameter-0-2, type-parameter-0-3>' against 'S'
operator==(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/iterator:1149:6: note: candidate template ignored: could not match 'istreambuf_iterator<type-parameter-0-0, type-parameter-0-1>' against 'S'
bool operator==(const istreambuf_iterator<_CharT,_Traits>& __a,
     ^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/iterator:1262:1: note: candidate template ignored: could not match 'move_iterator<type-parameter-0-0>' against 'S'
operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/iterator:1262:1: note: candidate template ignored: could not match 'move_iterator<type-parameter-0-0>' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/iterator:1634:1: note: candidate template ignored: could not match '__wrap_iter<type-parameter-0-0>' against 'S'
operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/iterator:1634:1: note: candidate template ignored: could not match '__wrap_iter<type-parameter-0-0>' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/tuple:1176:1: note: candidate template ignored: could not match 'tuple<type-parameter-0-0...>' against 'S'
operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/tuple:1176:1: note: candidate template ignored: could not match 'tuple<type-parameter-0-0...>' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:1758:6: note: candidate template ignored: could not match 'allocator<type-parameter-0-0>' against 'S'
bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;}
     ^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:1758:6: note: candidate template ignored: could not match 'allocator<type-parameter-0-0>' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:2599:1: note: candidate template ignored: could not match 'unique_ptr<type-parameter-0-0, type-parameter-0-1>' against 'S'
operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();}
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:2599:1: note: candidate template ignored: could not match 'unique_ptr<type-parameter-0-0, type-parameter-0-1>' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:2635:1: note: candidate template ignored: could not match 'unique_ptr<type-parameter-0-0, type-parameter-0-1>' against 'S'
operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:2635:1: note: candidate template ignored: could not match 'unique_ptr<type-parameter-0-0, type-parameter-0-1>' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:2643:1: note: candidate template ignored: could not match 'unique_ptr<type-parameter-0-0, type-parameter-0-1>' against 'double'
operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:2643:1: note: candidate template ignored: could not match 'unique_ptr<type-parameter-0-0, type-parameter-0-1>' against 'S'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:4071:1: note: candidate template ignored: could not match 'shared_ptr<type-parameter-0-0>' against 'S'
operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:4071:1: note: candidate template ignored: could not match 'shared_ptr<type-parameter-0-0>' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:4125:1: note: candidate template ignored: could not match 'shared_ptr<type-parameter-0-0>' against 'S'
operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:4125:1: note: candidate template ignored: could not match 'shared_ptr<type-parameter-0-0>' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:4133:1: note: candidate template ignored: could not match 'shared_ptr<type-parameter-0-0>' against 'double'
operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/memory:4133:1: note: candidate template ignored: could not match 'shared_ptr<type-parameter-0-0>' against 'S'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/functional:2588:1: note: candidate template ignored: could not match 'function<type-parameter-0-0 (type-parameter-0-1...)>' against 'S'
operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/functional:2588:1: note: candidate template ignored: could not match 'function<type-parameter-0-0 (type-parameter-0-1...)>' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/functional:2593:1: note: candidate template ignored: could not match 'function<type-parameter-0-0 (type-parameter-0-1...)>' against 'double'
operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/functional:2593:1: note: candidate template ignored: could not match 'function<type-parameter-0-0 (type-parameter-0-1...)>' against 'S'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string_view:614:6: note: candidate template ignored: could not match 'basic_string_view<type-parameter-0-0, type-parameter-0-1>' against 'S'
bool operator==(basic_string_view<_CharT, _Traits> __lhs,
     ^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string_view:623:6: note: candidate template ignored: could not match 'basic_string_view<type-parameter-0-0, type-parameter-0-1>' against 'S'
bool operator==(basic_string_view<_CharT, _Traits> __lhs,
     ^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string_view:623:6: note: candidate template ignored: could not match 'basic_string_view<type-parameter-0-0, type-parameter-0-1>' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string_view:632:6: note: candidate template ignored: could not match 'basic_string_view<type-parameter-0-0, type-parameter-0-1>' against 'double'
bool operator==(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
     ^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string_view:632:6: note: candidate template ignored: could not match 'basic_string_view<type-parameter-0-0, type-parameter-0-1>' against 'S'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string:565:6: note: candidate template ignored: could not match 'fpos<type-parameter-0-0>' against 'S'
bool operator==(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
     ^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string:3970:1: note: candidate template ignored: could not match 'basic_string<type-parameter-0-0, type-parameter-0-1, type-parameter-0-2>' against 'S'
operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string:3982:1: note: candidate template ignored: could not match 'basic_string<char, std::__1::char_traits<char>, type-parameter-0-0>' against 'S'
operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string:4001:1: note: candidate template ignored: could not match 'const _CharT *' against 'S'
operator==(const _CharT* __lhs,
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string:4001:1: note: candidate template ignored: could not match 'const _CharT *' against 'double'
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string:4014:1: note: candidate template ignored: could not match 'basic_string<type-parameter-0-0, type-parameter-0-1, type-parameter-0-2>' against 'S'
operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
^
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/usr/include/c++/v1/string:4014:1: note: candidate template ignored: could not match 'basic_string<type-parameter-0-0, type-parameter-0-1, type-parameter-0-2>' against 'double'
1 error generated.
*/

這是 Clang 下給出的結果. Concept 的引入除了需要簡化程式碼的寫法之外, 還有就是希望簡化編碼錯誤

另外, 我已經寫過一篇關於 Concept 的文章了 :《C++ 2a 特性導讀 – Concept》, 這篇文章寫的時間是 2019 年, 當時 C++ 20 標準還沒有發布, 實際納入標準的內容和文章有一些衝突, 因此我重新寫了這篇文章

2. 基本概念

2.1 關鍵字

Concept 中引入了兩個新的關鍵字 : conceptrequires, 這兩個關鍵字都是 C++ 20 之前沒有的

2.2 定義

要定義一個 Concept 非常簡單 :

template <PARAMETERS>
concept CONCEPT-NAME = CONSTRAINT-EXPRESSION;

其中, PARAMETERS 是樣板參數列表, CONCEPT-NAME 為 Concept 的名稱, CONSTRAINT-EXPRESSION 為制約表達式. 制約表達式必須可以在編碼期間被計算, 其結果為一個布林常數, 在下面的小節中, 我們將詳細介紹制約表達式. 這裡, 我們只需要了解 truefalse 是最簡單的制約表達式 :

template <typename>
concept C = true;

任何布林常數表達式都是制約表達式, 都可以被放入 Concept 中 :

template <typename T>
concept C = sizeof(T) > 0;

這裡需要注意的是, 任意一個 Concept 必定是一個樣板. 也就是說, 下面這個不帶有樣板的 Concept 是錯誤的 :

concept C = true; // error: expected unqualified-id

因此, 所有樣板的限制在 Concept 上也可以體現出來. 例如, Concept 不能在函式之內被定義, 因為樣本就不能被定義在函式之內, 甚至連宣告都不行. 除了這個限制之外, 一個 Concept 不能被特製化, 包括偏特製化 :

template <typename T>
concept C = true;
template <>
concept C<int> = false;     // error: name defined in concept definition must be an identifier

一個 Concept 的結果是一個布林常數表達式, 並且是一個純右值. 因此, 就可以這樣使用 Concept :

template <typename T>
concept C = true;
constexpr auto b {C<int>};      //OK
static_assert(C<char>);     //OK
static_assert(not C<void *>, "static assert failed!")       //Error : static assert failed!

相比於類別樣板和函式樣板, 它們都可以被宣告而暫不定義. 但是 Concept 不能被僅宣告, 只要它出現的地方必定是一個 Concept 的定義, 否則就會產生編碼錯誤. 另外, Concept 在自己的定義是無法找到自己的名稱的 :

template <typename T>
concept C = C<T *>;

這也是由 Concept 無法特製化的性質決定的. 否則的話, Concept 的遞迴就無法結束. 換句話說, Concept 無法遞迴

3. 進階

3.1 制約 Constraint

制約是隨著 Concept 一起引入的, 一般來說它和 Concept 是一起出現的. 制約是指針對樣板的制約. 我們都知道 Concept 的引入就是為了制約樣板, 然而 C++ 20 還提供了另外一種方式來制約樣板, 也就是 requires 表達式

3.1.1 requires 表達式

requires 表達式是制約表達式中的一種. 一個 requires 表達式的組成如下 :

requires(PARAMETERS) {
    REQUIREMENT-SEQUENCES;
}

其中, PARAMETERSrequires 表達式的參數, 這個參數並不是樣板參數, 而是類似於函式參數 (或者說, 它幾乎等同於函式參數), 這個參數列表是可選的; REQUIREMENT-SEQUENCES 是一系列的需求, 它至少包括了一個需求, 也就是說 requires 表達式不能為空. 需要注意的是, requires 表達式中的需求序列都處於不可估量語境中

一個 requires 表達式的結果就是純右值的布林常數表達式, 也就是說它是一個制約表達式. 那麼自然地, requires 表達式就可以出現在 Concept 中 :

template <typename>
concept C = requires {
    //...
};

需求序列包含了四種 :

3.1.1.1 簡單需求

簡單需求是指檢查一個表達式. 編碼器會檢查這個表達式在當前的語境中是否合法. 換句話說, 假如這個表達式如果出現在實際應用中, 會不會產生編碼錯誤 :

template <typename T, typename U>
concept C = requires(T t, U u) {
    t + u;
};

這裡並不是去計算 t + u 的值, 因為一個 Concept 不可能被呼叫, tu 的值永遠是未知的 (這就是為甚麼 requires 表達式中的需求序列都是處於不可估量語境中的原因). 因此, 這裡只能檢查 t + u 是否合法. 如果表達式 t + u 可以產生結果, 那麼 requires 表達式的結果就是 true; 否則, 這個 requires 表達式的結果為 false. 這裡需要說明的是, 如果某個名稱到 Concept 處沒有出現, 那麼這也不會直接導致編碼錯誤 :

#include <utility>

template <typename T>
concept C = requires(T &&t) {
    func(std::forward<T>(t));
};

static_assert(C<int>);      //error: static_assert failed, because 'int' does not satisfy 'C', because 'func(std::forward<T>(t))' would be invalid: use of undeclared identifier 'func'

編碼器不會真的嘗試去呼叫函式 func, 而是嘗試去匹配 func, 看看能不能找到這個函式. 如果匹配失敗, 並不會產生編碼錯誤, 而是讓 requires 表達式回傳一個 false 的結果. 但是對於變數就沒有那麼幸運了 :

template <typename>
concept C = requires {
    ++some_var;     //error: use of undeclared identifier 'some_var'
};

如果要針對外部的變數進行操作, 那麼編碼器會首先尋找那個變數是否存在. 如果變數不存在, 就會直接產生編碼錯誤, 而不是 requires 表達式回傳 false. 不過, 在這裡並不要求這個變數一定是編碼期可計算的變數

3.1.1.2 型別需求

型別需求是檢查一個型別是否合法 :

template <typename T>
using reference = T &;
template <typename T>
struct S;

template <typename T>
concept C = requires {
    typename T::type;       //檢查型別 T 內部是否有一個名為 type 的型別
    typename reference<T>;      //檢查型別 reference<T> 是否合法, 即 T & 是否存在
    typename S<T>;      //檢查型別 S<T> 是否合法
    typename T;     //檢查型別 T 本身是否合法, 這個檢查結果永遠為 true
};

要檢查一個型別是否合法, 前面必須要有 typename. 如果缺失 typename, 就變成了檢查型別內部是否存在某個可存取的成員. 另外, 通過 typename S<T>; 這一需求, 我們知道, 在 requires 表達式中, 並不一定要求型別是完整型別, 可以是未實作的型別

3.1.1.3 複合需求

複合需求稍微複雜一些, 也是一種新的語法 :

{EXPRESSION} noexcept -> CONCEPT;

其中, EXPRESSION 是一個表達式, 使用大括號囊括, noexcept-> CONCEPT 是可選的

template <typename T, typename U>
struct is_same {
    constexpr static auto value {false};
};
template <typename T>
struct is_same<T, T> {
    constexpr static auto value {true};
};
template <typename T, typename U>
concept same_as = is_same<T, U>::value;

template <typename T>
concept C = requires {
    {T {}.func()} noexcept -> same_as<int>;
};

首先, requires 表達式檢查 T {}.func() 是否合法. 然後, 會再檢查這個表達式是否是不擲出任何例外情況的. 最後, 會檢查表達式的回傳結果是否滿 same_as, 即能否讓 same_as 回傳 true. 只有所有的檢查都滿足的時候, 複合需求才會回傳 true; 如果有一項不滿足, 則複合需求的回傳結果為 false. 當然, {EXPRESSION} 也可以單獨出現 :

template <typename T>
concept C = requires {
    {T {}.func()};
};

這樣, 雖然 requires 表達式中存在複合需求, 但是複合需求在這裡退化為了簡單需求. 那麼, 上面這個 Concept 就等同於

template <typename T>
concept C = requires {
    T {}.func();
};

在一開始, 尾置回傳型別的檢查不要求必須是 Concept, 也可以是一個型別 T :

template <typename T>
concept C = requires {
    {T {}.func()} -> int;
};

這樣的寫法本來是可以的. 但是, 這種寫法有一個歧異 : 如果我想要 T {}.func() 的結果必須是 int, 而不是通過隱含型別轉化而轉型到 int; 又或者說, 我想要 T {}.func() 的結果可以通過隱含型別轉化轉型為 int, 而並不一定是 int. 這種寫法是無法消除這樣的歧異的. 曾經有人提議引入新的運算子 => 來解決, 但是這會增加 C++ 語言的複雜度, 也沒有必要為了這麼小的一個特性就引入新的運算子. 因此, 最終 P1084R2P1452R2 決定移除這種寫法, 僅保留使用 Concept 制約回傳型別那種寫法

現在, 如果我要求回傳型別必須是 int, 我可以這樣寫 :

template <typename T>
concept C = requires {
    {T {}.func()} -> same_as<int>;
};

如果我要求回傳型別可以通過隱含型別轉化轉型為 int, 我可以這樣寫 :

#include <type_traits>

template <typename T, typename U>
concept convertible_to = std::is_convertible_v<T, U>;

template <typename T>
concept C = requires {
    {T {}.func()} -> convertible_to<int>;
};

當然, 也不一定必須使用這種方法 :

template <typename T>
concept C = requires(T (*fp)(int)) {
    fp(T {}.func());
};

3.1.1.4 巢狀需求

對於一些有能力在編碼器計算的表達式, 我們希望它們被放入 requires 表達式中進行判斷, 就像

template <typename T>
concept C = sizeof(T) == 4;

這樣, C 就有能力檢查給定的型別 T 的大小是否為 4. 如果直接把 sizeof(T) == 4 放入 requires 表達式中呢?

template <typename T>
concept C = requires {
    sizeof(T) == 4;
};

static_assert(C<char>);     //OK

顯然, 這個結果並不是我們想要的. 不過, 這也並不完全出乎意料. 正所謂 requires 簡單需求都處於不可估量語境中, 編碼器只是檢查表達式 sizeof(T) == 4 是否合法, 不會真正去計算 sizeof(T) 是否為 4. 因此, 上面的程式碼可以通過編碼是在意料之內的. 那麼, 如何讓 requires 表達式有能力檢查表達式的計算結果呢? 要在 requires 表達式中使用判斷式, 需要借助 requires 的幫助, 即巢狀需求 :

requires CONSTRAINT-EXPRESSION;

其中, CONSTRAINT-EXPRESSION 為制約表達式. 巢狀需求會去計算 CONSTRAINT-EXPRESSION 中表達式的結果是否滿足相應的制約

現在, 如果我們想要檢查表達式的計算結果, 我們可以這樣去寫 :

template <typename T>
concept C = requires {
    requires sizeof(T) == 4;
};

static_assert(C<char>);     //error: static_assert failed, because 'char' does not satisfy 'C', 'sizeof(char) == 4' (1 == 4) evaluated to false

巢狀需求還可以更加複雜 :

template <typename T>
concept C = requires {
    requires requires(T t) {
        ++t;
    };
};

template <typename T> requires requires(T t) {
    ++t;
} void func();

如果僅僅把 C 寫成 :

template <typename T>
concept C = requires {
    requires(T t) {
        ++t;
    };
};

那樣只是檢查裡面的 requires 表達式是否合法. 而所有的 requires 表達式只要不擲出編碼錯誤, 就必定是合法的. 因此, Proposal P2092R0 提出移除這種寫法. 也就是說, 現在上面這種寫法是可能產生編碼錯誤的

Tip : 說可能產生編碼錯誤是因為截止發文為止, Clang 還沒有實作 P2092R0 中的內容, 因此在 Clang 中這種寫法只會得到警告. 不過相信在不久的將來, 在 Clang 支援之後, 這種寫法在 Clang 中是不被支援的. 在 GCC 中, 這種寫法已經會導致編碼器擲出編碼錯誤

巢狀需求除了可以檢查 requires 表達式之外, 還可以檢查具有編碼期計算能力的函式和變數的能力 :

#define ONE 1

enum E {
    E1, E2, E3
};

constexpr auto a {0};
constexpr int f1() noexcept {
    return 1;
}
consteval int f2() noexcept {
    return 2;
}
constexpr auto b {f1() + f2() + ONE + E1 - E2};

template <typename>
concept C = requires {
    requires a == 0;
    requires f1() == 1;
    requires f2() == 2;
    requires b == 3;
};

static_assert(C<int>);      //OK

3.1.2 制約樣板

3.1.2.1 使用 Concept 制約樣板

Concept 的結果雖然是一個純右值的布林常數表達式, 但是我們可以將 Concept 放到樣板中來制約樣板 :

#include <type_traits>

template <typename T>
concept Integral = std::is_integral_v<T>;

template <typename T, Integral U>
void func(const T &, U);

上述程式碼中, 我們使用 Integral 制約了函式樣板 func 中的樣板參數 U. 這個制約的意思為我們要求任意給定到樣板參數 U 的型別引數必須是一個整形型別, 如果這個制約不被滿足, 那麼函式將會從函式多載的候選集合中被排除 :

#include <iostream>

using namespace std;

template <typename T>
concept Integral = is_integral_v<T>;

template <typename T, Integral U>
void func(const T &, U) {
    cout << "constrained template parameter U by concept Integral" << endl;
}
template <typename T, typename U>
void func(const T &, const U &) {
    cout << "typename U" << endl;
}

int main(int argc, char *argv[]) {
    func(0, 0.0);       //輸出 : typename U
    func(0, 0);     //輸出 : constrained template parameter U by concept Integral
}

這種寫法比使用 SFINAE 要方便得多, 但是本質上它仍然是 SFINAE, 制約不滿足不會導致編碼器直接擲出編碼錯誤, 而是會繼續嘗試尋找可以匹配的函式

這種制約不但在函式樣板中有效, 在類別樣板中同樣有效 :

#include <iostream>

using namespace std;

template <typename T>
concept Integral = is_integral_v<T>;

template <typename T>
struct S {
    S() {
        cout << "default" << endl;
    }
};
template <Integral T>
struct S<T> {
    S() {
        cout << "Integral" << endl;
    }
};

int main(int argc, char *argv[]) {
    S<int> s1;      //輸出 : Integral
    S<float> s2;        //輸出 : default
}

在 C++ 20 之前, 類別 S 的實作則要複雜得多 :

#include <type_traits>

template <typename T, bool>
struct S_impl {
    S_impl() {
        cout << "default" << endl;
    }
};
template <typename T>
struct S_impl<T, true> {
    S_impl() {
        cout << "Integral" << endl;
    }
};
template <typename T>
struct S : S_impl<T, std::is_integral_v<T>> {};

3.1.2.2 使用 requires 表達式制約樣板

3.1.2.1 中討論的方法只是制約的一種方法, 要想制約樣板還有另外一種方法, 即使用 requires 表達式

在函式樣板中, 我們可以直接將 requires 表達式寫在樣板參數列表之後 :

#include <type_traits>

template <typename T> requires is_integral_v<T>
void func() {}

或者可以將 requires 表達式中的判斷式更改為 Concept :

#include <type_traits>

template <typename T>
concept Integral = std::is_integral_v<T>;

template <typename T> requires Integral<T>
void func() {}

其中, 在 requires 關鍵字之後跟隨一個 Concept, 我們稱其為 requires 條款 (requires clause), 它也是制約表達式的一種

也可以將 requires 表達式放在函式參數列表之後 :

#include <type_traits>

template <typename T>
concept Integral = std::is_integral_v<T>;

template <typename T>
void func1() requires std::is_integral_v<T>;
template <typename T>
void func2() requires Integral<T>;

需要注意的是, requires 表達式可以出現在函式的宣告或者定義中, 但是不能出現在和函式相關的型別、變數或者參數中 :

void (*fp)() requires true {nullptr};       //error: trailing requires clause can only be used when declaring a function
void f(void () requires true);      //error: trailing requires clause can only be used when declaring a function
auto p {new (void (*)() requires true)};      //error: expected expected ')'

對於尾置回傳型別的函式, requires 表達式要求出現在尾置回傳型別之後 :

auto func() requires false -> bool;     //error: trailing return type must appear before trailing requires clause
auto func() -> bool requires false;     //OK

另外, 虛擬函式本身不可被樣板化, 也就不能對虛擬函式使用 requires 表達式 :

struct S {
    virtual void func() requires true {}        //error: virtual function cannot have a requires clause
};

對於類別樣板來說, requires 表達式只能出現在樣板參數列表之後 :

#include <type_traits>

template <typename T> requires std::is_integral_v<T>
struct S {};

除此之外, 類別樣板要求樣板中的制約也要嚴格匹配 :

#include <type_traits>

template <typename>
concept C = true;

template <typename T> requires std::is_integral_v<T>
struct S {
    void func();
    void g() requires C<T>;
    template <C U>
    void h();
    template <C U> requires true
    struct X;
};

template <typename T>       //error: requires clause differs in template redeclaration
void S<T>::func() {}
template <typename T> requires std::is_integral_v<T>        //OK
void S<T>::func() {}

template <typename T> requires std::is_integral_v<T>
void S<T>::g() {}     //error: out-of-line declaration of 'g' does not match any declaration in 'S<T>'
template <typename T> requires std::is_integral_v<T>
void S<T>::g() requires C<T> {}     //OK

template <typename T> requires std::is_integral_v<T>
template <typename U>       //error: out-of-line definition of 'h' does not match any declaration in 'S<T>'
void S<T>::h() {}
template <typename T> requires std::is_integral_v<T>
template <C U>      //OK
void S<T>::h() {}

template <typename T> requires std::is_integral_v<T>
template <typename U>       //error: type constraint differs in template redeclaration
struct S<T>::X {};
template <typename T> requires std::is_integral_v<T>
template <C U> requires true     //OK
struct S<T>::X {};

3.1.3 制約對函式和類別的影響

3.1.3.1 函式樣板制約的本質

對函式加入制約之後, 對函式的匹配機制產生了一些影響. 前面我們已經提到過, 加入了制約的函式樣板本質上是 SFINAE, 而並非是函式多載, 這一點和 SFINAE 是一致的. 也就是說, 樣板參數被制約的函式樣板不能算為函式多載

除此之外, 相同的函式的宣告或者定義的過程中, 我們要求制約表達式相同 :

template <typename T> requires (sizeof(T) == 4)
void func() = delete;
template <typename T> requires (sizeof(T) >= 4)
void func() {}
int main(int argc, char *argv[]) {
    func<int>();
}

這種情況下, 就有多個可以匹配的函式, 於是產生了模稜兩可的呼叫, 編碼器會擲出編碼錯誤. 因為編碼器並不知道選擇哪一個函式比較好, 即使第一個函式被設定為被刪除的函式

3.1.3.2 最佳滿足原則

考慮下面程式碼 :

#include <iostream>

using namespace std;

template <typename>
concept C = true;

template <typename T> requires C<T>
void func() {
    cout << "requires C<T>" << endl;
}
template <typename T> requires (C<T> and true)
void func() {
    cout << "requires C<T> and true" << endl;
}

int main(int argc, char *argv[]) {
    func<int>();
}

很顯然, 如果把上述程式碼視為函式多載, 那麼在函式多載中, 兩個函式樣板 func 都是等效的, 編碼器並無法決定哪一個函式更好. 但是在制約中, 編碼器會選中那個更加滿足制約的函式. 也就是說, 如果滿足的制約越多, 那麼這個函式就是越好的匹配. 在 requires C<T> 中, 我們僅要求 T 滿足 C; 然而, 在 requires (C<T> and true) 中, 我們不但要求其滿足 C, 後面還結合了 true. 因此, 第二個滿足的制約更多. 理所應當地, 第二個函式成為了被選中的呼叫函式. 那麼第一個函式什麼時候可以被選中呢? 在第二個函式一直在可視範圍內的情況下, 第二個函式永遠比第一個函式滿足的制約更多, 因此第一個函式永遠不會被選中

對於都帶有制約的相同函式, 編碼器會根據最佳滿足原則, 選取滿足更多制約的那一個函式, 也就是選擇最受制約的那一個

對於類別樣板特製化的匹配來說, 帶有制約的類別在匹配的過程中同樣滿足最佳滿足原則 :

#include <iostream>

using namespace std;

template <typename>
concept C = true;

template <typename>
struct S {
    S() {
        cout << "default" << endl;
    }
};
template <typename T>
struct S<T *> {
    S() {
        cout << "pointer" << endl;
    }
};
template <C T>
struct S<T> {
    S() {
        cout << "concept" << endl;
    }
};
template <C T> requires true
struct S<T> {
    S() {
        cout << "concept with requires" << endl;
    }
};

int main(int argc, char *argv[]) {
    S<int *> s1;     //輸出 : pointer
    S<int> s2;       //輸出 : concept with requires
}

對於指標型別來說, S<T *>, S<C T>S<C T> requires true 都滿足匹配, 但是顯然 S<T *> 滿足的型別範圍比 S<C T>S<C T> requires true 要更少, 因此 S<T *> 更加匹配. 而對於一般型別來說, S<T>S<C T> 永遠不會被匹配, 因為 S<C T> requires true 比它們滿足的制約更多. 因此, 根據最佳匹配原則, 對於其它任意型別, S<C T> requires true 永遠是匹配的第一選擇

3.1.3.3 友誼函式

對於普通的非樣板函式, 我們可以將制約使用 requires 表達式添加在函式的參數列表之後. 但是針對友誼函式來說, 非樣板的友誼函式不能帶有任何制約

3.1.3.4 制約 Concept

很遺憾, 由於 Concept 無法遞迴, 所以任何嘗試制約 Concept 的樣板參數都是不允許的 :

template <typename>
concept C1 = true;
template <C1>     //error: concept cannot have associated constraints
concept C2 = true;
template <typename> requires true       //error: concept cannot have associated constraints
concept C3 = true;

但是, 我們可以通過實作另一個 Concept, 並且將其加入制約 :

#include <iostream>

using namespace std;

template <typename>
concept C1 = true;
template <typename T>
concept C2 = C1<T> and true;

template <C1 T>
void func() {
    cout << "C1" << endl;
}
template <C2 T>
void func() {
    cout << "C2" << endl;
}

int main(int argc, char *argv[]) {
    func<int>();        //輸出 : C2
}

顯然, C2 滿足的制約更多, 因此在函式匹配的過程中會選擇第二個函式 func

說一個個人的設想 : 我其實比較希望允許 Concept 的遞迴和特製化. 那樣, 樣板超編程會變得更加有趣

3.1.3.5 巢狀類別

對於巢狀類別來說, 如果其制約未被滿足, 那麼在它沒有被具現化之前, 編碼器無需對此發出任何警告, 甚至標準都不要求編碼器對此進行診斷 :

template <typename>
struct S {
    template <typename T> requires false        //可以通過編碼, 但是這個巢狀類別不能被具現化
    struct inner1 {};
    template <typename T> requires (sizeof(T [-sizeof(T)]) > 1)     //同樣可以通過編碼, 但是這個巢狀類別不能被具現化
    struct inner2 {};
};

如果進行具現化, 那麼就會產生編碼錯誤 :

template <typename>
struct S {
    template <typename T> requires false
    struct inner1 {};
    template <typename T> requires (sizeof(T [-sizeof(T)]) > 1)
    struct inner2 {};
};

S<int>::inner1 i1;      //error: no viable constructor or deduction guide for deduction of template arguments of 'inner1'
S<int>::inner2 i2;      //error: no viable constructor or deduction guide for deduction of template arguments of 'inner2'

3.1.4 requires 表達式的參數列表

需要注意的是, 函式的參數列表中並不支援直接使用 Concept :

template <typename>
concept C1 = true;

template <typename T>
void func(C1<T> t);     //Error

requires 表達式的參數列表同樣不支援使用 Concept :

template <typename>
concept C1 = true;
template <typename T>
concept C2 = requires(C1<T> t) {      //Error
    ++t;
};

auto 也不支援在 requires 表達式的參數列表中使用 :

template <typename T>
concept C2 = requires(auto t) {      //error: 'auto' not allowed in requires expression parameter
    ++t;
};

C-Style 可變參數也是不允許出現在 requires 表達式參數列表的最後的. 如果要使用可變參數, 就需要使用 C++ 11 的可變參數樣板 :

template <typename T>
concept C1 = requires(T t, ...) {       //error: varargs not allowed in requires expression
    ++t;
};
template <typename F, typename ...Args>
concept C = requires(F f, Args &&...args) {
    f(std::forward<Args>(args)...);
};

如果在 requires 表達式的參數列表中使用巢狀型別, 必須要這樣寫 :

template <typename T>
concept C = requires(typename T::type t) {
    t + t;
};

然而我們知道, 參數 t 前面必定是 t 的型別, 因此 T::type 在此處必定是型別而非一個成員變數或者成員函式. 因此, Proposal P2092R0 提出讓此處的 typename 變為可選的. 也就是說, 我們現在可以這樣去寫 :

template <typename T>
concept C = requires(T::type t) {
    t + t;
};

requires 表達式的參數列表中的任何參數都不允許帶有預設引數 :

template <typename T>
concept C = requires(T t = {}) {        //error: default arguments not allowed for parameters of a requires expression
    *t;
};

由於 requires 表達式處於不可估量語境中, 因此參數列表中的這些變數也不存在連結, 存儲和生命週期

最後, 我們可以將 SFINAE 用在 requires 表達式的參數列表中 :

template <typename T>
concept C = requires(std::enable_if_t<std::is_integral_v<T>, T> t) {
    +t;
};
static_assert(C<int>);      //OK
static_assert(C<float>);        //error: static_assert failed, because 'float' does not satisfy 'C', substituted constraint expression is ill-formed: failed requirement 'std::is_integral_v<float>'; 'enable_if' cannot be used to disable this declaration

如果 SFINAE 出現在 requires 表達式的參數列表中, 替換失敗不會導致編碼錯誤, 而是導致 requires 表達式回傳 false, 即導致最終 C 回傳 false

但是 SFINAE 不能用於 Concept 的參數樣板中 :

#include <type_traits>

template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>       //error: no type named 'type' in 'std::__1::enable_if<false>'; 'enable_if' cannot be used to disable this declaration
concept C = true;

static_assert(C<float>);

3.2 非型別參數樣板

對於樣板中的非型別參數, Concept 和制約同樣適用於它們 :

template <int I>
concept C = I > 42;
template <int I> requires (I > 42)
void func();
template <int I> requires C<I>
struct s;

但是, Concept 作為樣板參數的時候, 其必須是型別參數, 而不能是非型別參數 :

template <int I>
concept C = I > 42;
template <C I>      //error: concept named in type constraint is not a type concept
void func();

3.3 樣板參數中的樣板

和型別參數不同, 樣板參數中的樣板並不支援使用 requires 表達式進行制約 :

template <template <typename T> requires true typename TT>      //Error
void func();

對於樣板參數中的樣板, 其參數限制需要通過 Concept 來完成 :

template <typename>
concept C = true;

template <template <C T> typename TT>       //OK
void func();

Proposal P1616R1 解決了一個樣板參數中的樣板無法接受帶有制約的樣板的情況, 這個情況本來對於 SFINAE 是不存在的 :

template <typename, typename>
struct unconstrained {};
template <typename T, typename, typename = std::enable_if_t<std::is_integral_v<T>>>
struct SFINAE {};
template <typename T, typename> requires std::is_integral_v<T>
struct constrained {};

template <template <typename ...> typename T>
struct temp {};

template <template <typename, typename> typename TT>
struct S {
    template <typename T>
    using type = TT<T, int>;
};
template <template <typename T, typename, typename = std::enable_if_t<std::is_integral_v<T>>> typename TT>
struct S_SFINAE {
    template <typename T>
    using type = TT<T, int>;
};

temp<unconstrained> t1;     //OK
temp<SFINAE> t2;        //OK
temp<constrained> t3;       //Error, 因為 constrained 的樣板參數帶有制約, 因此 temp 暫時還不能接受它

S<unconstrained>::type<int> s1;     //OK
S_SFINAE<SFINAE>::type<int> s2;     //OK
S<constrained>::type<int> s3;     //Error, 同樣因為 constrained 的樣板參數帶有制約

P1616R1 解決了上面的問題, 上面的程式碼現在可以通過編碼

Proposal P0522R0 中已經提出, 讓上面程式碼中的類別 S 相容類別 SFINAE, 也就是讓 S 的樣板參數可以接受 SFINAE 作為引數. 因此, 本來上述程式碼可以簡化為 :

template <typename, typename>
struct unconstrained {};
template <typename T, typename, typename = std::enable_if_t<std::is_integral_v<T>>>
struct SFINAE {};
template <typename T, typename> requires std::is_integral_v<T>
struct constrained {};

template <template <typename ...> typename T>
struct temp {};

template <template <typename, typename> typename TT>
struct S {
    template <typename T>
    using type = TT<T, int>;
};

temp<unconstrained> t1;     //OK
temp<SFINAE> t2;        //OK
temp<constrained> t3;       //Error, 因為 constrained 的樣板參數帶有制約, 因此 temp 暫時還不能接受它

S<unconstrained>::type<int> s1;     //OK
S<SFINAE>::type<int> s2;     //OK
S<constrained>::type<int> s3;     //Error, 同樣因為 constrained 的樣板參數帶有制約

但是由於 Clang 目前沒有支援 (我也在文章《C++ 17 Paper 導讀合集 (二)》中指出了這點), 因此我並沒有採用上面的寫法. 上面的寫法在 GCC 中是可以通過編碼的

3.4 Partial Concept

在 3.1.1.3 中, 我省略了一個問題, 不知道是否有人發現 : 對於 convertible_to 這個 Concept, 當其用於複合需求的時候 :

#include <type_traits>

template <typename T, typename U>
concept convertible_to = std::is_convertible_v<T, U>;

template <typename T>
concept C = requires(T t) {
    {t.func()} -> convertible_to<int>;
};

convertible_to<int> 中的 int 是去替換 Concept 樣板參數中的 T 還是 U? 這個問題對於之前的 same_as 同樣存在

這種被部分替換的 Concept 被稱為局域 Concept (Partial Concept). 對於一個具有 N 個樣板參數的 Concept :

template <typename T_{1}, typename T_{2}, ..., typename T_{N}>
concept C;

其局域 Concept C<T_{1}, T_{2}, ..., T_{N - 1}> 可以表示為

template <typename A>
concept C<A, T_{1}, T_{2}, ..., T_{N - 1}>;

Tip : 此處的程式碼為虛擬碼, 無法通過編碼器編碼

也就是說, 局域 Concept 中的 N - 1 個樣板參數被按順序替換到了原始 Concept 中最後的 N - 1 個樣板參數中, 而保留了第一個樣板參數作為佔位. 對於前面 convertible_to 這個實例中, int 是被替換到了樣板參數 U 的位置, 而樣板參數 T 的位置作為保留. 對於複合需求 {t.func()} -> convertible_to<int>; 中, t.func() 的回傳型別被替換到了樣板參數 T 所在的位置. 因此, 複合需求 {t.func()} -> convertible_to<int>; 可以寫為巢狀需求 :

#include <type_traits>

template <typename T, typename U>
concept convertible_to = std::is_convertible_v<T, U>;

template <typename T>
concept C = requires(T t) {
    requires convertible_to<decltype(t.func()), int>;
};

到目前為止, 若某個 Concept 具有 N 個樣板參數, 那麼其局域 Concept 必定要用 N - 1 個引數去按順序替換 Concept 中後面 N - 1 個樣板參數. 如果想僅僅用 N - 2 個引數去按順序替換 Concept 中後面 N - 2 個樣板參數是未被 C++ 20 支援的. 也就是說, 下面的虛擬碼是錯誤的 :

template <typename T_{1}, typename T_{2}, ..., typename T_{N}>
concept C;

template <typename A, typename B>
concept C<A, B, T_{1}, T_{2}, ..., T_{N - 2}>;     //Error

3.5 可變參數樣板

可變參數樣板和 Concept 結合的情況比一般情況稍微複雜一些

3.5.1 Concept 不是可變參數的

在 Concept 不是可變參數的, 但是函式樣板或者類別樣板是使用了 Concept 的可變參數的情況下, 可以用以下程式碼描述這種情況 :

template <typename>
concept C = true;
template <C ...Ts>
void func();

在上述程式碼中, 我們要求函式樣板 func 所接收的所有樣板引數都滿足 Concept C, 即我們可以將上述程式碼轉換為 :

template <typename>
concept C = true;
template <typename T_{1}, typename T_{2}, ..., typename T_{N}>
void func() requires C<T_{1}> and C<T_{2}> and ... and C<T_{N}>;

3.5.2 Concept 是可變參數的

3.5.2.1 函式樣板或者類別樣板不是可變參數的

這種情況可以用下面的程式碼來描述 :

template <typename ...>
concept C = true;
template <C T>
void func();

這種情況很簡單, 就是要求函式樣板 f 的樣板參數 T 滿足 C<T>. 只不過 C 是一個可以接受任意數量的樣板參數的 Concept 罷了

3.5.2.2 函式樣板或者類別樣板也是可變參數的

這種情況可以用下面的程式碼來描述 :

template <typename ...>
concept C = true;
template <C ...Ts>
void func();

這種實際上就是結合了前面兩種情況的程式碼. 把這個程式碼轉換一下, 就得到了下面這個虛擬碼 (無法通過任何編碼器編碼) :

template <typename ...>
concept C = true;
template <typename T_{1}, typename T_{2}, ..., typename T_{N}>
void func() requires C<T_{1}> and C<T_{2}> and ... and C<T_{N}>;

其中, C 是一個可以接受任意數量的樣板參數的 Concept 罷了

Tip : 上述轉換之後的程式碼屬於虛擬碼, 無法通過編碼器編碼

3.5.3 折疊表達式

對於僅僅接受單個樣板參數的 Concept, 如果我們想讓一個引數包中的所有樣板引數都參數滿足這個 Concept, 此時我們不能簡單地進行引數包展開 :

template <typename>
concept C1 = true;
template <typename ...Ts>
concept C2 = C1<Ts>...;     //Error

而需要借助折疊表達式 :

template <typename>
concept C1 = true;
template <typename ...Ts>
concept C2 = (C1<Ts> and ...);      //OK

3.6 預設引數

Concept 的樣板參數列表中的參數也可以有預設引數, 這個和函式樣板或者類別樣板是一樣的 :

template <typename = int>
concept C = true;
static_assert(C<>);        //OK

但是針對使用了 Concept 制約樣板參數的函式樣板或者類別樣板, 如果樣板參數受到了 Concept 的制約並且帶有預設引數, 我們要求這些預設引數也要滿足 Concept. 但是一般來說, 在樣板沒有具現化之前, 編碼器是不會因為樣板的預設引數未滿足制約而擲出編碼錯誤 :

template <typename T>
concept C = sizeof(T) > 2;
template <C T = int>        //OK
void func(T);
template <C T = char>       //OK, 不會擲出編碼錯誤, 因為它還沒有被具現化
void func();

然而一旦其被具現化, 就會產生編碼錯誤 :

template <typename T>
concept C = sizeof(T) > 2;
template <C T = int>        //OK
void func(T);
template <C T = char>       //candidate template ignored: constraints not satisfied [with T = char], because 'char' does not satisfy 'C'
void func();

int main(int argc, char *argv[]) {
    func<>();       //error: no matching function for call to 'func'
}

如果主動給定了滿足制約的引數, 就不會產生編碼錯誤 :

template <typename T>
concept C = sizeof(T) > 2;
template <C T = int>        //OK
void func(T);
template <C T = char>       //預設引數 char 沒有滿足制約, 但是給定的引數 long 滿足制約
void func();

int main(int argc, char *argv[]) {
    func<long>();       //OK
}

4. 雜項

4.1 參數影射

為了理解後面的原子制約, 我們首先使用一個實例來演示參數影射 :

template <typename T>
concept A = T::value;
template <typename U>
concept B = A<U *>;
template <typename V>
concept C = B<V &>;

對於 B 來說, 它直接將 A 中的樣板參數 T 影射為 U * (T \rightarrow U *), 然後得到 (U *)::value; 對於 C 來說, 它首先將 B 的樣板參數 U 影射為 V & (U \rightarrow V &), 然後再將 A 中的樣板參數 T 影射為 V & * (T \rightarrow V & *), 最後得到 (V & *)::value. 顯然, BC 對應的影射到最後會導致錯誤的程式碼, 但是在 Concept 未被用在制約且制約未被檢查之前, C++ 標準並不要求編碼器必須對上述程式碼發出錯誤警告, 甚至不要求進行診斷. 顯然, 對於 C 來說, 在影射結果得到 V & * 的時候, 就已經出現錯誤了, 因為並不存在參考的指標

4.2 制約序列

一個制約序列可能存在多個制約表達式, 最終制約的結果取決於這些子制約表達式的結果的某種邏輯運算, 制約序列的最終結果是一個 bool 型別的常數表達式. 例如制約表達式 requires (sizeof(int) == 4 and sizeof(long) == 8) 這個制約表達式結合了兩個子制約表達式, 分別是 requires (sizeof(int) == 4)(requires sizeof(long) == 8)

於是, 根據邏輯操作的分類, C++ 20 標準將制約序列進行了分類 :

  • 結合 (conjunction) 制約
  • 分離 (disjunction) 制約
  • 原子 (atomic) 制約

4.2.1 結合制約和分離制約

結合制約和分離支援分別對應了邏輯運算中的 \wedge\vee, 也就是對應了 C++ 運算子中的 andor, 亦即 &&||

對於結合制約來說, 計算順序從左至右, 若且唯若所有制約都被滿足, 那麼結合制約就被滿足; 對於分離制約來說, 計算的順序也是從左至右, 只要有一個制約被滿足, 那麼整個分離制約就被滿足

4.2.2 原子制約

一個原子制約由一個表達式和出現在表達式中樣板參數至樣板引數的影射, 這個樣板引數和受制約實體的樣板參數有關. 兩個原子制約若且唯若它們由同一個表達式組成, 並且參數影射的目標也相同的時候, 我們稱兩個原子制約相等

引用 4.1 中的實例的一部分 :

template <typename T>
concept A = T::value;
template <typename U>
concept B = A<U *>;

對於 B 來說, 它要做的影射實際上是針對 A 的樣板參數 TU * 的影射, U * 作為 A 的樣板引數, 表達式為 A<U *>, 受制約的實體為 B, A 的樣板引數 U * 和受制約實體 B 的樣板參數 U 相關聯

原子制約的結果必須是型別為 bool 的常數表達式, 其中不能存在隱含型別轉化 :

struct S {
    constexpr operator bool() const noexcept {
        return true;
    }
    constexpr bool operator()() const noexcept {
        return true;
    }
};

void func() requires (S {});        //error: atomic constraint must be of type 'bool' (found 'S')
void func() requires (S {}());      //OK

另外, 原子制約是制約表達式中最小的制約. 也就是說可以由原子制約組成其它類型的制約, 但是無法再將原子制約拆分為更小的制約

4.3 制約正規化

實際上, 給定一個制約表達式, 編碼器在計算制約表達式的結果之前, 首先要對制約表達式進行制約正規化. 制約正規化的結果是制約表達式的範式的組合. 對於一個表達式的範式的定義如下 :

  • 表達式 (E) 的範式是 E
  • 表達式 E1 and E2 (E1 && E2) 的範式是 E1E2 的合取 (conjunction) : E1 \wedge E2
  • 表達式 E1 or E2 (E1 || E2) 的範式是 E1E2 的析取 (disjunction) : E1 \vee E2
  • 一個 Concept C<A_{1}, A_{2}, ..., A_{N}> 的範式是一個關於 C 的制約表達式的範式. 對於每個原子制約在參數影射時, 我們使用 A_{1}, A_{2}, ..., A_{N} 去替換 C 中對應的樣板參數
  • 其它表達式的範式是其對應的原子制約. 其參數影射為到自身的影射 (這裡包括了折疊表達式, 一切以 andor (&&||) 運算子進行的折疊都算在內)

Tip : 這裡特別說明一下, 到自身的影射就是用自己的樣板參數去替換自己, 這是概念上的而非實際上的. 所以此處同樣不存在遞迴的影射. 另外, 所有用戶自訂的 andor (&&||)  運算子在制約正規化中都無效

我們可以看到, 每一個範式最終都是一個原子制約. 制約正規化的過程就是將制約表達式轉換成原子制約的析取或者合取

4.4 制約轉換

在制約正規化中, 我們已經提到了編碼器在處理制約表達式的時候, 要首先將制約進行正規化 :

  • 如果一個樣板僅僅具有一個制約, 那麼制約就會轉換為這個制約表達式的範式
  • 如果一個樣板具有多個制約, 編碼器會以如下順序將所有制約表達式轉換為一個關於 and (&&) 運算的範式 :
    • 在樣板參數中, 如果某些參數是被 Concept 制約的, 那麼按照樣板參數的順序首先處理這些參數對應的制約表達式
    • 在樣板參數之後, 如果使用了 requires 表達式進行制約, 那麼處理這些制約表達式
    • 在函式參數之後, 如果還存在 requires 表達式, 最後處理這些制約表達式

對於下面的實例 :

template <typename>
concept C = true;

template <typename T, C U> requires C<T>
void func() requires (sizeof(T) > 1 and sizeof(U) > 1);

首先, 編碼器處理函式樣板 func 的樣板參數列表中的第二個樣板參數 C U, 它的制約表達式為 C<U>, 範式為 C<U>; 然後, 編碼器處理樣板參數列表之後的 requires 制約, 它的制約表達式就是 C<T>, 範式為 C<T>; 最後, 編碼器會處理位於函式參數列表之後的 requires 制約, 其制約表達式為 sizeof(T) > 1 and sizeof(U) > 1, 範式為 sizeof(T) > 1 \wedge sizeof(U) > 1. 最終, 編碼器會檢查各個範式的合取 C<U> and C<T> and sizeof(T) > 1 and (sizeof(T) > 1 \wedge sizeof(U) > 1) 是否滿足. 如果範式滿足並且函式的引數和函式的參數匹配, 那麼這個函式會被加入函式呼叫候選集合中

4.5 制約的偏序關係

我們說某個制約 P 歸入制約 Q 若且唯若制約 P 可以推導出制約 Q, 即 P \Rightarrow Q. 如果設 A 為滿足制約 P 的型別集合, B 為滿足制約 Q 的型別集合, 只要 P \Rightarrow Q 成立, 那麼必有 A \subseteq B

需要注意的是, 原子制約 N >= 0 並不一定歸入原子制約 N > 0. 考慮下面這個實例 :

template <typename>
concept C1 = false;
template <typename ...Ts>
concept C2 = (C1<Ts> and ...);

static_assert(C2<>);        //OK
static_assert(C2<int>);     //error: static_assert failed, because 'int' does not satisfy 'C2', 'int' does not satisfy 'C1'

因為當引數包為空的時候, and 運算子的折疊表達式永遠回傳 false; or 運算子的折疊表達式永遠回傳 true

要考察制約 P 是否歸入制約 Q, 首先要通過制約轉換, 將 P 轉換為一系列範式的析取, 將 Q 轉換為一系列範式的合取. 例如設 A, BC 都是原子制約, 制約 A \vee (B \wedge C) 是一系列範式合取之後的析取 (首先看括號內, 然後看是什麼將括號連結到了一起). 如果要將其轉換為一系列範式的析取, 我們只需要將括號內的合取拆開 : A \vee (B \wedge C) == (A \vee B) \wedge (A \vee C), 就變成了範式的合取. 然後, 我們檢查制約 PQ 中是否存在相同的原子制約, 如果不存在, 那麼制約 PQ 不存在任何偏序關係. 如果制約 P 和 制約 Q 中存在相同的原子制約, 我們說制約 P 歸入制約 Q 若且唯若對於 P 的範式中的任意析取子句都可以歸入 Q 的範式中的任意合取子句. 其中, P 的範式中的任意析取子句的原子制約都可以歸入 Q 的範式中的任意合取子句的原子制約. 對於原子制約的歸入, 實際上就是檢查原子制約的相等性. 設 AB 都是原子制約, 制約 P = A \wedge B, 制約 Q = A. 顯然, 如果兩個制約都得到了滿足, 那麼 P \Rightarrow Q, 即 P 歸入 Q. 直觀來說, 更嚴格的制約都得到了滿足, 那麼放鬆一些的制約必定可以滿足. 從上面的定義來說, 如果制約 PQ 都得到了滿足, 那麼原子制約 AB 也都得到了滿足, 自然地, P 中的任何子句及其子句的原子制約都可以歸入 Q 中的任何子句及其子句的原子制約. 只不過在這個例子裡面, PQ 的子句都為原子制約罷了

制約之間的歸入關係定義了制約的偏序關係, 它用來決定 :

  1. 非樣板函式的最佳選擇
  2. 針對函式指標, 非樣板函式地址的最佳選擇
  3. 樣板參數中的樣板的匹配
  4. 類別樣板特製化的偏序
  5. 函式樣板的偏序

對於兩個制約 D_{1}D_{2}, 我們說 D_{1}D_{2} 更受制約若且唯若滿足

  1. 制約 D_{1}D_{2} 都不為空, 制約 D_{1} 可以歸入 D_{2}, 即 D_{1}\Rightarrow D_{2}
  2. 制約 D_{2} 為空, 即 D_{2} 沒有受到任何制約

上述兩個條件中的任意一個條件

之前我們說最佳滿足原則的時候, 大家只是直觀地從程式碼中感覺, 只要約束表達式中的條件越多, 就越滿足. 最後編碼器在選擇函式的時候, 一定會選擇約束條件最多的那一個 :

#include <iostream>

using namespace std;

template <typename T>
concept C = is_integral_v<T>;
template <typename T> requires C<T>
void func() {
    cout << "requires C<T>" << endl;
}
template <typename T> requires C<T> and true
void func() {
    cout << "requires C<T> and true" << endl;
}
int main(int argc, char *argv[]) {
    func<int>();       //輸出 : requires C<T> and true
}

但是我如果把 C<T> 替換一下 :

#include <iostream>

using namespace std;

template <typename T>
concept C = is_integral_v<T>;
template <typename T> requires C<T>
void func() {
    cout << "requires C<T>" << endl;
}
template <typename T> requires is_integral_v<T> and true
void func() {
    cout << "requires C<T> and true" << endl;
}
int main(int argc, char *argv[]) {
    func<int>();       //error: call to 'func' is ambiguous
}

就會出現編碼錯誤. 也就是說, requires C<T> and true 和 is_integral_v<T> and true 代表著不同的制約表達式, 即使它們產生了相同的布林常數值. 因此, 編碼器總是選擇約束條件更多的那一個函式並不是正確的. 在引入了制約序列、制約正規化和制約的偏序關係之後, 我們就可以對編碼器如何作出選擇更加清楚

在上面的實例中, 對於沒有產生編碼錯誤的那一份程式碼, 在呼叫時, 第一個函式樣板 func 的制約為 C<T>, 將其轉化為範式為 is_integral_v<T>, 它是一個原子制約, 我們設為 P. 即制約表達式 is_integral_v<T> 經過制約正規化之後為 P. 再來看第二個函式樣板 func, 其制約為 C<T> and true, 將其轉化為範式為 is_integral_v<T> \wedge true. 而 is_integral_v<T>true 本身也是一個原子制約, 我們分別設為 QR. 即制約表達式 C<T> and true 經過正規化之後的範式為 Q \wedge R. 這裡需要提醒一下, 第一個 func 中的 is_integral_v<T> 和第二個 func 中的 is_integral_v<T> 我們分別設為了 PQ, 而不是同一個原子制約. 但是根據原子制約相等的定義, 顯然原子制約 PQ 相等, 即制約 C<T>C<T> and true 中存在相同的原子制約. 接下來, 我用原子制約 P 來替代原子制約 Q. 現在, 我們討論制約 PP \wedge R 的偏序關係. 直觀上, 制約 P \wedge RP 更受到約束, 因此我們設 A 為 P \wedge R, BP. 即直觀上, 我們有 A \Rightarrow B. 根據歸入的嚴格定義, 我們將制約 A 寫成一系列範式的析取 : P \vee \neg R. 要有 A \Rightarrow B, 我們要求 P \Rightarrow P 並且 \neg R \Rightarrow P. 任何制約都可以歸入到自己本身, 因此 P \Rightarrow P 顯然成立. 而 \neg R \Rightarrow P 同樣成立, 這是因為 \neg RP 更受制約. 這可能不太直觀, 直接一些, \neg R 只有一種結果 :

\neg\text {R} = \begin {cases} \text {true} & {\text {R} = \text {false}} \\ \text {false} & {\text {R} = \text {true}} \end {cases}

而對於 P, 也就是 C<T>, 亦即 is_integral_v<T> 卻有兩種結果 : truefalse. 因此, P \vee \neg R 成立, 編碼器選擇第二個 func

在產生了編碼錯誤的那一份程式碼中, 在呼叫時, 第一個函式樣板 func 的制約為 C<T>, 將其轉化為範式為 is_integral_v<T>, 它是一個原子制約, 我們設為 P. 即制約表達式 is_integral_v<T> 經過制約正規化之後為 P. 再來看第二個函式樣板 func, 其制約為 is_integral_v<T> and true, 將其轉化為範式為 is_integral<T> \wedge true, 我們設為 Q. is_integral_v<T>true, 我們分別設為 QR. 即制約表達式 is_integral_v<T> and true 經過正規化之後的範式為 Q \wedge R. 根據原子制約相等的定義, 原子制約 PQ 並不相等, 因為它們一個由 Concept 組成, 另一個由一個表達式組成, 儘管它們是同一個意思; 原子 PR 顯然不相等. 那麼制約 C<T>is_integral_v<T> and true 之間沒有任何偏序關係, 沒有誰歸入誰. 因此, 在函式 func<int>() 匹配的過程中, 由於這兩個制約不存在偏序關係, 那麼這兩個制約自然也不存在誰比誰更滿足這一層關係, 於是編碼器無法選擇哪一個更好或者更加滿足制約的函式, 擲出了編碼錯誤

現在考慮下面程式碼 :

template <int>
constexpr auto atomic {true};

template <int N>
concept C = atomic<N>;
template <int N>
concept add = C<N + 1>;

template <int N>
void func() requires add<N * 2>;
template <int N>
void func() requires add<2 * N> and true;

int main(int argc, char *argv[]) {
    func<42>();
}

N * 22 * N 我們看來是一樣的, 因此看起來第二個函式樣板更受制約. 但是實際上, add<N * 2>add <2 * N> 會被認為是毫無關聯的原子制約 (P2103R0). 因此, add<N * 2>add <2 * N> and true 沒有任何偏序關係, 因為原子制約相等性並不滿足, 那麼也就不存在誰更受制約的說法, 大家都是受到同一個制約, 並且制約都滿足. 最終, 編碼器並無法決定選擇哪一個函式, 擲出編碼錯誤

Tip : 目前 Clang 和 GCC 都針對此擲出了編碼錯誤, 儘管 Clang 沒有把 Concept 的部分完全實作, 但是我認為 Clang 並不會更改這個程式碼會產生編碼錯誤的結果. 因為根據 P2103R0, C++ 20 標準並不要求編碼器對此擲出編碼錯誤, 甚至不要求診斷

不過, 具現化的過程是必定會讓編碼器無法選擇哪一個函式更好的, 但是僅僅定義是沒有問題的 :

template <typename>
concept C = true;

template <typename T>
void func() requires C<T> {}
template <typename T>
void func() requires true {}

但是如果制約也相同, 就會產生編碼錯誤 :

template <typename>
concept C = true;

template <typename T>
void func() requires C<T> {}
template <typename T>
void func() requires C<T> {}        //error: redefinition of 'func'

4.6 Template-Head

C++ 20 為樣板引入了一個新的概念, 叫做樣板頭部 (template-head). 要判定兩個樣板頭部相同, 必須滿足

  • 樣板的參數列表中擁有相同數量的參數
  • 每一個樣板參數都是同一種類的 : 如果某個位置宣告了一個型別參數、非型別參數、樣板參數、帶有 Concept 限制的參數和引數包, 那麼另外一個樣板頭部對應的位置也應該和此樣板頭部該位置的參數種類相同
  • 如果樣板被 requires 表達式所制約, 那麼 requires 表達式也要相同

4.7 帶有制約樣板的使用

我們已經知道, 如果使用帶有制約的樣板, 如果需要對其具現化, 那麼制約必須滿足 :

template <typename T>
concept C = sizeof(T) not_eq 2;

template <C T>
struct S {};
template <>
struct S<char [2]> {};      //error: constraints not satisfied for class template 'S' [with T = char [2]]

template <C T>
using ptr = T *;

但是有一種特殊情況是例外的, 就是沒有具現化的類別內部如果使用不滿足制約的具現化樣板, 並不一定會有編碼錯誤, C++ 標準甚至不要求對此進行診斷 :

template <typename T>
concept C = sizeof(T) not_eq 2;

template <C T>
using array = T [];

template <typename T, template <C> typename U>
struct S {
    U<short> u;       //在 S 沒有被具現化之前, 這裡可能不會產生編碼錯誤
    array<unsigned char [2]> arr;        //同上
};

4.8 函式指標和制約

一個函式指標不能指向一個不滿足制約的函式 :

void f1() requires true;
void f2() requires false;

void (*p1)() = f1;      //OK
void (*p2)() = f2;      //error: invalid reference to function 'f2': constraints not satisfied

大家可能想用 delctype 或者 auto 去推導, 這也是不允許的 :

void f1() requires true;
void f2() requires false;

auto p1 {f1};       //OK
auto p2 {f2};       //error: invalid reference to function 'f2': constraints not satisfied
decltype(f2) *p3 {f2};      //error: invalid reference to function 'f2': constraints not satisfied

針對不滿足制約的函式進行型別推導是會產生編碼錯誤的 :

#include <iostream>

using namespace std;
void f() requires false;
int main(int argc, char *argv[]) {
    cout << is_same_v<decltype(f), void ()>;        //error: invalid reference to function 'f': constraints not satisfied
}

4.9 Lambda 表達式 (P0857R0)

本來 C++ 20 是不讓 Lambda 表達式支援制約的, 因為 Lambda 表達式的一個宗旨就是做一個簡單的函式. 我們曾在文章《【C++ Paper 與 Proposal 導讀】Lambda 表達式合集》提到, C++ 20 為 Lambda 表達式增加了樣板參數. 因此, 讓 Lambda 表達式也支援制約似乎也是合理的. 有時候, Lambda 表達式並不只是方便, 它還可以將其限定在某個可視範圍之內. 如果 Lambda 表達式不支援制約, 那麼對於本來有參數制約要求的 Lambda 表達式我們必須寫成函式. 這反而違反了 Lambda 表達式的宗旨. 因此, P0857R0 提出讓 Lambda 表達式支援 requires 制約

對於 Lambda 表達式來說, 它支援在兩個地方放入 requires 制約 : 一個是樣板參數列表之後, 另一個是尾置回傳型別之後 :

#include <type_traits>

auto f {[]<typename T> requires std::is_integral_v<T>(auto value, T t) -> T requires std::is_same_v<decltype(value), void *> {}};

4.10 auto 與 Concept auto (P0857R0 與 P1141R2)

C++ 17 為樣板引入了非型別引數的型別推導, 也就是使用 auto 推導非型別引數. Proposal P0857R0 提出為使用 auto 推導的非型別引數增加 requires 制約 :

#include <type_traits>

template <auto V> requires std::is_integral_v<decltype(V)>
struct S {};

雖然到了 C++ 17 為止, auto 已經很類似於一個佔位符, 但是在普通的函式參數列表中並不允許使用 auto. Proposal P1141R2 提出了 Concept auto, 徹底讓 auto 成為了一個佔位符

Concept auto 是指受到 Concept 制約且需要型別推導的參數, 給定的引數對應的型別需要滿足 Concept 制約 :

#include <type_traits>

template <typename T>
concept C = std::is_pointer_v<T>;

void func(C auto p) {
    if(not p) {
        return;
    }
    auto &ref = *p;
    //...
}

int main(int argc, char *argv[]) {
    func(&argc);        //OK
    func(0);        //error: no matching function for call to 'func', because 'int' does not satisfy 'C', candidate template ignored: constraints not satisfied [with p:auto = int]
}

Concept auto 對於 Lambda 表達式特別有用, 因為給 Lambda 表達式增加樣板參數和 requires 表達式卻是比較麻煩, 而且這也會導致 Lambda 表達式不美觀. 有了 Concept auto 之後, 我們就可以將

#include <type_traits>

auto f {[]<typename T> requires std::is_integral_v<T>(auto value, T t) -> T requires std::is_same_v<decltype(value), void *> {
    return v;
}};

改為更優雅的形式 :

#include <type_traits>

template <typename T>
concept integral = std::is_integral_v<T>;
template <typename T, typename U>
concept same_as = std::is_same_v<T, U>;

auto f {[](same_as<void *> auto value, integral auto v) -> decltype(v) {
    return v;
}};

根據局域 Concept, 上面的 same_as<void *> 相當於 same_as<T, void *>, 其中 T 為引數 value 對應的型別

不過 auto 的推導並不是總是令人滿意的, 它會省略掉 constvolatile 和參考限定. 為此, 可以使用 C++ 14 引入的 decltype(auto) :

#include <iostream>

using namespace std;

template <typename T>
concept C = is_integral_v<T>;

int main(int argc, char *argv[]) {
    int a {0};
    int &b {a};
    volatile int c {0};
    const int &d {0};
    //C auto floating_point {0.0};     //error: deduced type 'double' does not satisfy 'C'
    C auto auto_a {a};
    cout << is_same_v<decltype(auto_a), int> << endl;       //輸出 : 1
    C auto auto_b {b};
    cout << is_same_v<decltype(auto_b), int &> << endl;     //輸出 : 0
    C auto auto_c {c};
    cout << is_same_v<decltype(auto_c), volatile int> << endl;      //輸出 : 0
    C auto auto_d {d};
    cout << is_same_v<decltype(auto_d), const int &> << endl;       //輸出 : 0
    C decltype(auto) decl_a {a};
    cout << is_same_v<decltype(decl_a), int> << endl;       //輸出 : 1
    C decltype(auto) decl_b {b};
    cout << is_same_v<decltype(decl_b), int &> << endl;     //輸出 : 1
    C decltype(auto) decl_c {c};
    cout << is_same_v<decltype(decl_c), volatile int> << endl;      //輸出 : 1
    C decltype(auto) decl_d {d};
    cout << is_same_v<decltype(decl_d), const int &> << endl;       //輸出 : 1
}

這些不僅僅可以用於變數推導, 還可以用於函式、樣板和 Lambda 表達式的參數列表中

auto 變為佔位符之後, 就可以使用 operator auto 來多載轉型運算子 :

template <typename T>
concept C = is_integral_v<T>;

template <typename T>
struct S {
    operator C auto() {
        return T {};
    }
};

int main(int argc, char *argv[]) {
    S<int> s1;
    int i {s1};      //i == 0
    S<float> s2;        //OK, 因為 operator C auto 未被具現化, 暫時不檢查制約
    float f {s2};       //error: deduced type 'float' does not satisfy 'C', because 'is_integral_v<float>' evaluated to false, in instantiation of member function 'S<float>::operator C auto' requested here
}

為了使得上面程式碼通過編碼, 我們可能想到為類別 S 增加一個沒有制約的轉型運算子 :

#include <iostream>

using namespace std;

template <typename T>
concept C = is_integral_v<T>;

template <typename T>
struct S {
    operator C auto() {
        return T {};
    }
    operator auto() {
        return T {} + 1;
    }
};

int main(int argc, char *argv[]) {
    S<int> s1;
    int i {s1};     //Error
    S<float> s2;
    float f {s2};       //Error
}

但是實際上, 連變數 i 的初始化都會產生編碼錯誤. 貌似這是不合理的, 但是實際上這和 SFINAE 的行為是一致的 :

#include <iostream>

using namespace std;

template <typename T>
concept C = is_integral_v<T>;

template <typename T>
struct S {
    operator enable_if_t<is_integral_v<T>, T>() {
        return T {};
    }
    operator T() {
        return T {} + 1;
    }
};

int main(int argc, char *argv[]) {
    S<int> s1;
    int i {s1};     //error: multiple overloads of 'operator int' instantiate to the same signature 'int ()'
    S<float> s2;
    float f {s2};       //error: no type named 'type' in 'std::__1::enable_if<false>'; 'enable_if' cannot be used to disable this declaration
}

本來 C++ 20 是支援使用 Concept 制約非型別樣板參數的 :

template <int I>
concept C1 = I > 0;
template <int ...Is>
concept C2 = (C1<Is> and ...);

template <C1 I>
struct S1 {};
template <C2 I>     //I 要求滿足 C2<I>
struct S1_with_C2 {};
template <C2 ...Is>     //Is 要求滿足 C2<Is...>
struct S2 {};

但是, 這本身會導致歧義. 樣板參數中的型別參數我們使用 typename, 非型別參數我們使用引數對應的型別. 但是受到制約的樣板參數到底應該是個型別參數還是非型別參數呢?

因此, P1141R2 提出, 受到制約的樣板參數應該只對型別有效, 移除 Concept 針對非型別樣板參數的支援

4.11 特殊成員函式 (P0848R3)

由於普通函式也支援制約, 因此特殊成員函式也支援制約. 在 C++ 中, 特殊成員函式有

  • 建構子
  • 複製建構子
  • 移動建構子
  • 複製指派運算子
  • 移動指派運算子
  • 解構子

P0848R3 引入一個新的概念, 叫做可行特殊成員函式 (eligible special member function), 用來決定最終到底選擇哪一個. 對於兩個特殊成員函式來說, 首先要看它們是不是同一種類的特殊成員函式, 然後再根據制約決定哪一個是可行特殊成員函式. 對於兩個特殊成員函式, 它們是否屬於同一種類的特殊成員函式, 取決於 :

  1. 它們都是預設建構子
  2. 它們的參數列表的第一個參數是相同型別的複製建構子或者移動建構子
  3. 它們的參數列表的第一個參數是相同型別的複製指派運算子或者移動指派運算子

一個可行特殊成員函式必須滿足 :

  1. 必須是一個特殊成員函式
  2. 它不是一個被刪除的函式
  3. 所有相關的制約必須滿足
  4. 沒有同種類的特殊成員函式比這個函式更滿足制約
#include <iostream>

using namespace std;

template <typename T>
struct S {
    ~S() noexcept requires (sizeof(T) == 4) {
        cout << "sizeof T is 4" << endl;
    }
    ~S() noexcept requires (sizeof(T) not_eq 4) {
        cout << "sizeof T isn't 4" << endl;
    }
};

int main(int argc, char *argv[]) {
    S<int> s1;
    S<char> s2;
    /*
     * 輸出 :
     *   sizeof T isn't 4
     *   sizeof T is 4
    */
}

其它特殊成員函式可以是多載的, 但是一個類別的解構子有且唯有一個, 因此引入制約之後的解構子同樣要滿足這個條件

P0848R3 還解決了一個問題, 即本來帶有制約的建構、複製、移動和解構都不會被編碼器認為是 trivial 的 :

#include <iostream>

using namespace std;

struct S1 {
    S1() requires true = default;
};
template <typename T>
struct S2 {
    S2() requires (sizeof(T) == 1) = default;
    S2() = default;
};

int main(int argc, char *argv[]) {
    cout << is_trivially_default_constructible_v<S1> << endl;       //輸出 : 0
    cout << is_trivially_default_constructible_v<S2<int>> << endl;       //輸出 : 0
    cout << is_trivially_default_constructible_v<S2<char>> << endl;       //輸出 : 0
}

也就是說, 之前的 C++ 2a 標準草案對某個操作是否為 trivial 的限制過於嚴格. 很顯然, 上面的兩個類別的建構、複製、移動和解構都可以是 trivial 的. 因此, P0848R3 也解決了這個問題

4.12 帶有制約的手動具現化 (P2103R0)

之前的 C++ 2a 標準草案並沒有規定在帶有制約的情況下, 手動具現化編碼器應該選擇哪個函式 :

template <typename T>
concept C = true;
template <typename T>
struct S {
    template <typename U>
    U f(U) requires C<typename T::type>;        //error: type 'int' cannot be used prior to '::' because it has no members
    template <typename U>
    U f(U) requires C<T>;
};

template <>
template <typename U>
U S<int>::f(U u) requires C<int> {
    return u;
}

P2103R0 解決了這個問題, 使得上述程式碼可以通過編碼

4.13 擴展的檢查 (P1980R0)

P1980R0 之前, 在宣告匹配的過程中, 編碼器會檢查 requires 表達式是否相同 :

template <int N>
void func() requires (N + 2 > 0) {}
template <int N>
void func() requires (N + 2 > 0) {}     //error: redefinition of 'func'

但是這個檢查僅限於樣板參數中. P1980R0 提出讓這個檢查不僅僅限於樣板參數的制約中, 從制約擴展至所有的表達式. 例如, 任何未經過計算的操作 : 設 A 是一個接受 int 型別的樣板引數的類別樣板, 難道 A<42>A<40 + 2> 應該被認為是不同的類別嗎?

為此, 如果說兩個未經計算的操作是不等價的但卻是功能上等價的, 若且唯若對於給定的樣板引數集合, 表達式可以以相同的順序針對實體有相同的操作. 例如表達式 4240 + 2 顯然是表面上不相同的, 但是對於

template <int>
struct A {};

產生了相同型別的實體, 那麼我們說 4240 + 2 這兩個表達式是不等價但功能等價

4.14 運算子多載時的參數交換 (P2113R0)

P2113R0 提出讓下面程式碼通過編碼 :

template <typename>
concept C = true;

template <typename T, typename U>
struct X {};

template <typename T, C U, typename V>
bool operator==(X<T, U>, V) = delete;
template <C T, C U, C V>
bool operator==(T, X<U, V>);

X<int, char> x;
auto b {x == 0};        //error: overload resolution selected deleted operator '=='

顯然, 表達式 x == 0 選中的函式是 operator==(X<int, char>, int), 但是這個函式被刪除. P2113R0 希望通過嘗試交換參數, 讓編碼器檢查 0 == x 是否可以通過編碼, 如果可以的話, 就採用 0 == x 的結果. 而 0 == x 選中的函式是 operator==(int, X<int, char>), 這個函式是沒有被刪除的

Tip : 不過這個特性沒有被 GCC 所支援, 我覺得 Clang 很可能也不會支援. 因為這個特性本身就是反直覺的

5. 總結

Concept 的入門是挺簡單的, 但是進階並不簡單. 從雜項開始, 可能很多人第一時間無法理解, 但是一般情況下, 根本不需要考慮那麼複雜的情況

由於 Concept 可以很大程度上減少編碼錯誤的提示, 並且 Concept 的寫法比 SFINAE 要簡單得多, 因此本人建議大家在 C++ 20 之後, 盡量採用 Concept, 而不是 SFINAE

除了引入 Concept 這個語言特性之外, C++ 20 還引入了標頭檔 <concepts>, 上面我們自己實作的 same_asconvertible_to 都可以在這個標頭檔中找到

截至發文為止, GCC 基本支援了 C++ 20 標準的 Concept, 而 Clang 還有很多特性沒有做完. 因此, 上面介紹的一些特性可能無法通過 Clang++ 的編碼