c++ 從vector擴容看noexcept應用場景

c++11提供了關鍵字noexcept，用來指明某個函數沒法——或不打算——拋出異常：

void foo() noexcept;             // a function specified as will never throw
void foo2() noexcept(true);      // same as foo
void bar();                      // a function might throw exception
void bar2() noexcept(false);     // same as bar

因此咱們須要瞭解如下兩點：

• noexcept有什麼優勢，例如性能、可讀性等等。
• 需不須要在代碼中大量使用noexcept。

noexcept優勢

咱們先從std::vector入手來看一下第一點。

咱們知道，vector有本身的capacity，當咱們調用push_back可是vector容量滿時，vector會申請一片更大的空間給新容器，將容器內原有的元素copy到新容器內：

可是若是在擴容元素時出現異常怎麼辦？

• 申請新空間時出現異常：舊vector仍是保持原有狀態，拋出的異常交由用戶本身處理。
• copy元素時出現異常：全部已經被copy的元素利用元素的析構函數釋放，已經分配的空間釋放掉，拋出的異常交由用戶本身處理。

這種擴容方式比較完美，有異常時也會保持上游調用push_back時原有的狀態。

可是爲何說比較完美，由於這裏擴容仍是copy的，當vector內是一個類且持有資源較多時，這會很耗時。因此c++11推出了一個新特性：move，它會將資源從舊元素中「偷」給新元素（對move不熟悉的同窗能夠本身查下資料，這裏不展開說了）。應用到vector擴容的場景中：當vector中的元素的移動拷貝構造函數是noexcept時，vector就不會使用copy方式，而是使用move方式將舊容器的元素放到新容器中：

利用move的交換類資源全部權的特性，使用vector擴容效率大大提升，可是當發生異常時怎麼辦：
原有容器的狀態已經被破壞，有部分元素的資源已經被偷走。若要恢復會極大增長代碼的複雜性和不可預測性。因此只有當vector中元素的move constructor是noexcept時，vector擴容纔會採起move方式來提升性能。

剛纔總結了利用noexcept如何提升vector擴容。實際上，noexcept還大量應用在swap函數和move assignment中，原理都是同樣的。

noexcept使用場景

上面提到了noexcept可使用的場景：

• move constructor
• move assignment
• swap

不少人的第一念頭多是：個人函數如今看起來明顯不會拋異常，又說聲明noexcept編譯器能夠生成更高效的代碼，那能加就加唄。可是事實是這樣嗎？

這個問題想要討論清楚，咱們首先須要知道如下幾點：

• 函數本身不拋異常，可是不表明它們內部的調用不會拋出異常，而且編譯器不會提供調用者與被調用者的noexcept一致性檢查，例以下述代碼是合法的：

void g(){
    ...       //some code
}
void f() noexcept
{
    … 			//some code
    g();
}

• 當一個聲明爲noexcept的函數拋出異常時，程序會被終止並調用std::terminate();

因此在咱們的代碼內部調用複雜，鏈路較長，且隨時有可能加入新feature時，過早給函數加上noexcept可能不是一個好的選擇，由於noexcept一旦加上，後續再去掉也會變得困難 : 調用方有可能看到你的函數聲明爲noexcept，調用方也會聲明爲noexcept。可是當你把函數的noexcept去掉卻沒有修改調用方的代碼時，當異常拋出到調用方會致使程序終止。

目前主流的觀點是：

• 加noexcept
  • 函數在c++98版本中已經被聲明爲throw()
  • 上文提到過的三種狀況：move constructor、move assignmemt、swap。若是這些實現不拋出異常，必定要使用noexcept。
  • leaf function. 例如獲取類成員變量，類成員變量的簡單運算等。下面是stl的正向iterator中的幾個成員函數：

# if __cplusplus >= 201103L
#  define _GLIBCXX_NOEXCEPT noexcept
# else
#  define _GLIBCXX_NOEXCEPT

 reference
      operator*() const _GLIBCXX_NOEXCEPT
      { return *_M_current; }

      pointer
      operator->() const _GLIBCXX_NOEXCEPT
      { return _M_current; }

      __normal_iterator&
      operator++() _GLIBCXX_NOEXCEPT
      {
	++_M_current;
	return *this;
      }

      __normal_iterator
      operator++(int) _GLIBCXX_NOEXCEPT
      { return __normal_iterator(_M_current++); }

• 不加noexcept
  除了上面的要加的狀況，其他的函數不要加noexcept就能夠。

最後咱們看一下vector如何實現利用noexcept move constructor擴容以及move constructor是否聲明noexcept對擴容的性能影響。

如何實現利用noexcept move constructor擴容

這裏就不貼大段的代碼了，每一個平臺的實現可能都不同，咱們只關注vector是怎麼判斷調用copy constructor仍是move constructor的。

其中利用到的核心技術有：

• type trait
• iterator trait
• move iterator
• std::forward

核心代碼：

template <typename _Iterator, typename _ReturnType = typename conditional<
                                  __move_if_noexcept_cond<typename iterator_traits<_Iterator>::value_type>::value,
                                  _Iterator, move_iterator<_Iterator>>::type>
inline _GLIBCXX17_CONSTEXPR _ReturnType __make_move_if_noexcept_iterator(_Iterator __i) {
  return _ReturnType(__i);
}

template <typename _Tp>
struct __move_if_noexcept_cond
    : public __and_<__not_<is_nothrow_move_constructible<_Tp>>, is_copy_constructible<_Tp>>::type {};

這裏用type trait和iterator trait聯合判斷：假如元素有noexcept move constructor，那麼is_nothrow_move_constructible=1 => __move_if_noexcept_cond=0 => __make_move_if_noexcept_iterator返回一個move iterator。這裏move iterator迭代器適配器也是一個c++11新特性，用來將任何對底層元素的處理轉換爲一個move操做，例如：

std::list<std::string> s;
std::vector<string> v(make_move_iterator(s.begin()),make_move_iterator(s.end()));     //make_move_iterator返回一個std::move_iterator

而後上游利用生成的move iterator進行循環元素move:

{
  for (; __first != __last; ++__first, (void)++__cur) std::_Construct(std::__addressof(*__cur), *__first);
  return __cur;
}

template <typename _T1, typename... _Args>
inline void _Construct(_T1 *__p, _Args &&... __args) {
  ::new (static_cast<void *>(__p)) _T1(std::forward<_Args>(__args)...);      //實際copy(或者move)元素
}

其中_Construct就是實際copy(或者move)元素的函數。這裏很關鍵的一點是：對move iterator進行解引用操做，返回的是一個右值引用。，這也就保證了，當__first類型是move iterator時，用_T1(std::forward<_Args>(__args)...進行「完美轉發」才調用_T1類型的move constructor，生成的新對象被放到新vector的__p地址中。

總結一下過程就是：

• 利用type trait和iterator trait生成指向舊容器的normal iterator或者move iterator
• 循環將舊容器的元素搬到新容器。若是指向舊容器的是move iterator，那麼解引用會返回右值引用，會調用元素的move constructor，不然調用copy constructor。

你們能夠用下面這段簡單的代碼在本身的平臺打斷點調試一下：

class A {
 public:
  A() { std::cout << "constructor" << std::endl; }
  A(const A &a) { std::cout << "copy constructor" << std::endl; }
  A(const A &&a) noexcept { std::cout << "move constructor" << std::endl; }
};

int main() {
  std::vector<A> v;
  for (int i = 0; i < 10; i++) {
    A a;
    v.push_back(a);
  }

  return 0;
}

noexcept move constructor對性能的影響

這篇文章C++ NOEXCEPT AND MOVE CONSTRUCTORS EFFECT ON PERFORMANCE IN STL CONTAINERS介紹了noexcept move constructor對耗時以及內存的影響，這裏不重複贅述了，感興趣的能夠本身試一下。

參考資料：

• When to Use noexcept And When to Not
• Does noexcept improve performance?
• EffectiveModernCppChinese Item14
• C++11的noexcept標識符與操做符應如何正確使用？

（完）

朋友們能夠關注下個人公衆號，得到最及時的更新：