比如下面这个 GetLength 函数，它希望传入的参数的类型(即类型T)包含 iterator 类型。

进一步考虑这个函数的实现，这个函数还会期待类型T包含 begin 成员函数和 end 成员函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

template<typename T>
size_t GetLength(const T& v)
{
    // 这里用到了类型T中的iterator类型
    // 如果T类型中不包含iterator类型，会生成一大堆编译错误
	typedef T::iterator iterator;
    // 这里用到了T类型中的begin函数
	iterator it = v.begin();
    // 这里用到了T类型中的end函数
	iterator end = v.end();
	size_t result = 0;
	for (; it != end; ++it, ++result);
	return result;
}

这个 GetLength 函数的正确使用方法是：

1
2
3

vector<int> test({1,2,3});
cout << GetLength(test) << endl;     // 输出 3
cout << GetLength("Hello"s) << endl; // 输出 5

vector<int> 类和 string 类中都包含 iterator 类型，而且包含 begin 和 end 成员函数，所以上面的代码可以通过编译。

由于 GetLength 这个模板函数没有做出限制，所以你还可以传入其他类型的参数：

1

cout << GetLength(123) << endl;    // 错误！而且是一大堆错误！

上面的这个例子是无法通过编译的，因为字面量 123 的类型是 int 。 int 类型没有成员类型 iterator ，也没有成员函数 begin 和 end 。

你会得到类似下面这些错误：

1
2
3
4
5
6
7
8
9
10

error C2825: 'T': 当后面跟“::”时必须为类或命名空间
message : 查看对正在编译的函数 模板 实例化“size_t GetLength<int>(T)”的引用
with
[
	T=int
]
error C2510: “T”:“::”的左边必须是类/结构/联合
error C4430: 缺少类型说明符 - 假定为 int。注意: C++ 不支持默认 int
error C2146: 语法错误: 缺少“;”(在标识符“iterator”的前面)
warning C4091: “”: 没有声明变量时忽略“int”的左侧

这些错误实在是不友好，令人摸不着头脑。

出现这些错误的原因是编译器会根据模板生成一个 GetLength<int>(int v) 函数。很显然，不存在 int::iterator ，也不存在 v.begin() 和 v.end() ，编译这个函数的时候肯定会报错。

这就是需要 concept 的原因之一。 使用 concept 可以约束传入模板的类型，对于不满足条件的类型，就不进行模板实例化，可以避免复杂的报错，从而方便定位错误。在介绍 concept 之前，先介绍一种不使用 concept，但是可以达到同样目的的编程技巧。(这个部分可以跳过，不影响理解 concept)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

struct Test {
  typedef int foo;
};

template <typename T>
void f(typename T::foo) {}  // Definition #1

template <typename T>
void f(T) {}  // Definition #2

int main() {
  f<Test>(10);  // Call #1.
  f<int>(10);   // Call #2. Without error (even though there is no int::foo)
                // thanks to SFINAE.
}

虽然 Definition #1 和 Call #2 不匹配(因为没有int::foo)，但是编译器没有就此抛出错误，而是继续尝试另一个模板重载，即 Definition #2。

SFINAE 原则最初是应用于上述的模板编译过程。后来被C++开发者发现可以用于做编译期的决策，配合sizeof可以进行一些判断：类是否定义了某个内嵌类型、类是否包含某个成员函数等。

考虑下面这个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <iostream>
#include <vector>

template <typename T>
struct has_typedef_iterator {
    // Types "yes" and "no" are guaranteed to have different sizes,
    // specifically sizeof(yes) == 1 and sizeof(no) == 2.
    typedef char yes[1];
    typedef char no[2];

    template <typename C>
    static yes& test(typename C::iterator*);	// Definition #1

    template <typename>
    static no& test(...);						// Definition #2

    // If the "sizeof" of the result of calling test<T>(nullptr) is equal to sizeof(yes),
    // the first overload worked and T has a nested type named iterator.
    static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
};

struct foo {
    typedef float iterator;
};

int main() {
    std::cout << std::boolalpha;
    std::cout << has_typedef_iterator<foo>::value << std::endl;//true
    std::cout << has_typedef_iterator<int>::value << std::endl;//false
    std::cout << has_typedef_iterator<std::vector<int> >::value << std::endl;//true

    return 0;
}

类型 foo 定义了内嵌类型 iterator ，与Definition #1匹配。而Definition #1 的返回值类型为 yes ，因此 value 的值为 sizeof(yes) == sizeof(yes) ，即 true 。

类型 int 没有定义内嵌类型 iterator ，与Definition #1 不匹配。根据 SFINAE 原则，此时不会抛出编译错误，而是尝试另一个模板重载，即Definition #2。因为Definition #2的返回值类型为 no , value 的值为 sizeof(no) == sizeof(yes) ，即 false 。

现代C++可以用更少的代码实现上文提到的 has_typedef_iterator ，参考资料[2]这篇文章提到了这一点。

下面使用 enable_if 和 has_typedef_iterator 改进前文提到的 GetLength 函数。

1
2
3
4
5
6
7
8
9
10
11

template<typename T,
	typename = std::enable_if<has_typedef_iterator<T>::value>::type>	// 这一行是关键
size_t GetLength(T v)
{
	typedef T::iterator iterator;
	iterator it = v.begin();
	iterator end = v.end();
	size_t result = 0;
	for (; it != end; ++it, ++result);
	return result;
}

使用方法也没有任何变化：

1
2
3
4

vector<int> test({1,2,3});
cout << GetLength(test) << endl;     // 输出 3
cout << GetLength("Hello"s) << endl; // 输出 5
cout << GetLength(1234) << endl;	 // 这一行是错误的!

唯一的区别是错误使用时，编译器的错误变成了：

1
2
3

error C2672: “GetLength”: 未找到匹配的重载函数
error C2783: “size_t GetLength(T)”: 未能为“<unnamed-symbol>”推导 模板 参数
message : 参见“GetLength”的声明

改进之前，如果错误使用 GetLength 函数,编译器仍然会实例化模板，然后进行编译，从而导致一连串错误。

改进之后，错误使用 GetLength 函数，编译器将停止实例化模板，然后提示 未找到匹配的重载函数 。

从报错的友好程度来看，这个改进简直进步巨大！

那么这是如何做到的呢？

enable_if 的定义非常简单。标准库的代码往往都是晦涩难懂的代码，但 enable_if 的代码却很简单，下面是VC++标准库中 enable_if 的实现：

1
2
3
4
5
6
7
8

// STRUCT TEMPLATE enable_if
template <bool _Test, class _Ty = void>
struct enable_if {}; // no member "type" when !_Test

template <class _Ty>
struct enable_if<true, _Ty> { // type is _Ty for _Test
    using type = _Ty;
};

如果 _Test 的值为 false ，那么enable_if是一个空的struct。反之，如果 _Test 为 true ，enable_if 中会定义一个成员type，默认值为void，或等于传入的_Ty。

考虑改进后的GetLength中关键的一行：

1

typename = std::enable_if<has_typedef_iterator<T>::value>::type

当 has_typedef_iterator<T>::value 为 true 时，enable_if 包含 type 成员，因此这一句代码可以被编译器实例化。

而当 has_typedef_iterator<T>::value 为 false 时，enable_if 不包含任何成员，但是这里又调用了 enable_if::type ，出现了不匹配，无法继续实例化。

下面的内容尚未完成… \
可能含有错误

concept可以完全取代SFINAE技巧，而且写出来的代码更加简洁、易读。concept在编译期被计算、对模板进行约束。

1
2

template < template-parameter-list >
concept concept-name = constraint-expression;

比如约束类型T是类型U的派生类：

1
2

template <class T, class U>
concept Derived = std::is_base_of<U, T>::value;

将前文提到的 has_typedef_iterator 用concept的形式改写：

1
2
3
4
5
6
7

template<typename T>
concept has_iterator = requires(T v)
{
	T::iterator;
	v.begin();
	v.end();
};

has_iterator是concept的名称。 requires(T v) { /*...*/ }; 这部分可以看作是一个函数。
这个函数包含对模板的约束。

在本例中，对模板的约束为：

方式1，将 requires 写在函数后面：

1
2
3
4
5
6
7
8
9
10
11

// 方式1
template<typename T>
size_t GetLength(T v) requires has_iterator<T>
{
	typedef T::iterator iterator;
	iterator it = v.begin();
	iterator end = v.end();
	size_t result = 0;
	for (; it != end; ++it, ++result);
	return result;
}

方式2，将 requires 写在 template 下方：

1
2
3
4
5
6
7
8
9
10
11
12

// 方式2
template<typename T>
requires has_iterator<T>
size_t GetLength(T v) 
{
	typedef T::iterator iterator;
	iterator it = v.begin();
	iterator end = v.end();
	size_t result = 0;
	for (; it != end; ++it, ++result);
	return result;
}

方式3，使用concept名称取代模板关键词typename/class：

1
2
3
4
5
6
7
8
9
10
11

// 方式3
template<has_iterator T>
size_t GetLength(T v)
{
	typedef T::iterator iterator;
	iterator it = v.begin();
	iterator end = v.end();
	size_t result = 0;
	for (; it != end; ++it, ++result);
	return result;
}

此外，concept还可以使用逻辑运算符 && 和 || 。例如：

1
2
3
4
5
6
7
8

template <class T>
concept Integral = std::is_integral<T>::value;

template <class T>
concept SignedIntegral = Integral<T> && std::is_signed<T>::value;

template <class T>
concept UnsignedIntegral = Integral<T> && !SignedIntegral<T>;

使用concept对模板进行约束后，如果错误使用模板，会出现类似下面的错误：

1
2
3

error C2672: “GetLength”: 未找到匹配的重载函数
error C7602: “GetLength”: 未满足关联约束
message : 参见“GetLength”的声明

模板的报错更加友好了。

1
2
3
4
5
6

template<typename T>
concept has_iterator = requires(T v){/*...*/}; // 定义 requires-expressions

template<typename T>
requires has_iterator<T>  // 引入约束条件
size_t GetLength(T v) {} 

特别的，上面的 GetLength 函数可以写成这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

template<typename T>
requires requires(T v)		// 注意，这里有两个 requires
{
	T::iterator;
	v.begin();
	v.end();
}
size_t GetLength2(T v) 
{
	typedef T::iterator iterator;
	iterator it = v.begin();
	iterator end = v.end();
	size_t result = 0;
	for (; it != end; ++it, ++result);
	return result;
}