C++标准模板（STL）- 类型支持 （检查一个类型的对象是否能与同类型或不同类型的对，std::is_swappable_with, std::is_swappable）

最新推荐文章于 2024-08-05 20:49:33 发布
最新推荐文章于 2024-08-05 20:49:33 发布
阅读量267 收藏 14
点赞数 24
分类专栏： # 受支持操作 文章标签： c++ 开发语言 STL is_swappable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788199/article/details/140907747
版权

类型特性

类型特性定义一个编译时基于模板的结构，以查询或修改类型的属性。

试图特化定义于 <type_traits> 头文件的模板导致未定义行为，除了 std::common_type 可依照其所描述特化。

定义于<type_traits>头文件的模板可以用不完整类型实例化，除非另外有指定，尽管通常禁止以不完整类型实例化标准库模板。

受支持操作

检查一个类型的对象是否能与同类型或不同类型的对

std::is_swappable_with, 
std::is_swappable, 
std::is_nothrow_swappable_with, 
std::is_nothrow_swappable

template< class T, class U >
struct is_swappable_with;

(1)(C++17 起)

template< class T >
struct is_swappable;

(2)(C++17 起)

template< class T, class U >
struct is_nothrow_swappable_with;

(3)(C++17 起)

template< class T >
struct is_nothrow_swappable;

(4)(C++17 起)

1) 若表达式 swap(std::declval<T>(), std::declval<U>()) 及 swap(std::declval<U>(), std::declval<T>()) 在使用 using std::swap; （见 可交换 (Swappable) ）后的不求值语境中均为良式，则提供等于 true 的成员常量 value 。否则 value 为 false 。如同从与任一类型皆无关的语境进行访问检查。

2) 若 T 不是可解引用类型（即可为 cv 限定的 void 或拥有 cv-qualifier-seq 或 ref-qualifier 的函数类型），则提供等于 false 的成员常量 value 。否则，提供等于 std::is_swappable_with<T&, T&>::value 的成员常量 value 。

3) 同 (1) ，但已知来自 (1) 的两个表达式求值都不抛异常。

4) 同 (2) ，但使用 is_nothrow_swappable_with 。

T 与 U 应均为完整类型、（可为 cv 限定的） void ，或未知边界数组。否则行为未定义。

若上述模板的实例化直接或间接地依赖于不完整类型，并且如果假如使该类型完整，实例化就会产生不同的结果，则行为未定义。

辅助变量模板

template <class T, class U>
inline constexpr bool is_swappable_with_v = is_swappable_with<T, U>::value;

(C++17 起)

template <class T>
inline constexpr bool is_swappable_v = is_swappable<T>::value;

(C++17 起)

template <class T, class U>
inline constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<T, U>::value;

(C++17 起)

template <class T>
inline constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<T>::value;

(C++17 起)

继承自 std::integral_constant

成员常量

value

[静态]

若T可与U交换则为 true ，否则为 false
(公开静态成员常量)

成员函数

operator bool

转换对象为 bool ，返回 value
(公开成员函数)

operator()

(C++14)

返回 value
(公开成员函数)

成员类型

类型定义
value_typebool
typestd::integral_constant<bool, value>

注意

此特性不检查 swap 表达式的立即语境外的内容：若 T 或 U 的使用会触发模板特化，生成隐式定义的特定成员函数等，而它们有错误，则即使 std::is_swappable_with<T,U>::value 通过编译且求值为 true ，实际的 swap 也可能无法编译。

调用示例

#include <type_traits>
#include <utility>
#include <iostream>

namespace std
{
template <typename _Tp>
struct __is_swappable;

template <typename _Tp>
struct __is_nothrow_swappable;

template<typename... _Elements>
class tuple;

template<typename>
struct __is_tuple_like_impl : false_type
{ };

template<typename... _Tps>
struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
{ };

// Internal type trait that allows us to sfinae-protect tuple_cat.
template<typename _Tp>
struct __is_tuple_like
    : public __is_tuple_like_impl<typename remove_cv<
      typename remove_reference<_Tp>::type>::type>::type
{ };

template<typename _Tp>
inline
typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
         is_move_constructible<_Tp>,
         is_move_assignable<_Tp>>::value>::type
         swap(_Tp&, _Tp&)
         noexcept(__and_<is_nothrow_move_constructible<_Tp>,
                  is_nothrow_move_assignable<_Tp>>::value);

template<typename _Tp, size_t _Nm>
inline
typename enable_if<__is_swappable<_Tp>::value>::type
swap(_Tp(&__a)[_Nm], _Tp(&__b)[_Nm])
noexcept(__is_nothrow_swappable<_Tp>::value);

namespace __swappable_details
{
using std::swap;

struct __do_is_swappable_impl
{
    template<typename _Tp, typename
             = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
    static true_type __test(int);

    template<typename>
    static false_type __test(...);
};

struct __do_is_nothrow_swappable_impl
{
    template<typename _Tp>
    static __bool_constant <
    noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
    > __test(int);

    template<typename>
    static false_type __test(...);
};

} // namespace __swappable_details

template<typename _Tp>
struct __is_swappable_impl
    : public __swappable_details::__do_is_swappable_impl
{
    typedef decltype(__test<_Tp>(0)) type;
};

template<typename _Tp>
struct __is_nothrow_swappable_impl
    : public __swappable_details::__do_is_nothrow_swappable_impl
{
    typedef decltype(__test<_Tp>(0)) type;
};

template<typename _Tp>
struct __is_swappable
    : public __is_swappable_impl<_Tp>::type
{ };

template<typename _Tp>
struct __is_nothrow_swappable
    : public __is_nothrow_swappable_impl<_Tp>::type
{ };

/// is_swappable
template<typename _Tp>
struct is_swappable
    : public __is_swappable_impl<_Tp>::type
{ };

/// is_nothrow_swappable
template<typename _Tp>
struct is_nothrow_swappable
    : public __is_nothrow_swappable_impl<_Tp>::type
{ };

#if __cplusplus >= 201402L
/// is_swappable_v
template<typename _Tp>
_GLIBCXX17_INLINE constexpr bool is_swappable_v =
    is_swappable<_Tp>::value;

/// is_nothrow_swappable_v
template<typename _Tp>
_GLIBCXX17_INLINE constexpr bool is_nothrow_swappable_v =
    is_nothrow_swappable<_Tp>::value;
#endif // __cplusplus >= 201402L

namespace __swappable_with_details
{
using std::swap;

struct __do_is_swappable_with_impl
{
    template<typename _Tp, typename _Up, typename
             = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
             typename
             = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
    static true_type __test(int);

    template<typename, typename>
    static false_type __test(...);
};

struct __do_is_nothrow_swappable_with_impl
{
    template<typename _Tp, typename _Up>
    static __bool_constant <
    noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
    &&
    noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
    > __test(int);

    template<typename, typename>
    static false_type __test(...);
};

} // namespace __swappable_with_details

template<typename _Tp, typename _Up>
struct __is_swappable_with_impl
    : public __swappable_with_details::__do_is_swappable_with_impl
{
    typedef decltype(__test<_Tp, _Up>(0)) type;
};

// Optimization for the homogenous lvalue case, not required:
template<typename _Tp>
struct __is_swappable_with_impl<_Tp&, _Tp&>
    : public __swappable_details::__do_is_swappable_impl
{
    typedef decltype(__test<_Tp&>(0)) type;
};

template<typename _Tp, typename _Up>
struct __is_nothrow_swappable_with_impl
    : public __swappable_with_details::__do_is_nothrow_swappable_with_impl
{
    typedef decltype(__test<_Tp, _Up>(0)) type;
};

// Optimization for the homogenous lvalue case, not required:
template<typename _Tp>
struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
    : public __swappable_details::__do_is_nothrow_swappable_impl
{
    typedef decltype(__test<_Tp&>(0)) type;
};

/// is_swappable_with
template<typename _Tp, typename _Up>
struct is_swappable_with
    : public __is_swappable_with_impl<_Tp, _Up>::type
{ };

/// is_nothrow_swappable_with
template<typename _Tp, typename _Up>
struct is_nothrow_swappable_with
    : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
{ };

/// is_swappable_with_v
template<typename _Tp, typename _Up>
constexpr bool is_swappable_with_v =
    is_swappable_with<_Tp, _Up>::value;

/// is_nothrow_swappable_with_v
template<typename _Tp, typename _Up>
constexpr bool is_nothrow_swappable_with_v =
    is_nothrow_swappable_with<_Tp, _Up>::value;

} // namespace std

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

int main()
{
    std::cout << std::boolalpha;

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

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

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

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

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

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

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

    std::cout << "-----------------------------------------------" << std::endl;
    std::cout << std::endl;
    return 0;
}

输出

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

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

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

std::is_nothrow_swappable<B*>::value:                     false
std::is_nothrow_swappable<A*>::value:                     false
std::is_nothrow_swappable<B*>::value:                     false
std::is_nothrow_swappable<D>::value:                      false
std::is_nothrow_swappable<E>::value:                      false
std::is_nothrow_swappable<int>::value:                    false
std::is_nothrow_swappable<char>::value:                   false
std::is_nothrow_swappable<double>::value:                 false
std::is_nothrow_swappable<std::string>::value:            false
-----------------------------------------------

繁星璀璨G
关注
  • 24
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++标准模板（STL）- 类型支持 （类型关系，检查是否能转换一个类型为另一类型，std::is_convertible）
qq_40788199的博客
11-21 135
1) 若虚构函数定义 To test() { return std::declval(); } 为良式，（即 std::declval() 能用隐式转换转换为 To ，或 From 和 To 均为可有 cv 限定的 void ），则提供等于 true 的成员常量 value 。否则 value 为 false 。为此检查的目的，不认为 return 语句中的 std::declval 是 odr 使用。
C++标准模板（STL）- 概念库 (C++20) - 指定能销毁该类型的对象 - （std::destructible）
qq_40788199的博客
07-23 240
概念 destructible 指定能在实例生存期结尾安全销毁的所有类型（包含引用类型）的概念。
C++标准模板（STL）- 类型支持 （类型关系，检查类型能否以给定的实参类型调用，std::is_invocable）
qq_40788199的博客
07-30 840
1) 确定是否能以参数 ArgTypes... 调用 Fn 。 2) 确定是否能以参数 ArgTypes... 调用 Fn 并生成可转换为 R 的结果。 3) 确定是否能以参数 ArgTypes... 调用 Fn （同 (1) ），并已知这种调用不抛任何异常。 4) 确定是否能以参数 ArgTypes... 调用 Fn 并生成可转换为 R 的结果（同 (2) ），并已知这种调用（包括转换）不抛任何异常。
C++标准模板（STL）-基本类型 - 字节类型 （std::byte）
qq_40788199的博客
07-29 783
std::byte 是一种独立类型，它实现指定于 C++ 语言定义中的字节的概念。 同 char 与 unsigned char ，它能用于访问其他对象所占据的生内存（对象表示），但不同于这些类型，它不是字符类型且非算术类型。 byte 只是位的汇集，而且只对它定义逐位运算符。
C++标准模板（STL）- 概念库 (C++20) - 指定类型为整型类型 - （std::integral）
qq_40788199的博客
07-19 302
概念 integral 若且唯若 T 为整数类型才得到满足。
C++标准模板（STL）- 概念库 (C++20) - 指定类型为有符号的整型类型 - （std::signed_integral）
qq_40788199的博客
07-20 312
概念 signed_integral 若且唯若 T 为整数类型且 std::is_signed_v 为 true 才得到满足。.
c++11 标准模板（STL）（std::ios_base）成员类型与常量
qq_40788199的博客
06-15 803
流打开模式类型 ，格式化标志类型 ，流状态类型 ，寻位方向类型 ，指定事件类型，回调函数类型
C++标准模板（STL）- 概念库 (C++20) - 指定该类型的变量能从一组实参类型进行构造，或绑定到一组实参类型 - （std::constructible_from）
qq_40788199的博客
07-24 272
constructible_from 概念指定 T 类型变量能以给定的参数类型集 Args... 初始化。
C++标准模板（STL）- 概念库 (C++20) - 指定类型为无符号的整型类型 - （std::unsigned_integral）
qq_40788199的博客
07-21 589
概念 unsigned_integral 若且唯若 T 是整数类型且 std::is_signed_v 为 false 才得到满足。
C++标准模板（STL）- 概念库 (C++20) - 指定一个类型能隐式转换成另一类型 - （std::convertible_to）
qq_40788199的博客
07-18 350
概念 convertible_to 指定类型和值类别由 From 编码的表达式能隐式和显式转换成 To 类型，而二种转换形式等价。
【C语言】Top K问题【建小堆】
2301_80840905的博客
08-04 413
在我们生活中，经常会遇到TopK问题。建小堆解决
【C++】输入输出
2401_83948390的博客
08-02 512
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
C++ STL copy, move 用法
08-04 178
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
OD C卷 - 中庸行者
weixin_45228198的博客
08-04 184
DFS
c++——map、set底层之AVL树（动图演示旋转）
2301_80687320的博客
08-05 757
我们之前学了过二叉搜索树，二这里的AVL也是一种搜索树，当我们二叉搜索树发生偏移时，搜索时间就会边长，就不树logN了，变成N；而AVL就修复了这一点。一、{}// 该节点的左孩子// 该节点的右孩子// 该节点的双亲T _data;int _bf;// 该节点的平衡因子。
3.C_Demo_最大公约数、最小公倍数
Fresh_man111的博客
08-03 289
假设两个数字a和b，求两个数字相除的余数c=a%b，如果余数为0，则b为最大公约数。如果b不为零，a=b,b=c,继续循环计算。两个数的最小公倍数数等于两个数的乘积除以两个数的最大公约数。即：x，y的最小公倍数 min(公倍数)=x*y÷max(公约数)参数a，b：传入的两个数值，两个数都不能为0。参数a，b：传入的两个数值，不能全为0。返回值：0代表错误，正常返回最大公约数。返回值：0代表错误，正常返回最小公倍数。功能：求a，b最大公约数。功能：求a，b最小公倍数。
嵌入式初学-C语言-十五
最新发布
MaBaB的博客
08-05 537
函数：实现一定功能的，独立的代码模块，我们的函数一定是先定义后使用使用函数的优势可以通过函数提供功能给别人使用，当然我们也可以使用别人提供的函数，减少代码量借助函数可以减少重复性代码。实现结构化（模块化）程序设计思想结构化程序设计思想：将大型的任务功能，划分为相互独立的小型的任务模块来设计3.函数是c语言程序的基本组成单元：C语言程序是由一个（必然是main函数）或多个函数组成。语法：返回类型 函数名(形参列表) -- 函数头 | 函数首部。
【C语言篇】C语言数据类型和变量
2301_79849925的博客
07-27 808
C语⾔提供了丰富的数据类型来描述⽣活中的各种数据。 - 使⽤整型类型来描述整数 - 使⽤字符类型来描述字符 - 使⽤浮点型类型来描述⼩数 所谓“类型”，就是相似的数据所拥有的共同特征，编译器只有知道了数据的类型，才知道怎么操作数据。下⾯盘点⼀下C语⾔提供的各种数据类型，本文主要探讨内置数据类型。
string类的模拟实现(C++)
2302_80190394的博客
08-02 1107
C++ string的功能函数实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值