移动语义（Move Semantics）与 enable_if＜＞

已于 2022-07-17 21:35:43 修改
阅读量2.1k 收藏 6
点赞数 6
分类专栏： C++ C++ Templates 文章标签： c++ 开发语言 移动语义 完美转发 enable_if
于 2022-07-17 21:34:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dong_HFUT/article/details/125834102
版权

移动语义（Move Semantics）与 enable_if<>

移动语义（Move Semantics）无疑是 C++11 最重要的特性，可以用于优化拷贝和赋值操作。本章将讨论下移动语义对模板设计的影响。移动语义和完美转发相关文章也贴在这里，供参考：

Item 23: Understand std::move and std::forward.
Item 24: Distinguish universal references from rvalue references.
Item 25: Use std::move on rvalue references, std::forward on universal references.
Item 26: Avoid overloading on universal references.
Item 27: Familiarize yourself with alternatives to overloading on universal references.
Item 28: Understand reference collapsing.
Item 29: Assume that move operations are not present, not cheap, and not used.
Item 30: Familiarize yourself with perfect forwarding failure cases.

完美转发

将一个函数实参的如下基本特性转发给另一个函数：

  • 可修改的对象转发后应该仍可以被修改。
  • 常量对象应该作为只读对象转发。
  • 可移动的对象应该作为可移动对象转发。

如果不使用模板，你需要重载上面的所有情况，假设转发 f() 的参数给 g()：

#include <utility>
#include <iostream>

class X {
  ...
};

void g (X&) {
  std::cout << "g() for variable\n";
}

void g (X const&) {
  std::cout << "g() for constant\n";
}

void g (X&&) {
  std::cout << "g() for movable object\n";
}

// let f() forward argument val to g():
void f (X& val) {
  g(val);               // val is non-const lvalue => calls g(X&)
}

void f (X const& val) {
  g(val);              // val is const lvalue => calls g(X const&)
}

void f (X&& val) {
  g(std::move(val));   // val is non-const lvalue => needs std::move() to call g(X&&)
}

int main()
{
  X v;              // create variable
  X const c;        // create constant
  f(v);             // f() for nonconstant object calls f(X&) => calls g(X&)
  f(c);             // f() for constant object calls f(X const&) => calls g(X const&)
  f(X());           // f() for temporary calls f(X&&) => calls g(X&&)
  f(std::move(v));  // f() for movable variable calls f(X&&) => calls g(X&&)
}

需要注意的是第三个 f()，虽然 val 被申明为一个右值引用，但它本身依然是一个非常量左值，如果不使用 std::move 进行转换，将会调用第一个 f()。

void f (X&& val) {
  g(std::move(val));   // val is non-const lvalue => needs std::move() to call g(X&&)
}

C++11 引入的万能引用（Universal Reference）和完美转发（Perfect Forward）机制可以大大简化代码：

template<typename T>
void f (T&& val) {
  g(std::forward<T>(val));  // perfect forward val to g()
}

使用万能引用和完美转发版本的 f() 则可以完美替代上述三个版本的 f()。此处需要注意：对于模板参数 T 的 T&& 和一个特定类型 X 的 X&& 则完全不同。

  • 对于特定类型 X 的 X&& 是一个右值引用，它只能绑定到一个可移动的对象（a prvalue, such as a temporary object, and an xvalue, such as an object passed with std::move()）上。
  • 对于模板参数 T 的 T&& 是一个万能引用（universal reference，or called perfect reference），它可以绑定到一个可变的、不可变的、可移动的对象上。

T 必须是模板参数，模板的依赖参数不是万能引用。例如 T::iterator&& 只是一个右值引用，而非万能引用。

借助可变参数模板，完美转发也可以转发任意数量参数：

template<typename... Ts>
void f(Ts&&... args)
{
  g(std::forward<Ts>(args)...);
}

特殊成员函数模板

成员函数模板也可以用于特殊的成员函数，例如构造函数，但可能产生一些奇怪的行为。

考虑下面代码：

#include <utility>
#include <string>
#include <iostream>
class Person
{
  private:
    std::string name;
  public:
    // constructor for passed initial name:
    explicit Person(std::string const& n) : name(n) {
      std::cout << "copying string-CONSTR for '" << name << "'\n";
    }
    explicit Person(std::string&& n) : name(std::move(n)) {
      std::cout << "moving string-CONSTR for '" << name << "'\n";
    }
    // copy and move constructor:
    Person (Person const& p) : name(p.name) {
      std::cout << "COPY-CONSTR Person '" << name << "'\n";
    }
    Person (Person&& p) : name(std::move(p.name)) {
      std::cout << "MOVE-CONSTR Person '" << name << "'\n";
    }
};

int main()
{
  std::string s = "sname";
  Person p1(s);              // init with string object => calls copying string-CONSTR
  Person p2("tmp");          // init with string literal => calls moving string-CONSTR
  Person p3(p1);             // copy Person => calls COPY-CONSTR
  Person p4(std::move(p1));  // move Person => calls MOVE-CONST
}

如果我们使用万能引用和完美转发机制重写前两个 std::string 的构造函数：

#include <iostream>
class Person
{
  private:
    std::string name;
  public:
    // generic constructor for passed initial name:
    template<typename STR>
    explicit Person(STR&& n) : name(std::forward<STR>(n)) {
      std::cout << "TMPL-CONSTR for '" << name << "'\n";
    }
    // copy and move constructor:
    Person (Person const& p) : name(p.name) {
      std::cout << "COPY-CONSTR Person '" << name << "'\n";
    }
    Person (Person&& p) : name(std::move(p.name)) {
      std::cout << "MOVE-CONSTR Person '" << name << "'\n";
    }
};

int main()
{
  std::string s = "sname";
  Person p1(s);              // init with string object => calls TMPL-CONSTR
  Person p2("tmp");          // init with string object => calls TMPL-CONSTR
  Person p3(p1);             // ERROR
  Person p4(std::move(p1));  // OK: move Person => calls MOVE-CONST
  Person const p2c("ctmp");  // init constant object with string literal
  Person p3c(p2c);           // OK: copy constant Person => calls COPY-CONSTR
}

p1、p2、p4 的构造函数调用符合我们的预期，但是 p3 的构造将失败。这是因为完美转发构造函数的模板比拷贝构造函数更匹配 non-const 左值，于是调用完美转换构造函数，导致使用 Person 类型初始化 std::string 的错误。

Person p3(p1);

而拷贝一个 const 的类型的 Person，则不会有问题。这是因为当模板函数和普通函数都能完美匹配时，则优先调用普通函数。

Person const p2c("ctmp");  // init constant object with string literal
Person p3c(p2c);           // OK: copy constant Person => calls COPY-CONSTR

对于上面问题的一个解决方案是补充一个非 const 参数的拷贝构造函数：

Person(Person&);

但这不是一个完美的解决方案，对于继承类，完美转发的成员模板构造函数将更加匹配。可以参考文章开头的参考文章 Item 26: Avoid overloading on universal references. 的相关介绍。完美的解决方案是使用 enable_if<> 来禁用某些参数类型的实例化。

使用 enable_if<> 禁用模板

C++11 引入 enable_if<>，使模板根据编译期条件进行实例化。例如：

template<typename T>
typename std::enable_if<(sizeof(T) > 4)>::type
foo() {
}

如果表达式 (sizeof(T) > 4 为 false，该定义将被忽略，即模板不会被实例化。否则，才会实例化。

std::enable_if 是一个 type traits，编译时表达式作为首个模板实参传递。若表达式为 false，则 enable_if::type 未定义，由于被称为 SFINAE（substitution failure is not an error）的模板特性，这个带有 enable_if 的函数模板将被忽略。若表达式为 true，enable_if::type 产生一个类型，若有第二个实参，则类型为第二个实参类型，否则为 void。

template<typename T>
std::enable_if<(sizeof(T) > 4), T>::type 
foo() {
  return T();
}

C++14 为所有的 type traits 提供了别名模板。例如 enable_if::type 可以简写为 enable_if_t，则上述代码可以简化为：

template<typename T>
typename std::enable_if_t<(sizeof(T) > 4)>
foo() {
}

template<typename T>
typename std::enable_if_t<(sizeof(T) > 4), T>
foo() {
  return T();
}

为了增加可读性，可以将 enable_if 作为第二个模板参数：

template<typename T,
         typename = std::enable_if_t<(sizeof(T) > 4)>>
void foo() {
}

如果 (sizeof(T) > 4 为 true，则可扩展为：

template<typename T,
         typename = void>
void foo() {
}

还可以使用 using 进一步简化：

template<typename T>
using EnableIfSizeGreater4 = std::enable_if_t<(sizeof(T) > 4)>;

template<typename T,
         typename = EnableIfSizeGreater4<T>>
void foo() {
}

使用 enable_if<>

对于前面的问题，我们期望的是 std::string 或者可以转为为 std::string 类型的参数才匹配到完美转发构造函数。

template<typename STR>
Person(STR&& n);

借助 enable_if<> 和 std::is_convertible，并利用 C++17 的写法：std::is_convertible_v 替代 std::is_convertible::value ，实现如下：

template<typename STR,
         typename = std::enable_if_t<
                      std::is_convertible_v<STR, std::string>>>
Person(STR&& n);

如果 STR 是可以转换为 std::string 类型，则上述声明可以扩展为：

template<typename STR,
         typename = void>
Person(STR&& n);

同样地，可以借助 using 简化为：

template<typename T>
using EnableIfString = std::enable_if_t<
                         std::is_convertible_v<T, std::string>>;
...
template<typename STR, typename = EnableIfString<STR>>
Person(STR&& n);

这里给出完整代码：

#include <utility>
#include <string>
#include <iostream>
#include <type_traits>
template<typename T>
using EnableIfString = std::enable_if_t<
                         std::is_convertible_v<T,std::string>>;
class Person
{
  private:
    std::string name;
  public:
    // generic constructor for passed initial name:
    template<typename STR, typename = EnableIfString<STR>>
    explicit Person(STR&& n)
     : name(std::forward<STR>(n)) {
      std::cout << "TMPL-CONSTR for '" << name << "'\n";
    }
    // copy and move constructor:
    Person (Person const& p) : name(p.name) {
      std::cout << "COPY-CONSTR Person '" << name << "'\n";
    }
    Person (Person&& p) : name(std::move(p.name)) {
      std::cout << "MOVE-CONSTR Person '" << name << "'\n";
    }
};

int main()
{
  std::string s = "sname";
  Person p1(s);              // init with string object => calls TMPL-CONSTR
  Person p2("tmp");          // init with string literal => calls TMPL-CONSTR
  Person p3(p1);             // OK => calls COPY-CONSTR
  Person p4(std::move(p1));  // OK => calls MOVE-CONST
}

也可以用 std::is_constructible 替代 std::is_convertible，但 std::is_convertible 判断的是类型可以隐式转换，而 std::is_constructible 判断的是显式转换，实参顺序相反。

template<typename T>
using EnableIfString = std::enable_if_t<std::is_constructible_v<std::string, T>>;

禁用特殊成员函数

不能是 enable_if 禁用预定义的拷贝构造函数、赋值运算符、移动构造函数。例如：

class C {
  public:
    template<typename T>
    C (T const&) {
      std::cout << "tmpl copy constructor\n";
    }
    ...
};

C x;
C y{x}; // still uses the predefined copy constructor (not the member template)

一个解决办法是使用 =delete 标记预定义的特殊成员函数。

class C
{
  public:
    ...
    // user-define the predefined copy constructor as deleted
    // (with conversion to volatile to enable better matches)
    C(C const volatile&) = delete;
    // implement copy constructor template with better match:
    template<typename T>
    C(T const&) {
      std::cout << "tmpl copy constructor\n";
    }
    ...
};

C x;
C y{x}; // uses the member template

此时就可以用 enable_if<> 添加编译期限制，比如模板参数类型为整型时禁用拷贝构造：

template<typename T>
class C
{
  public:
    ...
    // user-define the predefined copy constructor as deleted
    // (with conversion to volatile to enable better matches)
    C(C const volatile&) = delete;
    // if T is no integral type, provide copy constructor template with better match:
    template<typename U,
             typename = std::enable_if_t<!std::is_integral<U>::value>>
    C (C<U> const&) {
      ...
    }
    ...
};

使用 Concepts 简化 enable_if<> 表达式

使用 enable_if<> 使用起来比较繁琐，并且可读性比较差。C++20 引入 Concepts 可以大大简化 enable_if<> 表达式。例如：

template<typename STR>
requires std::is_convertible_v<STR,std::string>
Person(STR&& n) : name(std::forward<STR>(n)) {
  ...
}

也可以简化为：

template<typename T>
concept ConvertibleToString = std::is_convertible_v<T,std::string>;

template<typename STR>
requires ConvertibleToString<STR>
Person(STR&& n) : name(std::forward<STR>(n)) {
...
}

甚至可以简化为：

template<ConvertibleToString STR>
Person(STR&& n) : name(std::forward<STR>(n)) {
  ...
}

至此，本文结束。

参考：

  • http://www.tmplbook.com
loongknown
关注
专栏目录
CPP11特性概述_cpp11_
10-04
`std::is_*`和`std::enable_if`等类型Traits库扩展了对类型属性的查询和类型条件化，帮助编写更安全的泛型代码。 5. **初始化列表（Initializer Lists）** 初始列表允许在构造对象或初始化数组时使用花括号，使得...
Item 26: Avoid overloading on universal references
heusunduo88的博客
10-18 135
避免利用万能引用类型进行重载
Modern Effective C++
阿Q在行走
01-05 1087
Effective Modern C++ Deducing Types 类型诊断 auto atuo Moving to Modern C++ 转向现代C++ Smart Pointers 智能指针 Rvalue References, Move Semantics, and Perfect Forwarding 右值引用，移动语义，完美转发 Lambda Expressions Lambda表达...
C++11中的 "enable_if"小记
电影旅行敲代码
06-18 1万+
std::enable_if
c++11-17 模板核心知识（八）—— enable_if＜＞与SFINAE
hyl999的专栏
01-15 1210
c++11-17 模板核心知识（八）—— enable_if<>与SFINAE 引子 使用enable_if<>禁用模板 enable_if<>实例 使用Concepts简化enable_if<> SFINAE (Substitution Failure Is Not An Error) SFINAE with decltype 引子 class Person { private: std::string name; public:
enable_if
m0_51271123的博客
12-06 2930
学习笔记
C++_C11.rar
01-14
首先，C++11在语法层面引入了右值引用（Rvalue References），这是一项关键的改进，用于支持更好的资源管理，特别是通过移动语义（Move Semantics）实现。移动语义允许对象的状态在构造函数和析构函数之间有效地转移...
C++11-14教程_C++14_c++11-14教程_C++11_
10-04
其中，最显著的改变之一是加入了右值引用（Rvalue References）和移动语义（Move Semantics），这一特性使得对象的资源可以在不复制的情况下高效转移，尤其在处理大对象时能大幅减少开销。同时，C++11还引入了类型...
GCC_x64_4.8.1_Setup
03-05
2. **右值引用（Rvalue References）**：允许更有效地处理临时对象，为移动语义（Move Semantics）提供基础，提高了效率。 3. **Lambda表达式**：在代码中定义匿名函数，便于编写简洁的回调和函数对象。 4. **范围...
C++11 enable_if
一个菜鸟
10-16 1478
C++11 enable_if最清晰的讲解 https://eli.thegreenplace.net/2014/sfinae-and-enable_if/
C++ enable_if的使用
jeffasd的专栏
11-30 1万+
http://www.fuzihao.org/blog/2016/07/14/C-enable-if%E7%9A%84%E4%BD%BF%E7%94%A8/ C++的enable_if常用于构建需要根据不同的类型的条件实例化不同模板的时候。本文主要讲了enable_if的使用场景和使用方式。 ## 函数重载的缺陷 函数重载能解决同名函数针对不同传入参数类型而实现不同的功能。举一个简单的例子： ...
std::enable_if 的几种用法
热门推荐
jeffasd的专栏
11-30 5万+
https://yixinglu.gitlab.io/enable_if.html std::enable_if 顾名思义，满足条件时类型有效。作为选择类型的小工具，其广泛的应用在 C++ 的模板元编程（meta programming）中。它的定义也异常的简单： template &lt;bool, typename T=void&gt; struct enable_if { }; te...
Ｃ++１１　enable_if　详解
catwan的专栏
06-24 8607
enable_if<>这个概念，以前从没有遇到过，这里做个小记。 /*----------llvm/include/llvm/ADT/Hashing.h------------*/ /// \brief Compute a hash_code for any integer value. /// /// Note that this function is intended to c...
C++——C++11新语法（中）
Wangx_wang的博客
11-06 1040
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
C++_用 using 语句继承基类的构造函数
最新发布
学海无涯
11-09 226
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
常用的c++特性--＞day02
m0_69093426的博客
11-06 624
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 298
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++ string(2)实现精讲
Jason_from_China的博客
11-06 1709
C++ string的使用我们已经讲解了，接下来我们会讲解string的实现，但是并不是每一个我都会实现，比如string删除有好几个，但是我会删除只是实现一个erase，首先是使用的次数频繁，其次是都大差不差，没有必要实现那么多，我这里只是把string整体的逻辑给实现，对string有一个更深入的了解提升代码能力和思维能力。注意事项1。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值