深入理解c++20 concepts

目录

• 没有concept时，如何实现对模板参数进行约束？
• static_assert
• SFINAE
• enable_if
• 有了concept之后如何使用？
• 声明concept
• 使用concept
• 总结

concepts在c++20中被引入，其作用是对模板参数进行约束，极大地增强了c++模板的功能。

在c++20之前，如果希望获取类似的效果，使用起来并不方便。

没有concept时，如何实现对模板参数进行约束？

static_assert

我们可以使用static_assert去对模板类型T进行约束。如下所示：

#include <type_traits>
#include <iostream>
template<class T>
void test(T a)
{
    static_assert(std::is_integral<T>());
    std::cout << "T is integral" << std::endl;
}
int main()
{
    test(10);
    test<double>(12.3); 
}

但是该种方法不太好，因为需要将static_assert嵌入到函数的内部，这意味着即使类型不对，模板还是成功的匹配上了，只是在模板函数内部展开时出现编译错误。

SFINAE

SFINAE是Substitution Failure Is Not An Error的缩写，翻译过来的意思是替换失败并不是一个错误。

SFINAE是模板元编程中常见的一种技巧，如果模板实例化后的某个模板函数（模板类）对该调用无效，那么将继续寻找其他重载决议，而不是引发一个编译错误。

因此一句话概括SFINAE，就是模板匹配过程中会尝试各个重载模板，直到所有模板都匹配失败，才会认为是真正的错误。

例如下面这个经典的例子：

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.
}

f<Test>(10)最终将使用到第一个模板定义， 而f<int>(10)最终将使用到第二个模板定义。

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

template <typename T>
struct has_iterator_category {
    struct two { char a; char b; };
    template <typename C>
    static two& test(typename C::iterator_category*);
    template <typename>
    static char& test(...);
    static const bool value = sizeof(test<T>(nullptr)) == sizeof(two);
};

enable_if

enable_if的出现使得SFINAE使用上更加方便，进一步扩展了上面has_xxx，is_xxx的作用。而enable_if实现上也是使用了SFINAE。

enable_if的定义简单， 即当_Test是true时，将不会有type的类型定义，而当_Test是false时，将会有type的类型定义。

// 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;
};

下面是利用enable_if去实现SFINAE的方式。

#include <type_traits>
#include <iostream>
template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type 
test(T value)
{
    std::cout<<"T is intergal"<<std::endl;
    return value;
}
template <typename T>
typename std::enable_if<!std::is_integral<T>::value, T>::type 
test(T value)
{
    std::cout<<"T is not intergal"<<std::endl;
    return value;
}
int main()
{
    test(100);
    test('a');
    test(100.1);
}

可以看到SFINAE的主要实现了is_xxx和has_xxx的语义，但是其语法并不简单，对使用者有较高要求，并且即便写正确了，可读性也相对较差。

有了concept之后如何使用？

声明concept

声明一个concept的语法如下所示：

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

例如，约束T是一个整形：

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

也可以使用requires更加灵活地定义concept，例如下面的例子要求T类型拥有一个名字叫做print的方法，另外需要拥有一个toString方法，并且返回值是string类型。

template <typename T>
concept printable = requires(T t) {
    t.print(); //1
    {t.toString()} -> std::same_as<std::string>; //2
};

使用concept

使用concept有三种方式：

方法1：直接将concept嵌入模板的类型的尖括号<>内

template<Arithmetic T> 
void f(T a){/*function definition*/};
we can enforce it just after template declaration using requires:

方法2：在模板声明的下方使用requires关键字

template<class T> 
requires Arithmetic<T>
void f(T a)
{/*function definition*/};
or after the function declaration

方法3：使用后置形式，直接在函数声明的后方使用requires关键字添加约束。

#include<concepts>
template<class T>
void f(T a) requires integral<T> // integral is in header <concepts>    
{/*function definition*/}; 

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

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>;

下面是两个完整的例子来看看concepts是如何实现了is_xxx和has_xxx的功能。

第一个例子中test模板T只能是整形或者是double。实现了is_xxx。

#include <iostream>
template <class T>
concept Integral = std::is_integral<T>::value;
template <class T>
concept IsDouble = std::is_same<T, double>::value;
template<Integral T>
void test(T a)
{
    std::cout << "test(int) functin called" << std::endl;
}
template<IsDouble T>
void test(T a)
{
    std::cout << "test(double) functin called" << std::endl;
}
int main()
{
    test(100);
    test(10.0);
}

第二个例子中print函数要求t拥有print函数。实现了has_xxx。

#include <iostream>
template <typename T>
concept Has_print = requires(T t) {
    t.print(); //1
};
class HasPrint
{
public:
    void print(){};
};
class NoPrint
{
};
template<Has_print T>
void print(T t)
{
    t.print();
}
int main()
{
    HasPrint t;
    print(t);
    NoPrint t2;
    print(t2); //将报编译错误
}

总结

c++20的concepts增强了模板对于参数类型约束的功能，语法简单，可以提高代码的可读性。
如果你的项目不能使用较新的标准，那么还是要老老实实的使用SNINAE，enable_if那一套东西。