Item 41: Consider pass by value for copyable parameters that are cheap to move and always copied.

已于 2022-10-02 06:02:48 修改
阅读量1.9k 收藏 5
点赞数 4
分类专栏： Effective Modern C++ C++ 文章标签： c++ 开发语言 值传递 引用 构造函数
于 2022-10-01 16:21:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dong_HFUT/article/details/127054642
版权

Item 41: Consider pass by value for copyable parameters that are cheap to move and always copied.

C++ 函数参数传递方式有值传递、指针传递、引用传递的方式。一般地，考虑到拷贝开销，建议使用引用传递的方式。例如：

class Widget {
public:
  void addName(const std::string& newName) // take lvalue;
  { names.push_back(newName); }            // copy it
  
  void addName(std::string&& newName)      // take rvalue;
  { names.push_back(std::move(newName)); } // move it; see
  ...                                      // Item 25 for use
                                           // of std::move
private:
  std::vector<std::string> names;
};

对于左值，拷贝进 Widget.names 中。对于右值，移动进 Widget.names。上面代码是有效的，但是实现和维护两个函数有点冗余。

另一种方案是使用万能引用（universal reference）传参。例如：

class Widget {
public:
  template<typename T>                            // take lvalues
  void addName(T&& newName)                       // and rvalues;
  {                                               // copy lvalues,
    names.push_back(std::forward<T>(newName));    // move rvalues;
  }                                               // see Item 25
                                                  // for use of
  ...                                             // std::forward
};

万能引用版本代码量减少了很多，看起来也清爽很多，但也会有其他问题。但模板的实现一般要放到头文件里，也会实例化出多个版本（左值版本、右值版本以及可以转换为 std::string 的类型版本）。于此同时，还存在诸如 Item 30 介绍万能引用和完美转发失效的例子、Item 27 介绍的传参错误时编译报错可读性很差的问题。

那么有没有什么完美的方案可以解决上述两种方案遇到的问题呢？我们来分析下值传递的方案。

class Widget {
public:
  void addName(std::string newName)         // take lvalue or
  { names.push_back(std::move(newName)); }  // rvalue; move it
  ...
};

在 addName 内对 newName 使用 std::move 可以减少一次拷贝。这里使用 std::move 考虑到两点：首先，newName 独立于传入的参数，不会影响到调用者；再者，这里是最后使用 newName 的地方，对其移动不会影响其他代码。

值传递的方案可以解决引用重载版本的源码冗余问题和万能引用版本的不适用场景、传参错误报错信息可读性等问题，那剩下的问题就是值传递方案的性能了。

在 C++98 中，对于值传递的方案，不管传入的左值还是右值，newName 都会通过拷贝构造函数来构造。而到了 C++11，newName 在传入左值时是拷贝构造，传入右值是移动构造。考虑到下面的代码：

Widget w;
...
std::string name("Bart");

w.addName(name);            // call addName with lvalue
...
w.addName(name + "Jenne");  // call addName with rvalue
                            // (see below)

对于第一个调用，参数 newName 使用左值初始化，是拷贝构造。对于第二个调用，参数 newName 使用右值初始化，是移动构造。

我们把上述三种方案写到一起再对比下性能：

class Widget {                             // Approach 1:overload for             
public:                                    // lvalues and rvalues.
  void addName(const std::string& newName) // take lvalue;
  { names.push_back(newName); }            // copy it
  
  void addName(std::string&& newName)      // take rvalue;
  { names.push_back(std::move(newName)); } // move it; see
  ...                                      // Item 25 for use
                                           // of std::move
private:
  std::vector<std::string> names;
};

class Widget {                             // Approach 2: use universal reference
public:
  void addName(const std::string& newName) // take lvalue;
  { names.push_back(newName); }            // copy it
  
  void addName(std::string&& newName)      // take rvalue;
  { names.push_back(std::move(newName)); } // move it; see
  ...                                      // Item 25 for use
                                           // of std::move

};

class Widget {                              // Approach 3: pass by value
public:
  void addName(std::string newName)         // take lvalue or
  { names.push_back(std::move(newName)); }  // rvalue; move it
  ...
};

同样，考虑上面两种调用方式：

Widget w;
...
std::string name("Bart");

w.addName(name);            // call addName with lvalue
...
w.addName(name + "Jenne");  // call addName with rvalue
                            // (see below)

这里，我们忽略掉编译器根据上下文信息所做的编译优化的干扰，对比下三种方案的性能开销：

  • 引用重载：首先，无论是左值还是右值重载函数， 调用者的实参是被绑定到引用 newName上，没有拷贝或移动开销。再者，对于左值引用重载函数， newName 被拷贝到 Widget::names 内，而对于右值引用重载函数，newName 被移动到 Widget::names 内。总的来说，左值需要一次拷贝，右值需要一次移动。
  • 万能引用：首先，调用者的实参也是被绑定到引用 newName上，也没有拷贝或移动开销。再者，由于使用了 std::forward ，左值实参则被拷贝到 Widget::names 内，而右值实参则被移动到 Widget::names 内。总的来说，左值需要一次拷贝，右值需要一次移动。
    对于调用者传入的参数不是 std::string 类型，而是可以转换为 std::string 的类型，比如 char* 类型，对于引用重载版本，需要先将 char* 构造成 std::string，这会增加其开销，而万能引用版本则直接将 char* 转发给 std::string 构造函数直接构造 std::string 类型，详见 Item 25 。这里不考虑这种特殊情况。
  • 值传递：首先，对于左值，需要调用拷贝构造 newName，而对于右值，需要移动构造 newName。再者， newName 被无条件移动到 Widget::names 内。总的来说，左值需要一次拷贝加一次移动，右值需要两次移动。相较于前两种引用传参的方法，多了一次移动操作。

再回头看下本 Item 的标题： Consider pass by value for copyable parameters that are cheap to move and always copied。缘于以下四个原因：

  1. 只考虑值传递的话，只需要写一个函数，目标代码中也会生成一个函数，并且可以避免万能引用方法的问题。但是引入了一点性能开销。
  2. 只对可拷贝的参数使用值传递方法。如果参数是 move-only 的，那值传递的方法肯定会失败。对于 move-only 类型参数，也无须提供左值引用重载函数，只需要一个右值引用的重载函数即可。例如，对于传递 std::unique_ptr 类型参数：
	class Widget {
	public:
	  ...
	  void setPtr(std::unique_ptr<std::string>&& ptr)
	  { p = std::move(ptr); }
	private:
	  std::unique_ptr<std::string> p;
	};
	...
	Widget w;
    ...
    w.setPtr(std::make_unique<std::string>("Modern C++"));

上述代码，std::make_unique<std::string>("Modern C++") 产生一个右值，然后被移动到成员变量 p 上。因此总的开销是一次移动。如果只提供值传递的方法：

	class Widget {
	public:
	  ...
	  void setPtr(std::unique_ptr<std::string> ptr)
	  { p = std::move(ptr); }
	  ...
	};

相同的调用，会隐式移动构造 ptr，接着移动赋值给 p。因而总的开销则是两次移动操作。

  1. 只有当移动开销低时才考虑值传递方法。因为只有当移动开销很低时，额外的一次移动才是可接受的。否则，执行一次不必要的移动操作和执行一次不必要的拷贝操作是类似的，都一样违反了 C++98 中避免值拷贝这一规则。
  2. 只有当参数总是要被拷贝的时才考虑值传递方法。假设在将参数放入 Widget::names 内之前先对参数进行合法性检查，满足条件才放入到 Widget::names 内。例如：
class Widget {
public:
  void addName(std::string newName)
  {
    if ((newName.length() >= minLen) &&
        (newName.length() <= maxLen))
    {
      names.push_back(std::move(newName));
    }
  }
  ...
private:
  std::vector<std::string> names;
};

如果不满足条件则会浪费 newName 的构造和析构的开销，想比较而言，引用传参开销更小。

即使上述条件都满足（移动开销低的可拷贝参数被无条件拷贝）时，值传递也不一定适用。函数参数的拷贝有两种方式：通过构造（拷贝构造或移动构造）和通过赋值（拷贝赋值或移动赋值）。上面例子中的 addName 使用的就是构造的方式，其参数 newName 通过拷贝构造创建了一个新的元素放在 std::vector 的尾部。这种情况比引用传参多一次移动。

当参数通过赋值拷贝，情况要复杂的多。例如，你有一个表示密码的类，由于密码可以被改变，需要同时提供 setter 和 changeTo 两个方法，值传递方法的实现如下：

class Password {
public:
  explicit Password(std::string pwd)  // pass by value
  : text(std::move(pwd)) {}           // construct text
  
  void changeTo(std::string newPwd)   // pass by value
  { text = std::move(newPwd); }       // assign text

  ...
  
private:
  std::string text;                  // text of password
};

std::string initPwd("Supercalifragilisticexpialidocious");
Password p(initPwd);

这里，p.text 通过构造函数进行了密码的初始化。通过前面的分析可知，相比较引用传递的方法，多了一次额外的移动开销。当通过下面的方式修改密码时：

std::string newPassword = "Beware the Jabberwock";
p.changeTo(newPassword);

changeTo 采用的是赋值构造，值传递的方法会产生性能问题。构造 newPwd 时， std::string 的构造函数会被调用，这个构造函数中会分类内存来保存 newPwd，然后， newPwd 移动赋值给 text，这将导致 text 原来指向的内存会释放掉。也就是说，修改密码的过程发生一次内存的申请和一次内存的释放。其实在这里，旧的密码（“Supercalifragilisticexpialidocious”）比新的密码（“Beware the Jabberwock”）长度更长，没有必要申请或者释放内存。如果采用下面引用重载的方法，很可能申请和释放内存都不会发生：

class Password {
public:
  ...
  void changeTo(const std::string& newPwd) // the overload
  {                                        // for lvalues
    text = newPwd;          // can reuse text's memory if
                            // text.capacity() >= newPwd.size()
  }
  ...
private:
  std::string text;
};

当 text 的字符串长度大于 newPwd 的时会复用已经分配的内存。因此，开销要比值传递的方式要小。如果旧密码的长度要比新密码短时，那么赋值过程中的申请和释放内存不可避免，则值传递和引用传递二者的开销一致。

上面对函数参数通过赋值来拷贝的分析要考虑多种因素，例如传递的类型、左值还是右值、类型是否使用动态内存等。例如: 对于 std::string，如果它使用了SSO 优化，那么赋值的操作会将要赋值的内容放到 SSO 的缓存中，那么情况又不一样了。SSO 优化详见 Item 29。

如果要追求极致的性能，值传递的方式可能不再是一个可行的方法，因为避免一次廉价的移动开销也是很重要的。并且我们并不是总是知道会有多少次这样的移动操作，例如，addName 通过值传递造成了一次额外的移动操作，但是这个函数内部又调用了 validateName，并且也是值传递的方式，这将就又造成了一次额外的移动开销，validateName 内部如果再调用其他的函数，并且这个函数同样是值传递的方式呢?这就造成了累加效应，而采用引用传递的方式就不会有这样的累加效应。

最后，一个与性能无关的话题，但却值得我们关注。那就是值传递的类型切割问题（slicing problem），详见 C++ 按值传递的切割问题（Slicing Problem）。

至此，本文结束。

参考：

loongknown
关注
专栏目录
Effective Modern C++ 条款41：对于移动成本低且总是被拷贝的可拷贝形参，考虑按值传递
cf18862344377的博客
05-24 1614
（这样的句子就说明有一个术语来区分拷贝操作制作的副本，和移动操作制作的副本，是非常好的。对于特殊的场景，可拷贝且移动开销小的类型，传递给总是会拷贝他们的一个函数，并且切片也不需要考虑，这时，按值传递就提供了一种简单的实现方式，效率接近传递引用的函数，但是避免了传引用方案的缺点。结论是，使用通过赋值拷贝一个形参进行按值传递的函数的额外开销，取决于传递的类型，左值和右值的比例，这个类型是否需要动态分配内存，以及，如果需要分配内存的话，赋值操作符的具体实现，还有赋值目标占的内存至少要跟赋值源占的内存一样大。
torch.nn、(一)
weixin_36670529的博客
08-30 2202
目录 torch.nn Parameters Containers Module Sequential ModuleList ModuleDict ParameterList ParameterDict Convolution layers Conv1d Conv2d Conv3d ConvTranspose1d ConvTranspose2d ConvTransp...
Item41 Consider pass by value for copyable parameters that are cheap to move and always copied.
zyfforlinux
05-29 1330
这个系列的文章来自于Effective Modern C++的读书笔记，我抽取了其中比较重要的，不容易理解的，平常我们开发过程中也不太在意的一些Item进行分析。 ​ 函数的参数传递方式有很多种，可以是值拷贝、传指针、传引用、甚至是移动。下面这个addName函数就是将外部传入的值存放到其内部的一个私有的容器中，为了让传递的过程更加高效，addName同时支持引用传递和移动两种方式。class W
Effective Modern C++笔记汇总
zyfforlinux
06-05 1万+
Effective Modern C++ 目录Item 1: Understand template type deduction….待续
Effective Modern C++ 阅读笔记（最新颖的名词是‘通用引用’和‘完美转发’，C++语言真是博大精深，哈哈）
cteng的专栏
12-13 2881
Effective Modern C++ 目录 1 Deducing Types2 auto3 Moving to Modern C++4 Smart Pointers5 Rvalue References, Move Semantics, and Perfect Forwarding6 Lambda Expressions7 The Concurre
Want Speed? Pass by Value.
CPP_CHEN的专栏
12-24 2084
Want Speed? Pass by Value. This entry is part of a series, RValue References: Moving Forward»Entries in this series: Want Speed? Pass by Value. Making Your Next Move Your Next Assignme
Effective Modern C++ 完全解读笔记汇总
Dong_HFUT的博客
10-04 7297
Effective Modern C++ 系列学习和解读笔记汇总。
C++核心准则边译边学-F.16 对于输入参数来说，拷贝代价小的传值，其他传递const参照
面向对象思考
01-03 439
F.16: For "in" parameters, pass cheaply-copied types by value and others by reference to const（对于输入参数来说，拷贝代价小的传值，其他传递const参照） Reason（原因） Both let the caller know that a function will not modify the ...
item41 对于移动成本低且总是被拷贝的可拷贝形参，考虑按值传递
学IT的细胞膜的博客
07-11 336
对于C++中的通用技术和特性，总是存在适用和不适用的场景。除了本章覆盖的两个例外，描述什么场景使用哪种通用技术通常来说很容易。这两个例外是传值（pass by value）和安置（emplacement）。决定何时使用这两种技术受到多种因素的影响，本书提供的最佳建议是在使用它们的同时仔细考虑清楚，尽管它们都是高效的现代C++编程的重要角色。接下来的条款提供了使用它们来编写软件是否合适的所需信息。
Effective Modern C++42招独家技巧助你改善C++11和C++14的高效用法笔记
网络资源是无限的
02-01 9763
Scott Meyers大师Effective三部曲：Effective C++、More Effective C++、Effective STL，这三本书出版已很多年，后来又出版了Effective Modern C++。 Effective C++的笔记见：https://blog.csdn.net/fengbingchun/article/details/102761542 More E...
Effective Modern C++：类型推导与最佳实践
Item17：考虑值传递（Consider pass by value for cheap-to-move parameters that are always copied） 对于移动语义良好的类型，值传递可以利用移动构造函数提高性能。 Item18：考虑使用emplace代替插入（Consider...
Modern Effective C++
阿Q在行走
01-05 1086
Effective Modern C++ Deducing Types 类型诊断 auto atuo Moving to Modern C++ 转向现代C++ Smart Pointers 智能指针 Rvalue References, Move Semantics, and Perfect Forwarding 右值引用，移动语义，完美转发 Lambda Expressions Lambda表达...
《高效的项目和团队》
热门推荐
海阔天空 邵加超的BLOG
01-04 1万+
Productive Projects and Teams是一本好书。 许多其中许多关于管理和沟通的精辟言论让我大有相见很晚之感。其实不仅是软件的开发项目，任何项目，甚至任何行业的管理，都首先是对人的管理，然后才是对事物的管理，所以设身处地的为别人着想，用鼓励来代替批评，用相互学习来取消互相排挤，在失败中学习，在前进中自醒，则无往而不胜。鉴于原书是英文的，我打算利用业余时间把它翻译成中文，一来方便
C++——C++11新语法（中）
Wangx_wang的博客
11-06 1034
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
C++_用 using 语句继承基类的构造函数
最新发布
学海无涯
11-09 219
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
C 学习（4）
search7的博客
11-05 855
C语言学习，每个模块来自工作中的？？？
常用的c++特性--＞day02
m0_69093426的博客
11-06 609
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 290
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++ string(2)实现精讲
Jason_from_China的博客
11-06 1706
C++ string的使用我们已经讲解了，接下来我们会讲解string的实现，但是并不是每一个我都会实现，比如string删除有好几个，但是我会删除只是实现一个erase，首先是使用的次数频繁，其次是都大差不差，没有必要实现那么多，我这里只是把string整体的逻辑给实现，对string有一个更深入的了解提升代码能力和思维能力。注意事项1。
Clang-Tidy: Pass by value and use std::move
05-23
Clang-Tidy is a static analysis tool for C++ code that helps identify potential bugs or issues in the code. One of the checks it can perform is to suggest passing arguments by value and using std::move instead of passing by reference. Passing arguments by value means that a copy of the argument is made and passed to the function. This can be more efficient than passing by reference if the argument is small enough to be copied quickly. Additionally, passing by value can improve code safety because it avoids the possibility of accidentally modifying the original object. Using std::move can improve efficiency when dealing with large objects or objects that are expensive to copy. std::move allows the contents of an object to be moved to a new location without copying, which can be much faster than copying the entire object. In summary, Clang-Tidy is suggesting to pass arguments by value and use std::move to improve code efficiency and safety.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值