为什么在Herb Sutter的CppCon 2014演讲（返回基础知识：现代C ++风格）中不建议采用赋值设置器成员函数？

Question 1

在Herb Sutter的CppCon 2014演讲“回到基础：现代C ++风格”中，他在幻灯片28（此处是幻灯片的网络副本）上提到了这种模式：

class employee {
  std::string name_;
public:
  void set_name(std::string name) noexcept { name_ = std::move(name); }
};

他说这是有问题的，因为当用临时调用set_name（）时，noexcept-ness并不强（他使用短语“ noexcept-ish”）。

现在，我在自己最近的C ++代码中已经大量使用了上述模式，主要是因为它使我每次都不必键入两个set_name（）副本-是的，我知道每次强制执行一个副本构造可能会有点效率低下，但嘿，我是一个懒惰的打字员。但是，Herb的短语“ this noexcept有问题”令我担心，因为我在这里没有遇到问题：std :: string的移动赋值运算符是noexcept，它的析构函数也是如此，因此对我来说，上面的set_name（）似乎可以保证noexcept。我确实在编译器准备参数时在set_name（）之前看到了潜在的异常抛出，但是我正在努力将其视为有问题的。

后来在幻灯片32上，赫伯清楚地指出以上内容是反模式。有人可以向我解释为什么我懒得写不好的代码吗？

Question 2

其他人已经涵盖了noexcept上面的推理。

Herb在效率方面的讨论花费了更多时间。问题不在于分配，而在于不必要的释放。当您复制一个std::string如果有足够的空间来保存要复制的数据，则复制例程将重用目标字符串的已分配存储。在进行移动分配时，目标字符串的现有存储必须被重新分配，因为它从源字符串继承了存储。“复制并移动”这个惯用语迫使总是要进行重新分配，即使您没有通过临时传递也是如此。这是在稍后的演讲中演示的可怕表现的根源。他的建议是改为使用const ref，如果您确定需要使用const ref，则对r值引用有重载。这将为您提供两全其美的优势：将非临时文件复制到现有存储中，避免了重新分配，而将临时文件移到您所在的位置

上面的内容不适用于构造函数，因为成员变量中没有要分配的存储空间。这很好，因为构造函数通常会使用多个参数，并且如果您需要为每个参数执行const ref / r-value ref重载，则最终会产生构造函数重载的组合爆炸。

现在的问题是：复制时有多少类可以重用std :: string之类的存储？我猜std :: vector确实可以，但是我不确定。我确实知道我从未写过这样的可重用存储的类，但是我写了很多包含字符串和向量的类。遵循Herb的建议，对于不会重复使用存储的类不会造成伤害，首先将使用接收器功能的复制版本进行复制，如果您确定复制对性能造成的影响太大，则您会进行r值引用重载以避免复制（就像对std :: string那样）。另一方面，使用“复制和移动”确实对std :: string和其他可重用存储的类型产生了明显的性能影响，这些类型可能在大多数人的代码中都有很多用途。我现在正在遵循Herb的建议，但是在我认为问题完全解决之前（我可能没有足够的时间来潜伏这一切的博客文章），需要多考虑一些问题。

Question 3

考虑两个原因，为什么按值传递可能比按const引用传递更好。

更高效
没有

对于类型成员的setter std::string，他证明了const引用传递通常会产生较少的分配（至少对于std::string），从而驳斥了按值传递更有效的说法。

他还noexcept通过证明noexcept声明具有误导性来驳斥它允许设置器的说法，因为在复制参数的过程中仍然可能发生异常。

因此，他得出结论，至少在这种情况下，通过const引用传递比通过值传递更可取。但是，他确实提到按值传递对于构造函数而言是一种潜在的好方法。

我确实认为std::string仅靠示例是不足以概括所有类型的，但确实引起了质疑，至少出于效率和例外的原因，通过值传递昂贵的拷贝但廉价的参数传递值的做法。

Question 4

Herb的观点是，在已经分配了存储空间的情况下，按价值计算可能会效率低下并导致不必要的分配。但是采用byconst&几乎是很糟糕的，就像采用原始C字符串并将其传递给函数一样，会发生不必要的分配。

您应该采取的是从字符串读取的抽象，而不是字符串本身，因为这是您所需要的。

现在，您可以执行以下操作template：

class employee {
  std::string name_;
public:
  template<class T>
  void set_name(T&& name) noexcept { name_ = std::forward<T>(name); }
};

这是相当有效的。然后添加一些SFINAE也许：

class employee {
  std::string name_;
public:
  template<class T>
  std::enable_if_t<std::is_convertible<T,std::string>::value>
  set_name(T&& name) noexcept { name_ = std::forward<T>(name); }
};

因此我们在接口而不是实现上会遇到错误。

这并不总是可行的，因为它需要公开公开实现。

这是string_view类型类可以进入的地方：

template<class C>
struct string_view {
  // could be private:
  C const* b=nullptr;
  C const* e=nullptr;

  // key component:
  C const* begin() const { return b; }
  C const* end() const { return e; }

  // extra bonus utility:
  C const& front() const { return *b; }
  C const& back() const { return *std::prev(e); }

  std::size_t size() const { return e-b; }
  bool empty() const { return b==e; }

  C const& operator[](std::size_t i){return b[i];}

  // these just work:
  string_view() = default;
  string_view(string_view const&)=default;
  string_view&operator=(string_view const&)=default;

  // myriad of constructors:
  string_view(C const* s, C const* f):b(s),e(f) {}

  // known continuous memory containers:
  template<std::size_t N>
  string_view(const C(&arr)[N]):string_view(arr, arr+N){}
  template<std::size_t N>
  string_view(std::array<C, N> const& arr):string_view(arr.data(), arr.data()+N){}
  template<std::size_t N>
  string_view(std::array<C const, N> const& arr):string_view(arr.data(), arr.data()+N){}
  template<class... Ts>
  string_view(std::basic_string<C, Ts...> const& str):string_view(str.data(), str.data()+str.size()){}
  template<class... Ts>
  string_view(std::vector<C, Ts...> const& vec):string_view(vec.data(), vec.data()+vec.size()){}
  string_view(C const* str):string_view(str, str+len(str)) {}
private:
  // helper method:
  static std::size_t len(C const* str) {
    std::size_t r = 0;
    if (!str) return r;
    while (*str++) {
      ++r;
    }
    return r;
  }
};

可以直接从astd::string或a构造这样的对象，"raw C string"并且几乎无成本地存储您需要知道的内容，以便从中生成新的对象std::string。

class employee {
  std::string name_;
public:
  void set_name(string_view<char> name) noexcept { name_.assign(name.begin(),name.end()); }
};

并且由于现在我们set_name有一个固定的接口（不是完美的转发接口），因此它的实现可能不可见。

唯一的低效率是，如果您传递C风格的字符串指针，则在某种程度上不必要地遍历了它的大小两次（第一次寻找'\0'，第二次复制它们）。另一方面，这为您的目标信息提供了必须达到的大小，因此可以预先分配而不是重新分配。

Question 5

您有两种方法来调用该方法。

使用形rvalue参时，只要形move constructor参类型为noexcept，就没有问题（std::string大多数情况下为noexcept），在任何情况下都最好使用条件式noexcept（以确保形参为noexcept）
对于lvalue参数，在这种情况下，copy constructor将调用参数类型的，几乎可以确定它需要一些分配（可能会抛出）。

在这种情况下，使用可能会被误用，因此最好避免使用。class假定没有抛出异常的客户端，但是可以以有效，可编译，没有可疑的C++11方式抛出异常。