C++20 Concepts简介

已于 2025-02-18 20:34:51 修改
阅读量792 收藏 9
点赞数 14
分类专栏： Modern C++ 文章标签： c++20 c++ stl
于 2024-04-01 19:27:14 首次发布
CC BY-NC-ND 3.0
本文链接：https://blog.csdn.net/arong_xu/article/details/137243943
版权

简介

在使用 STL 库的时候, 我们经常会遇到编译器的错误提示冗长且难以理解的情况. 这是因为编译器对模板的编译是分为两步, 第一步是模板的实例化, 使用用户提供的类型去替代模板参数, 第二步是对实例化后的代码进行编译. 编译器报告错误的时候往往是在第二步.

C++20 引入了 Concepts, 它是一种对模板进行约束的机制. Concept 可以用在函数模板(Function Template), 类模板(Class Template), 通用函数成员(Generic Member Function)上. 能对模板参数, 函数参数进行约束. 约束作为接口的一部分, 允许编译器对其进行检查, 能让编译器更早发现错误, 提供更好的错误信息.

如何使用 Concepts

有四种方式使用concepts:

  1. requires语句
  2. 尾部的 requires 语句
  3. 受约束的模板参数
  4. 函数模板缩写
#include <concepts>
#include <iostream>
using namespace std;

template <typename T>
  requires integral<T>  // Requires clause
auto max1(T a, T b) {
  return a >= b ? a : b;
}

template <typename T>
auto max2(T a, T b)
  requires integral<T>  // Trailing requires clause
{
  return a >= b ? a : b;
}

template <integral T>  // Constrained template parameter
auto max3(T a, T b) {
  return a >= b ? a : b;
}

auto max4(integral auto a,  // Abbreviated function
          integral auto b)  // template
{
  return a >= b ? a : b;
}

int main() {
  cout << "max1(1,2) = " << max1(1, 2) << '\n';
  cout << "max2(1,2) = " << max2(1, 2) << '\n';
  cout << "max3(1,2) = " << max3(1, 2) << '\n';
  cout << "max4(1,2) = " << max4(1, 2) << '\n';
}

代码输出:

max1(1,2) = 2
max2(1,2) = 2
max3(1,2) = 2
max4(1,2) = 2

Concepts 使用场景

Concepts 的使用场景有很多, 下面是一些常见的使用场景.

编译时谓词(Compile Time Predicates)

#include <iostream>
using namespace std;

template <typename T>
void checkIntegral(T value) {
  if constexpr (integral<T>) {  // compile-time predicate
    cout << "The value is integral.\n";
  } else {
    cout << "The value is not integral.\n";
  }
}

int main() {
  checkIntegral(5);    // The value is integral.
  checkIntegral(5.5);  // The value is not integral.
  return 0;
}

类模板(Class Template)

#include <concepts>

template <std::regular T> // class template
class Container {
 public:
  void push_back(const T& item) {}
};

int main() {
  Container<int> a;   // OK
  Container<int&> b;  // ERROR: constraints not satisfied
}

成员函数模板

#include <concepts>

template <typename T>
struct Container {
  void push_back(const T&)
    requires std::copyable<T> // generic member function
  {}
};

struct NotCopyable {
  NotCopyable() = default;
  NotCopyable(const NotCopyable&) = delete;
};

int main() {
  Container<int> a;
  a.push_back(2020);

  Container<NotCopyable> b;    // OK
  b.push_back(NotCopyable());  // ERROR, requires copyable
}

可变参数模板

#include <concepts>
#include <iostream>

template <std::integral... Args>
bool all_positive(Args... args) {
  return (... && (args > 0));
}

template <std::integral... Args>
bool any_positive(Args... args) {
  return (... || (args > 0));
}

template <std::integral... Args>
bool none_positive(Args... args) {
  return not(... || (args > 0));
}

int main() {
  std::cout << std::boolalpha;
  std::cout << " all positive: " << all_positive(-1, 0, 1) << '\n';
  std::cout << " any positive: " << any_positive(-1, 0, 1) << '\n';
  std::cout << "none positive: " << none_positive(-1, 0, 1) << '\n';
}

执行输出:

 all positive: false
 any positive: true
none positive: false

重载

#include <concepts>
#include <iostream>
using namespace std;

void fun(auto t) { cout << "fun(auto) : " << t << '\n'; }

void fun(long t) { cout << "fun(long) : " << t << '\n'; }

void fun(integral auto t) { cout << "fun(integral auto) : " << t << '\n'; }

int main() {
  fun(2020.);
  fun(2020L);
  fun(2020);
}

执行输出:

fun(auto) : 2020
fun(long) : 2020
fun(integral auto) : 2020

模板特化(Template Specialization)

#include <concepts>
#include <iostream>
using namespace std;
template <typename T>
struct Container {
  Container() { cout << "Use Container<T>" << '\n'; }
};

template <regular T>
struct Container<T> {
  Container() { cout << "Use Container<std::regular>" << '\n'; }
};

int main() {
  Container<int> a;
  Container<int&> b;
}

执行输出:

Use Container<std::regular>
Use Container<T>

使用多个 Concepts

#include <concepts>
#include <iostream>
#include <iterator>
#include <list>
#include <vector>
using namespace std;
template <typename Iter, typename Val>
  requires input_iterator<Iter> &&  // use multi concepts
           same_as<typename iterator_traits<Iter>::value_type, Val>
bool contains(Iter b, Iter e, Val v) {
  while (b != e && *b != v) ++b;
  return b != e;
}

int main() {
  vector vec{1, 2, 3, 4, 5};
  cout << boolalpha;
  cout << contains(vec.begin(), vec.end(), 5) << endl;  // true

  list list{1.1, 2.2, 3.3, 4.4, 5.5};
  cout << contains(list.begin(), list.end(), 5.5) << endl;  // true
  return 0;
}

受限的和不受限的auto

C++14 增加了泛型 lambda(generic lambda), 但是不支持在函数模板中使用 auto.
所谓泛型 lambda 是指使用auto而不是具体的类型来定义 lambda 函数.

不受限的 auto

单纯的 auto 被称为不受限的占位符,
下面的例子展示了不受限的占位符与相对应的模板函数.

#include <cassert>
template <typename L, typename R>
auto max_tmpl(L l, R r) {
  return l >= r ? l : r;
}

auto max_auto(auto l, auto r) { return l >= r ? l : r; }

int main() {
  assert(max_auto(1, 2) == max_tmpl(1, 2));
  assert(max_auto(-1, 0) == max_tmpl(-1, 0));
}

受限的 auto

受限的占位符是指使用 concepts来约束auto的类型.
下面的例子展示了受限的占位符与相对应的模板函数.

#include <cassert>
#include <concepts>
using namespace std;
template <integral L, integral R>
integral auto max_tmpl(L l, R r) {
  return l >= r ? l : r;
}

integral auto max_auto(integral auto l, integral auto r) {
  return l >= r ? l : r;
}

int main() {
  assert(max_auto(1, 2) == max_tmpl(1, 2));
  assert(max_auto(-1, 0) == max_tmpl(-1, 0));
}

Concepts 库简介

一些常用的 Concept 定义在<concepts>头文件中.

语言相关的 concepts

  • std::same_as<T, U>: 当且仅当T和U是相同的类型时, 该 concept 才为真.
  • std::derived_from<T, U>: 当且仅当T是U的派生类时, 该 concept 才为真.
  • std::convertible_to<T, U>: 当且仅当T可以隐式转换为U时, 该 concept 才为真.
  • std::common_reference_with<T, U>: 当且仅当T和U有一个公共的引用类型时, 该 concept 才为真.
  • std::common_with<T, U>: 当且仅当T和U有一个公共的类型时, 该 concept 才为真.
  • std::assignable_from<T, U>: 当且仅当T可以从U赋值时, 该 concept 才为真.
  • std::swappable<T>: 当且仅当T可以交换时, 该 concept 才为真.
#include <concepts>
#include <iostream>

class Base {};
class Derived : public Base {};

template <typename L, typename R>
void same_as(L lhs, R rhs) {
  if constexpr (std::same_as<L, R>) {
    std::cout << "same type\n";
  } else {
    std::cout << "not same type\n";
  }
}

template <typename D, typename B>
void derived_from(D d, B b) {
  if constexpr (std::derived_from<D, B>) {
    std::cout << "Derived from Base" << std::endl;
  } else {
    std::cout << "Not derived from Base" << std::endl;
  }
}

template <typename L, typename R>
void convertible_to(L l, R r) {
  if constexpr (std::convertible_to<L, R>) {
    std::cout << "Convertible" << std::endl;
  } else {
    std::cout << "Not convertible" << std::endl;
  }
}

template <typename L, typename R>
void common_reference_with(L& l, R& r) {
  if constexpr (std::common_reference_with<L, R>) {
    std::cout << "Common reference" << std::endl;
  } else {
    std::cout << "No common reference" << std::endl;
  }
}

template <typename L, typename R>
void common_with(L& l, R& r) {
  if constexpr (std::common_with<L, R>) {
    std::cout << "Common" << std::endl;
  } else {
    std::cout << "Not common" << std::endl;
  }
}

template <typename T, typename U>
void assignable_from(T& t, U& u) {
  if constexpr (std::assignable_from<T&, U>) {
    std::cout << "Assignable" << std::endl;
  } else {
    std::cout << "Not assignable" << std::endl;
  }
}

template <typename T>
void swappable(T& t1, T& t2) {
  if constexpr (std::swappable<T>) {
    std::cout << "Swappable: " << t1 << " " << t2 << std::endl;
  } else {
    std::cout << "Not swappable" << std::endl;
  }
}

int main() {
  same_as(1, 3.14);  // not same type
  same_as(0, 1);     // same type

  Derived derived;
  Base base;
  derived_from(derived, base);  // Derived from Base
  derived_from(1, base);        // Not derived from Base

  convertible_to(1, 3.14);  // Convertible
  convertible_to(1, "1");   // Not convertible

  int i = 1, j = 2;
  double d = 3.14;
  common_reference_with(i, d);           // Common reference
  common_reference_with(derived, base);  // Common reference
  common_reference_with(i, base);        // No common reference

  common_with(i, d);           // Common
  common_with(derived, base);  // Common
  common_with(i, base);        // No common

  assignable_from(i, j);           // Assignable
  assignable_from(derived, base);  // Not assignable
  assignable_from(base, derived);  // Assignable

  const int ci = 0;
  assignable_from(ci, d);  // Outputs: Not assignable

  int l = 0, r = 1;
  const int cl = 0, cr = 1;
  swappable(l, r);    // Swappable: 0, 1
  swappable(cl, cr);  // Not swappable
  return 0;
}

数学 concepts

  • std::integral: 整数类型. 包含 bool, char, char8_t, char16_t, char32_t, wchar_t, short, int, long, long long,
    以及对应的有符号和无符号类型,以及带 const 修饰符的类型.
  • std::signed_integral: 有符号整数类型, 满足std::integral且是带符号的
  • std::unsigned_integral: 无符号整数类型
  • std::floating_point: 浮点数类型
#include <concepts>
#include <iostream>
using namespace std;
void print(std::signed_integral auto value) {
  std::cout << "Signed Integral: " << value << '\n';
}

void print(std::unsigned_integral auto value) {
  std::cout << "Unsigned Integral: " << value << '\n';
}

void print(std::floating_point auto value) {
  std::cout << "Floating Point: " << value << '\n';
}

int main() {
  print(10);
  print(-5);
  print(20u);
  print(3.14);
}

运行输出:

Signed Integral: 10
Signed Integral: -5
Unsigned Integral: 20
Floating Point: 3.14

生命周期 concepts

  • std::default_initializable: 默认初始化的
  • std::copy_constructible: 可拷贝构造的
  • std::move_constructible: 可移动构造的
  • std::constructible_from: 可构造的
  • std::destructible: 可销毁的
#include <concepts>
#include <iostream>

class Plain {};
class SingleInstance {
 public:
  SingleInstance() = default;
  SingleInstance(const SingleInstance&) = delete;
  SingleInstance(SingleInstance&&) = delete;
};

template <typename T>
class Container {
 public:
  void resize(size_t new_size)
    requires std::default_initializable<T> &&  //
             std::destructible<T>              //
  {}

  void push_back(const T&)
    requires std::copy_constructible<T>  //
  {}

  void push_back(T&&)
    requires std::move_constructible<T>  //
  {}

  template <typename... Args>
  void emplace_back(Args&&... args)
    requires std::constructible_from<T, Args...>  //
  {}
};

int main() {
  Container<Plain> a;
  a.resize(10);
  a.push_back(Plain());
  a.emplace_back();

  Container<SingleInstance> b;
  b.resize(10);  // OK
  b.push_back(SingleInstance());  // ERROR, not copy constructible
  b.emplace_back();
}

运行输出:

比较类的 concepts

  • std::equality_comparable: 相等性比较.是指结构体提供了等于==和!=. 为了保证代码的逻辑正确, 通常只提供==或者!=. 另外一个完全可以由编译器推导出来.

  • std::totally_ordered: 完全有序. 是指提供了比较运算符<, <=, >, >=.
    同样,为了保证逻辑上的一致性,
    四个比较操作符中只需要实现一个(通常是<),
    其他的关系完全可以推导出来.

只能用相等性而无法用有序性的场景, 如: C++中与nullptr的比较, 数学上的与无穷大的比较等.

常见的关联容器可以分为两类: 基于比较的和基于哈希的.

  • 基于比较的比如std::set, std::map, std::multiset, std::multimap等. 通常其底层实现是红黑树(二分查找树的一种).
  • 基于哈希的比如std::unordered_set, std::unordered_map, std::unordered_multiset, std::unordered_multimap等.
    通常其底层实现是哈希表. 哈希表的原理中需要计算键(Key)的哈希值,
    所以键类型需要提供哈希函数. 在发生键冲突的时候, 为了保证键的唯一性,
    还需要提供相等性比较函数来区别不同的键.
#include <concepts>
#include <cstdint>
#include <cstring>
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
using namespace std;

struct Equality {
  string data;
  bool operator==(const Equality& rhs) const {  //
    return data == rhs.data;
  }
  bool operator!=(const Equality& rhs) const { return !(*this == rhs); }

  bool operator<(const Equality&) const = delete;
  bool operator<=(const Equality&) const = delete;
  bool operator>(const Equality&) const = delete;
  bool operator>=(const Equality&) const = delete;
};

struct Ordered {
  int a = 0;
  bool operator<(const Ordered& rhs) const {  //
    return a < rhs.a;
  }
  bool operator>(const Ordered& rhs) const { return rhs < *this; }
  bool operator==(const Ordered& rhs) const {
    return !(*this < rhs) && !(rhs < *this);
  }
  bool operator<=(const Ordered& rhs) const { return !(rhs < *this); }
  bool operator>=(const Ordered& rhs) const { return !(*this < rhs); }
};

int main() {
  auto hash_fun = [](Equality const& key) {
    return std::hash<std::string>()(key.data);
  };
  std::map<Ordered, int> map;
  std::unordered_map<Equality, int, decltype(hash_fun)> hashmap;

  std::set<Ordered> set;
  std::unordered_set<Equality, decltype(hash_fun)> hashset;

  map<Equality, int> em;            // Error
  unordered_map<Ordered, int> eum;  // Error
}

对象相关的 concepts

  • std::regular: 正则的, 是指一个对象可以被复制(copyable),默认构造(default constructible), 以及比较相等性(equality comparable).
  • std::semiregular: 半正则的, 比正则少了比较相等性的要求.
  • std::movable: 可移动的
  • std::copyable: 可拷贝的
#include <concepts>
#include <iostream>

// copyable, default constructible, and equality comparable.
struct Regular {
  int a = 0;
  bool operator==(const Regular& rhs) const { return a == rhs.a; };
};

// copyable, default constructible, but not equality comparable.
struct SemiRegular {
  int a = 0;
  bool operator==(const SemiRegular&) const = delete;
};

template <std::semiregular T>
void isSemiregular() {
  std::cout << typeid(T).name() << " is semi-regular\n";
}

template <std::regular T>
void isRegular() {
  std::cout << typeid(T).name() << " is regular\n";
}

int main() {
  isSemiregular<SemiRegular>();
  isRegular<Regular>();
  isSemiregular<Regular>();
}

运行输出:

struct SemiRegular is semi-regular
struct Regular is regular
struct Regular is semi-regular

可调用的 concepts

  • std::invocable: 可调用的
  • std::regular_invocable: 可调用且不改变入参, 另外一点就是对相同的输入参数会得到相同的输出.
  • std::predicate: 谓词, 返回值为 bool 类型
#include <concepts>
#include <iostream>

void print(int i) { std::cout << "Value: " << i << std::endl; }

bool is_even(int i) { return i % 2 == 0; }

template <std::invocable<int> Func>
void invocable_example(Func func) {
  func(10);
}

template <std::regular_invocable<int> Func>
void regular_invocable_example(Func func) {
  func(20);
}

template <std::predicate<int> Pred>
void predicate_example(Pred pred) {
  if (pred(30)) {
    std::cout << "Predicate returned true." << std::endl;
  } else {
    std::cout << "Predicate returned false." << std::endl;
  }
}

int main() {
  invocable_example(print);
  regular_invocable_example(print);
  predicate_example(is_even);
}

运行输出:

Value: 10
Value: 20
Predicate returned true.

工具类的库

  • std::input_iterator: 输入迭代器
  • std::output_iterator: 输出迭代器
  • std::forward_iterator: 前向迭代器
  • std::bidirectional_iterator: 双向迭代器
  • std::random_access_iterator: 随机访问迭代器
  • std::contiguous_iterator: 连续迭代器

算法相关的 concepts

  • std::permutable: 可在原地排序, 不需要额外的内存.
  • std::mergeable: 可以合并两个有序序列到输出序列.
  • std::sortable: 可形成有序序列.

自定义requires表达式

C++20 支持自定义 Concepts, 目前有四种方法.

简单要求

requires表达式的语法为:

requires (parameter-list(optional)) {requirement-seq}

其中parameter-list是可选的, 用于指定requires表达式的参数. requirement-seq是一个或多个requirement的序列. 后文会详细介绍.

#include <string>
#include <vector>
template <typename T>
concept Arith = requires(T a, T b) {  // simple requirement
  a + b;
  a - b;
  a* b;
  a / b;
};

int main() {
  static_assert(Arith<int>);               // OK
  static_assert(Arith<double>);            // OK

  static_assert(Arith<std::string>);       // Error
  static_assert(Arith<std::vector<int>>);  // Error
}

Concept Addable要求类型T支持+操作符.

类型要求

在类型要求中, 必须使用关键字typename和类型名.

#include <list>
#include <vector>

template <typename T>
struct Container {
  using value_type = T;
};

template <typename T>
concept HasValueType = requires {
  typename T::value_type;  // type requirement
};

int main() {
  static_assert(HasValueType<std::vector<int>>);   // OK
  static_assert(HasValueType<std::list<double>>);  // OK
  static_assert(HasValueType<Container<int>>);     // OK

  static_assert(HasValueType<int>);  // Error
}

复合要求

复合要求的形式如下:

{expression} noexcept(optional) return-type-requirement(optional);

#include <concepts>
#include <iterator>
#include <list>
#include <vector>

template <typename T>
concept CompReq = requires(T t) {  // compound requirement
  { t.begin() } -> std::input_iterator;
  { t.end() } -> std::input_iterator;
};

int main() {
  static_assert(CompReq<std::vector<int>>);   // OK
  static_assert(CompReq<std::list<double>>);  // OK

  static_assert(CompReq<int>);                // Error
}

嵌套要求

#include <concepts>
#include <list>
#include <vector>

template <typename T>
concept Container = requires(T t) {
  { t.begin() } -> std::input_iterator;
  { t.end() } -> std::input_iterator;
};

template <typename T>
concept Arithmetic = std::is_arithmetic_v<T>;

template <typename T>
concept NestedReq = requires(T) {  // nested requirement
  Container<T>;
  requires Arithmetic<typename T::value_type>;
};

int main() {
  static_assert(NestedReq<std::vector<int>>);  // OK
  static_assert(NestedReq<std::list<double>>);  // OK

  static_assert(NestedReq<int>);  // Error
}

总结

  • Concepts 通过对类型参数施加约束来提高模板的可读性和可维护性.
  • Concepts 可以应用于 requires 语句,尾部 requires 语句,受约束的模板参数和函数模板缩写.
  • Concepts 是可以用作编译时谓词.可以基于 Concepts 进行重载,在 Concepts 上特化模板,在成员函数或可变参数模板上使用 Concepts.
  • 由于 C++20 和 Concepts,使用未约束的占位符(auto)和约束的占位符(Concepts)是统一的.
  • 由于新的缩写函数模板语法,定义函数模板变得非常简单.
  • 不要重复发明轮子.在定义自己的 Concepts 之前,请研究 C++20 标准中丰富的预定义 Concepts.
c++20标准_c++20标准_
10-02
C++20是C++编程语言的一个重大更新，它引入了一系列新特性，旨在提升效率、可读性以及并发处理能力。以下是对C++20标准的一些关键知识点的详细阐述： 1. **模块（Modules）**：C++20引入了模块机制，允许程序员将...
C++98-C++20 C++ 语言标准参考手册 2021-01-22 最新版本
01-22
此外，C++20引入了 Concepts，这是一种更精确的模板约束方式，可以增强模板的类型安全性。还有协程（Coroutines），它们为异步编程提供了一种新的控制流机制。其他重要特性包括改进的范围for循环，添加了std::ranges...
C++20 Concepts
一朵花开的时间
12-27 4275
vs2019 C++20 Concepts01 concepts及concepts库函数02 Concepts demo 01 concepts及concepts库函数 什么是C ++概念？ 概念(concepts)提供基础语言概念的定义，它们能用于进行模板实参的编译时校验，以及基于类型属性的函数派发。这些概念在程序中提供等式推理的基础。1 通过使用concepts，传统的模板元编程方面关于编译错...
C++20------Concept
qq_38409301的博客
06-21 592
C++20: Concept详解
【C++20 新特性Concepts 概念】C++20 Concepts: Unleashing the Power of Template Programming
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
08-02 313
C++20 Concepts（概念）是C++20标准中引入的一项重要特性，它的目的是为了改进模板编程。在C++20之前，模板编程虽然强大，但也存在一些问题。例如，当模板参数不满足模板的预期时，编译器产生的错误信息通常难以理解。此外，模板的使用者往往需要查看模板的实现才能知道模板参数应满足的条件，这使得模板的使用变得困难。
C++20四大之三：concept特性详解
扶风的博客
04-05 5177
前言：C++模板的演进 模板的演进是C++发展史中一条十分重要的线，个人觉得Concept是这条线中最大的一个特性了。在介绍Concept之前，我们先捋一捋模板这条线的发展。 据Stroustrup先生回忆， 对模板的设想早在1982年便有了，正式提出是在1998年的 USENIX C++ conference会议上提出，设计模板的初衷是因为当时的C++缺少一个标准库，而当时没有模板的C++很难设计出“vector、list”这种适用于多种类型的容器。 到1998年模板正式进入标准，在这之前C++模板已经
C++20之Concept（概念部分，之一）
fl2011sx的博客
09-27 3271
本篇介绍了C++20中的一个重要概念——concept
C++20 Concepts详解：提升模板编译效率与约束
C++20 Concepts是C++20引入的一项关键特性，旨在解决在处理模板编程时编译器错误报告复杂性的问题。此前，由于模板实例化过程的分步骤，编译器往往在代码执行阶段才检查类型兼容性，导致错误信息不直观。Concepts...
《STL源码分析》学习笔记 — C++20 concepts
coding-hwz
09-01 246
《STL源码分析》学习笔记 — 迭代器概念一、迭代器是一种智能指针二、迭代器相应型别三、concepts 一、迭代器是一种智能指针 在学习数据结构时，我们实现过一个版本的迭代器 — 链表迭代器实现。从这个实现中，我们不难看出两件事： 1、迭代器本身是一个智能指针，是 RAII 思想的一种体现； 2、迭代器的设计需求源于算法的实现，算法需要一种遍历容器的统一的方式；但是迭代器的实现需要开发者对于容器有充分的了解。从这个角度来说，提供迭代器应该是容器设计者的工作。 二、迭代器相应型别 当我们需要在算法中使用迭代
C++20 实践入门，第六版，英文
12-14
* Concepts：C++20 中引入的概念（Concepts）机制，用于约束模板参数的类型，提高代码的可读性和安全性。 * Ranges：C++20 中引入的 Ranges 库，提供了一个更简洁和高效的方式来处理序列数据。 * Coroutines：C++20 ...
掌握C++20的革命性特性：Concepts
qq_42896106的博客
01-19 1726
标准库定义了一系列预定义的 Concepts，分为多个类别。以下列表给出了每个类别中的一些示例 Concepts，所有这些都在头文件和std核心语言 Conceptssame_asintegral等。比较 Concepts等。对象 Conceptsmovablecopyable等。可调用 Conceptsinvocablepredicate等。此外，头文件定义了与迭代器相关的 Concepts，如等，还定义了算法要求，如mergeablesortable。
C++20之 concept 概念
wyg_031113的专栏
12-13 713
c++ concept 概念
C++(20)：concept概念
风静如云的博客
06-22 620
编译错误：error: request for member 'p' in 't', which is of non-class type 'int'C++20引入了concept，其一个主要的作用是用于模板对其参数所需满足的条件进行约束和说明。当模板实参的类型有成员函数p的时候，可以很好的工作。test的参数1是个整数，没有成员函数p。可以看到这样的约束更加的直观。
C++20的新特性：concept
normallife的专栏
02-19 1002
今天我们接着聊聊C++20的新特性：concept. Concepts的定义 下面是concept的定义的形式。 template < template-parameter-list > concept concept-name = constraint-expression; 其中，constraint-expression是一个可以被eval为bool的表达式或者编译期函数。 在使用定义好的concept时，constraint-expression会根据上面template-para..
C++ 20新特性之Concepts
hope_wisdom的技术博客
06-03 1852
在C++ 20之前，我们在编写泛型代码时，模板参数的约束往往通过复杂的SFINAE（Substitution Failure Is Not An Error）策略或繁琐的Traits类来实现。这不仅难以阅读，也非常容易出错，导致很多程序员在提及泛型编程时，总是心有余悸、脊背发凉。
C++20中头文件concepts的使用
最新发布
网络资源是无限的
09-28 1000
C++20中头文件concepts的使用
C++20： 概念 concept
Royi的学习博客
08-24 711
Concepts（概念）是 C++20 引入的一项重要特性，用于对模板参数进行约束和检查。通过使用 Concepts，开发者可以在编译期对模板参数的类型和行为进行验证，从而提高代码的可读性、可维护性和错误信息的清晰度。Concepts 为 C++ 模板编程带来了强大的类型约束机制，使得模板代码更加健壮、可读和易于维护。通过在编译期进行类型检查，Concepts 帮助开发者更早地发现错误，并提供更直观的错误信息。C++20 提供了一些预定义的 Concepts，如。编译器会给出清晰的错误信息，指出。
C++20：从0到1学懂concept
Francis的博客
01-08 1423
目录1.concept语法1.1 替换typename1.2 requires关键字1.4 concept与auto2.编译器支持3.总结C++20引入了concept(概念)，是对模板参数(编译时评估)的一组约束。你可以将它们用于类模板和函数模板来控制函数重载和特化。一些优点包括：对模版参数强制类型约束提高代码可读性(替换了较长的SFINAE代码)提供更友好的报错信息通过限制可以使用的类型来防止...
c++20 的部分新概念及示例代码-concepts，＜=＞，init-capture extension，coroutines
谁谁谁的的的博客
03-27 515
c++20 概念，三路比较符，初始化捕获，协程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

arong-xu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值