如何通过概念选择最佳约束函数模板？ [英] How is the best constrained function template selected with concepts?

查看：82 发布时间：2020/9/28 3:01:51 c++ c++20 c++-concepts

本文介绍了如何通过概念选择最佳约束函数模板？的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

在概念的演示中，显示了这样的内容：

In a presentation of concepts something like this was shown:

template <bidirectional_iterator It>
void sort(It begin, It end);            // #1

template <random_access_iterator It>
void sort(It begin, It end);            // #2

std::list<int> l{};
sort(l.begin(), l.end()); // #A  -> calls #1

std::vector<int> v{};
sort(v.begin(), v.end()); // #B  -> calls #2

通话 #A 很简单：只有 sort＃1 是可行的，因为不满足约束 random_access_iterator ，因此它调用＃1 。

For the call #A it's simple: only sort #1 is viable as the constraint random_access_iterator is not satisfied so it calls #1.

但对于通话 #B 均 sort 是可行的，因为这两个约束（满足 random_access_iterator 和 bidirectional_iterator ）。那么，如何选择更有效率的 sort＃2 ？演示者说它正好起作用。

But for the call #B both sorts are viable as both constraints (random_access_iterator and bidirectional_iterator are satisfied). So how is the "more efficient" sort #2 chosen? The presenter said "it just works".

推荐答案

那么效率更高如何 sort＃2 是否被选择？

之所以有效，是因为存在部分约束上的排序（由 subsums 关系定义）。

It works because there is a partial ordering on constraints (defined by the subsumes relation).

sort＃2 sort＃1 相比，$ c>（具有 randomaccess_iterator 的那个）更受约束。（具有 bidirectional_iterator 的人），因为 randomaccess_iterator 包含 bidirectional_iterator ：

sort #2 (the one with the randomaccess_iterator) is more constrained than sort #1 (the one with bidirectional_iterator) because randomaccess_iterator subsumes bidirectional_iterator:

template <class It>
concept bidirectional_iterator = requires /*...*/;

template <class It>
concept randomaccess_iterator = bidirectional_iterator<It> && requires /*...*/;

要使这项工作受到限制，必须在连词和析取词的语言水平上知道这一点。

To make this work constraints are aware at the language level of conjunctions and disjunctions.

确定一个声明是否比另一个约束更多的过程是这样的：约束规范化->约束包含关系->（定义）约束局部排序->（确定）声明之间的约束关系更多/更少。

The process for determining if a declaration is more or less constrained than another goes like this: Constraint normalization -> constraint subsumes relation -> (defines) constraint partial ordering -> (determines) declarations are more/less constraint relation.

简化，归一化是概念模板参数在约束的参数映射中的替代。

Simplified, normalization is the substitution of the concepts template parameters in the parameter mapping of constraints.

示例：

template <class T> concept integral        = std::is_integral_v<T>;
template <class T> concept signed_integral = integral<T> && std::is_signed_v<T>;
template <class T> concept integral_4      = integral<T> && sizeof(T) == 4;

void foo_1(integral auto)        // #0
void foo_1(signed_integral auto) // #1 
void foo_1(integral_4 auto)      // #2

auto test1()
{
    foo_1(std::uint16_t{});  // calls #0
    foo_1(std::uint32_t{});  // calls #2

    foo_1(std::int16_t{});   // calls #1
    //foo_1(std::int32_t{}); // error ambiguous between #1 and #2
}

积分的普通形式是 std :: is_integral_v

signed_integral 的普通形式为 std :: is_integral_v< T> ∧std :: is_signed_v< T>

正常形式 integral_4 是 std :: is_integral_v< T> ∧sizeof（T）== 4
- the normal form of integral is std::is_integral_v<T>
- the normal form of signed_integral is std::is_integral_v<T> ∧ std::is_signed_v<T>
- the normal form integral_4 is std::is_integral_v<T> ∧ sizeof(T) == 4
  
  signed_integral 包含积分
  
  integral_4 包含积分
  
  ＃1 比＃0
  
  示例：
```
template <class T> concept integral            = std::is_integral_v<T>;
template <class T> concept signed_integral_sad = std::is_integral_v<T> &&
                                                     std::is_signed_v<T>;
template <class T> concept integral_4_sad      = std::is_integral_v<T> && sizeof(T) == 4;


void foo_2(integral auto)             // #0
void foo_2(signed_integral_sad auto); // #1
void foo_2(integral_4_sad auto);      // #2


auto test2()
{
    foo_2(std::uint16_t{});   // calls #0
    //foo_2(std::uint32_t{}); // error ambiguous between #0 and #2

    //foo_2(std::int16_t{});  // error ambiguous between #0 and #1
    //foo_2(std::int32_t{});  // error ambiguous between #0, #1 and #2
}
```
  - 积分的正常形式为 std :: is_integral_v< T>
  - signed_integral_sad 的普通形式为 std :: is_integral_v< T> d std :: is_signed_v< T>
  - 正常形式 integral_4_sad 是 std :: is_integral_v< T> ∧sizeof（T）== 4

查看全文

如何通过概念选择最佳约束函数模板？ [英] How is the best constrained function template selected with concepts?

问题描述

推荐答案

相关文章

C/C++开发最新文章

热门教程

热门工具

登录关闭

如何通过概念选择最佳约束函数模板？ [英] How is the best constrained function template selected with concepts?

问题描述

推荐答案

相关文章

C/C++开发最新文章

热门教程

热门工具

登录 关闭

登录关闭