C++标准模板（STL）- 概念库 (C++20) - 指定能复制构造和移动构造一个类型的对象 - （std::copy_constructible）

于 2024-07-27 08:30:00 发布
阅读量330 收藏 3
点赞数 12
分类专栏： 概念库 文章标签： c++20 开发语言 STL 指定能复制构造 copy_ constructible
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788199/article/details/140589423
版权

概念库提供基础语言概念的定义，它们能用于进行模板实参的编译时校验，以及基于类型属性的函数派发。这些概念在程序中提供等式推理的基础。

标准库中的大多数概念一同加上了语法及语义要求。通常，编译器只能检查语法要求。若在使用点语义要求未得到满足，则程序为病式，不要求诊断。

类型支持（基本类型、RTTI、类型特性）

指定能复制构造和移动构造一个类型的对象

std::copy_constructible

定义于头文件 <concepts>

template <class T>

concept copy_constructible =
  std::move_constructible<T> &&
  std::constructible_from<T, T&> && std::convertible_to<T&, T> &&
  std::constructible_from<T, const T&> && std::convertible_to<const T&, T> &&

  std::constructible_from<T, const T> && std::convertible_to<const T, T>;		(C++20 起)

概念 copy_constructible 若符合这些条件则得到满足： T 为左值引用类型，或若它是 move_constructible 对象类型，而能从（可为 const 的）该类型左值或 const 右值，在直接和复制初始化语境中以通常语义构造该类型对象（构造副本而不更改源）。

更精确而言，若 T 为对象类型，则 copy_constructible<T> 仅若符合下列条件才得到满足。给定

  • v ， T 类型左值（可为 const ）或为 const T 类型右值，

下列为真：

  • 定义 T u = v; 后， u 等于 v ；
  • T(v) 等于 v 。

参阅

is_copy_constructible

is_trivially_copy_constructible

is_nothrow_copy_constructible

(C++11)

检查类型是否拥有复制构造函数
(类模板)

调用示例

#include <iostream>
#include <type_traits>

class E
{
public:
    template<class T> E(T&&) { }
};

class A {};
class B : public A {};
class C {};
class D
{
public:
    operator C()
    {
        return c;
    }  C c;
};

//自定义的实现
namespace std
{

template< class T, class... Args >
const bool is_constructible_v = is_constructible<T, Args...>::value;

template< class T, class... Args >
const bool is_trivially_constructible_v = is_trivially_constructible<T, Args...>::value;

template< class T, class... Args >
const bool is_nothrow_constructible_v = is_nothrow_constructible<T, Args...>::value;

template< class T >
const bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value;

template < class T >
const bool destructible = is_nothrow_destructible<T>::value;

template <class From, class To>
constexpr bool convertible_to = (std::is_convertible<From, To>::value);

template < class T, class... Args >
const bool constructible_from = (destructible<T> && is_constructible_v<T, Args...>);

template< class T >
const bool move_constructible = (constructible_from<T, T> && convertible_to<T, T>);

template <class T>
const bool copy_constructible =
    move_constructible<T> &&
    constructible_from<T, T&> && convertible_to<T&, T> &&
    constructible_from<T, const T&> && convertible_to<const T&, T> &&
    constructible_from<T, const T> && convertible_to<const T, T>;
}
int main()
{
    std::cout << std::boolalpha;

    std::cout << "std::is_convertible<B*, A*>::value:           "
              << std::is_convertible<B*, A*>::value << std::endl;
    std::cout << "std::is_convertible<A*, B*>::value:           "
              << std::is_convertible<A*, B*>::value << std::endl;
    std::cout << "std::is_convertible<B*, C*>::value:           "
              << std::is_convertible<B*, C*>::value << std::endl;
    std::cout << "std::is_convertible<D, C>::value:             "
              << std::is_convertible<D, C>::value << std::endl;
    std::cout << "std::is_convertible<E, A>::value:             "
              << std::is_convertible<E, A>::value << std::endl;
    std::cout << "std::is_convertible<int, double>::value:      "
              << std::is_convertible<int, double>::value << std::endl;
    std::cout << "std::is_convertible<int, char>::value:        "
              << std::is_convertible<int, char>::value << std::endl;
    std::cout << "std::is_convertible<std::string, char>::value:"
              << std::is_convertible<std::string, char>::value << std::endl;

    std::cout << "-----------------------------------------------" << std::endl;
    std::cout << std::endl;

    std::cout << "std::destructible<A>:                         "
              << std::destructible<A> << std::endl;
    std::cout << "std::destructible<B>:                         "
              << std::destructible<B> << std::endl;
    std::cout << "std::destructible<C>:                         "
              << std::destructible<C> << std::endl;
    std::cout << "std::destructible<D>:                         "
              << std::destructible<D> << std::endl;
    std::cout << "std::destructible<E>:                         "
              << std::destructible<E> << std::endl;
    std::cout << "std::destructible<float>:                     "
              << std::destructible<float> << std::endl;
    std::cout << "std::destructible<int>:                       "
              << std::destructible<int> << std::endl;
    std::cout << "std::destructible<bool>:                      "
              << std::destructible<bool> << std::endl;
    std::cout << std::endl;

    std::cout << "-----------------------------------------------" << std::endl;
    std::cout << std::endl;

    std::cout << "std::constructible_from<B, A>:                "
              << std::constructible_from<B, A> << std::endl;
    std::cout << "std::constructible_from<A, B>:                "
              << std::constructible_from<A, B> << std::endl;
    std::cout << "std::constructible_from<B*, A*>:              "
              << std::constructible_from<B*, A*> << std::endl;
    std::cout << "std::constructible_from<A*, B*>:              "
              << std::constructible_from<A*, B*> << std::endl;
    std::cout << "std::constructible_from<B*, C*>:              "
              << std::constructible_from<B*, C*> << std::endl;
    std::cout << "std::constructible_from<D, C>:                "
              << std::constructible_from<D, C> << std::endl;
    std::cout << "std::constructible_from<E, A>:                "
              << std::constructible_from<E, A> << std::endl;
    std::cout << "std::constructible_from<int, double>:         "
              << std::constructible_from<int, double> << std::endl;
    std::cout << "std::constructible_from<int, char>:           "
              << std::constructible_from<int, char> << std::endl;
    std::cout << "std::constructible_from<std::string, char>:   "
              << std::constructible_from<std::string, char> << std::endl;

    std::cout << "-----------------------------------------------" << std::endl;
    std::cout << std::endl;

    std::cout << "std::convertible_to<B, A>:                    "
              << std::convertible_to<B, A> << std::endl;
    std::cout << "std::convertible_to<A, B>:                    "
              << std::convertible_to<A, B> << std::endl;
    std::cout << "std::convertible_to<B*, A*>:                  "
              << std::convertible_to<B*, A*> << std::endl;
    std::cout << "std::convertible_to<A*, B*>:                  "
              << std::convertible_to<A*, B*> << std::endl;
    std::cout << "std::convertible_to<B*, C*>:                  "
              << std::convertible_to<B*, C*> << std::endl;
    std::cout << "std::convertible_to<D, C>:                    "
              << std::convertible_to<D, C> << std::endl;
    std::cout << "std::convertible_to<E, A>:                    "
              << std::convertible_to<E, A> << std::endl;
    std::cout << "std::convertible_to<int, double>:             "
              << std::convertible_to<int, double> << std::endl;
    std::cout << "std::convertible_to<int, char>:               "
              << std::convertible_to<int, char> << std::endl;
    std::cout << "std::convertible_to<std::string, char>:       "
              << std::convertible_to<std::string, char> << std::endl;

    std::cout << "-----------------------------------------------" << std::endl;
    std::cout << std::endl;

    std::cout << "std::move_constructible<B>:                   "
              << std::move_constructible<B> << std::endl;
    std::cout << "std::move_constructible<A>:                   "
              << std::move_constructible<A> << std::endl;
    std::cout << "std::move_constructible<B*>:                  "
              << std::move_constructible<B*> << std::endl;
    std::cout << "std::move_constructible<A*>:                  "
              << std::move_constructible<A*> << std::endl;
    std::cout << "std::move_constructible<C*>:                  "
              << std::move_constructible<C*> << std::endl;
    std::cout << "std::move_constructible<D>:                   "
              << std::move_constructible<D> << std::endl;
    std::cout << "std::move_constructible<E>:                   "
              << std::move_constructible<E> << std::endl;
    std::cout << "std::move_constructible<int>:                 "
              << std::move_constructible<int> << std::endl;
    std::cout << "std::move_constructible<char>:                "
              << std::move_constructible<char> << std::endl;
    std::cout << "std::move_constructible<std::string>:         "
              << std::move_constructible<std::string> << std::endl;

    std::cout << "-----------------------------------------------" << std::endl;
    std::cout << std::endl;

    std::cout << "std::copy_constructible<B>:                   "
              << std::copy_constructible<B> << std::endl;
    std::cout << "std::copy_constructible<A>:                   "
              << std::copy_constructible<A> << std::endl;
    std::cout << "std::copy_constructible<B*>:                  "
              << std::copy_constructible<B*> << std::endl;
    std::cout << "std::copy_constructible<A*>:                  "
              << std::copy_constructible<A*> << std::endl;
    std::cout << "std::copy_constructible<C*>:                  "
              << std::copy_constructible<C*> << std::endl;
    std::cout << "std::copy_constructible<D>:                   "
              << std::copy_constructible<D> << std::endl;
    std::cout << "std::copy_constructible<E>:                   "
              << std::copy_constructible<E> << std::endl;
    std::cout << "std::copy_constructible<int>:                 "
              << std::copy_constructible<int> << std::endl;
    std::cout << "std::copy_constructible<char>:                "
              << std::copy_constructible<char> << std::endl;
    std::cout << "std::copy_constructible<std::string>:         "
              << std::copy_constructible<std::string> << std::endl;

    return 0;
}

输出

std::is_convertible<B*, A*>::value:           true
std::is_convertible<A*, B*>::value:           false
std::is_convertible<B*, C*>::value:           false
std::is_convertible<D, C>::value:             true
std::is_convertible<E, A>::value:             false
std::is_convertible<int, double>::value:      true
std::is_convertible<int, char>::value:        true
std::is_convertible<std::string, char>::value:false
-----------------------------------------------

std::destructible<A>:                         true
std::destructible<B>:                         true
std::destructible<C>:                         true
std::destructible<D>:                         true
std::destructible<E>:                         true
std::destructible<float>:                     true
std::destructible<int>:                       true
std::destructible<bool>:                      true

-----------------------------------------------

std::constructible_from<B, A>:                false
std::constructible_from<A, B>:                true
std::constructible_from<B*, A*>:              false
std::constructible_from<A*, B*>:              true
std::constructible_from<B*, C*>:              false
std::constructible_from<D, C>:                false
std::constructible_from<E, A>:                true
std::constructible_from<int, double>:         true
std::constructible_from<int, char>:           true
std::constructible_from<std::string, char>:   false
-----------------------------------------------

std::convertible_to<B, A>:                    true
std::convertible_to<A, B>:                    false
std::convertible_to<B*, A*>:                  true
std::convertible_to<A*, B*>:                  false
std::convertible_to<B*, C*>:                  false
std::convertible_to<D, C>:                    true
std::convertible_to<E, A>:                    false
std::convertible_to<int, double>:             true
std::convertible_to<int, char>:               true
std::convertible_to<std::string, char>:       false
-----------------------------------------------

std::move_constructible<B>:                   true
std::move_constructible<A>:                   true
std::move_constructible<B*>:                  true
std::move_constructible<A*>:                  true
std::move_constructible<C*>:                  true
std::move_constructible<D>:                   true
std::move_constructible<E>:                   true
std::move_constructible<int>:                 true
std::move_constructible<char>:                true
std::move_constructible<std::string>:         true
-----------------------------------------------

std::copy_constructible<B>:                   true
std::copy_constructible<A>:                   true
std::copy_constructible<B*>:                  true
std::copy_constructible<A*>:                  true
std::copy_constructible<C*>:                  true
std::copy_constructible<D>:                   true
std::copy_constructible<E>:                   true
std::copy_constructible<int>:                 true
std::copy_constructible<char>:                true
std::copy_constructible<std::string>:         true

繁星璀璨G
关注
  • 12
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++模板与STL库介绍
03-18
C++模板和STL库是C++编程语言中的两个核心特性，它们极大地提高了代码的复用性和效率。本文将深入探讨这两个主题，并提供丰富的实践应用示例。 首先，我们来理解C++模板。模板是C++的一个强大工具，它允许程序员...
C++-STL标准模板库中的string
04-05
C++ STL 中的 `std::string` 是一个非常重要的数据类型，它提供了高效、灵活的字符串操作功能。在C++编程中，`std::string`通常用来替代传统的C风格字符串（`char*`），因为前者提供了更丰富的接口和更安全的内存...
C++函数对象-函数包装器-（std::function）(一）- 构造新的 std::function 实例 - 析构 std::function 实例
qq_40788199的博客
01-15 1320
从各种资源构造 std::function 。 1-2) 构造空 function 。 3-4) 复制 (3) 或移动 (4) other 的目标到 *this 的目标。若 other 为空，则调用后 *this 将亦为空。对于 (4) ， other 在调用后处于合法但未指定的状态。 5) 以 std::move(f) 初始化目标。若 f 是空指针或指向成员的空指针，则 *this 在此调用后将为空。此构造函数不参与重载决议，除非 f 对于参数类型 Args... 和返回类型 R 可调用 (Call
C++11标准模板（STL）- 算法 - 数值运算 （std::accumulate）
qq_40788199的博客
12-25 3617
对一个范围内的元素求和。 计算给定值 init 与给定范围 [first, last) 中元素的和。第一版本用 operator+ ，第二版本用二元函数 op 求和元素，均将 std::move 应用到其左侧运算数 (C++20 起)。
c++标准模板（STL）- 算法 （std::remove, std::remove_if）
qq_40788199的博客
10-31 2996
从范围 [first, last) 移除所有满足特定判别标准的元素，并返回范围新结尾的尾后迭代器。 1) 移除所有等于 value 的元素。 3) 移除所有 p 对于它返回 true 的元素，用 operator== 比较它们。
C++11标准模板（STL）- 算法 - 排序操作（std::sort）
qq_40788199的博客
11-21 2527
以升序排序范围 [first, last) 中的元素。不保证维持相等元素的顺序。 1) 用 operator< 比较元素。 3) 用给定的二元比较函数 comp 比较元素。
c++ 11标准模板（STL） std::vector (一）
qq_40788199的博客
11-10 1750
vector 的存储是自动管理的，按需扩张收缩。 vector 通常占用多于静态数组的空间，因为要分配更多内存以管理将来的增长。 vector 所用的方式不在每次插入元素时，而只在额外内存耗尽时重分配。分配的内存总量可用 capacity() 函数查询。额外内存可通过对 shrink_to_fit() 的调用返回给系统。
C++11标准模板（STL）- 算法 - 最小/最大操作（std::max）
qq_40788199的博客
12-13 2272
返回给定值中的较大者。 1-2) 返回 a 与 b 的较大者。 3-4) 返回 initializer_list ilist 中值的最大者。 (1,3) 版本用 operator< 比较元素， (2,4) 版本用给定的比较函数 comp 。
c++ 11标准模板（STL） std::map(一）旧
qq_40788199的博客
12-19 3641
std::map 是有序键值对容器，它的元素的键是唯一的。用比较函数 Compare 排序键。搜索、移除和插入操作拥有对数复杂度。 map 通常实现为红黑树。 在每个标准库使用比较 (Compare) 概念的位置，以等价关系检验唯一性。不精确而言，若二个对象 a 与 b 互相比较不小于对方 ： !comp(a, b) && !comp(b, a) ，则认为它们等价（非唯一）。
C++11标准模板（STL）- 算法 - 最小/最大操作（std::max_element）
qq_40788199的博客
12-14 3117
寻找范围 [first, last) 中的最大元素。 1) 用 operator< 比较元素。 3) 用给定的二元比较函数 comp 比较元素。
C++ STL标准库：std::valarray 使用详解
超级大洋葱的博客
12-15 7851
文章目录1.简介2.代码示例3.成员函数3.1 构造函数 1.简介 valarray对象被设计用来保存一个值数组，并且可以轻松地对它们执行数学运算。它还允许特殊机制引用数组中元素的子集（请参见其运算符[]重载）。 大多数数学运算可以直接应用于valarray对象，包括算术和比较运算符，影响其所有元素。 valarray规范允许库通过几种效率优化来实现它，例如某些操作的并行化、内存回收或支持“引用时拷贝/写入时拷贝”优化。实现甚至可以取代valarray作为下面描述的标准函数的返回类型，前提是它们的行为方式是
C++ - STL标准库
热门推荐
weixin_49303682的博客
12-25 1万+
1.C++ STL标准库简介 长久以来，软件界一直希望建立一种可重复利用的东西，以及一种得以制造出”可重复运用的东西” 的方法，从函数(functions)，类别(classes),函数库(function libraries),类别库(class libraries)、各种 组件，从模块化设计，到面向对象(object oriented )，为的就是复用性的提升。 复用性必须建立在某种标准之上。但是在许多环境下，就连软件开发最基本的数据结构(data structures) 和算法(algori
《C++语言 - 标准模板库STL》_标准模板库_C++_C++STL_
09-29
在C++编程中，标准模板库（Standard Template Library，简称STL）是一个极其重要的组成部分，它为程序员提供了高效且易用的数据结构和算法。STL是C++标准库的一个核心部分，极大地提升了代码的可读性和复用性，使得...
C++_标准模板库(STL)_C++_C++STL_C++标准库_
10-01
C++标准模板库（STL）是C++编程语言中不可或缺的一部分，它是现代C++编程的基础，极大地提高了代码的效率和可复用性。STL包括了五个主要组件：容器、迭代器、算法、函数对象（也称为适配器）以及分配器。下面将详细...
C++ PPT第9章 标准模板库STL.ppt
05-30
C++标准模板库（Standard Template Library，简称STL）是C++语言中的一种通用库，主要思想是结合C++的模板机制，设计出一系列针对数据结构中具体问题的类模板和函数模板，并不针对具体的数据类型，形成了具有优秀、...
【OpenCV C++20 学习笔记】基本图像容器——Mat
TeamLee的博客
07-22 1080
详细介绍了OpenCV中Mat对象的原理、创建方式和输出方式
【OpenCV C++20 学习笔记】扫描图片数据
TeamLee的博客
07-23 1110
详细介绍了OpenCV中4种扫描图片数据的方法，并比较它们的性能优劣
【C++20】从0开始自制协程库
最新发布
喜欢打篮球的普通人
07-24 455
很多人对协程的理解就是在用户态线程把CPU对线程的调度复制了一遍，减少了线程的数量，也就是说在一个线程内完成对协程的调度，不需要线程切换导致上下文切换的开销。但是线程切换是CPU行为，就算你的程序只有一个线程，多个应用一样会切换上下文，所以并不能提升效率。所以协程必须引入线程池以及epoll的多路复用才能在大部分情况下提升每个线程的运行效率，防止线程空转。
主流开发语言和开发环境介绍
weixin_44215445的博客
07-23 1180
主流开发语言和开发环境介绍
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值