c++11-17 模板核心知識（十一）—— 撰寫泛型庫需要的基本技術-有解無憂

Callables
- 函式物件 Function Objects
- 處理成員函式及額外的引數
  - std::invoke<>()
- 統一包裝
泛型庫的其他基本技術
- Type Traits
- std::addressof()
- std::declval
完美轉發 Perfect Forwarding
作為模板引數的參考
延遲計算 Defer Evaluations

Callables

許多基礎庫都要求呼叫方傳遞一個可呼叫的物體（entity），例如：一個描述如何排序的函式、一個如何hash的函式，一般用callback來描述這種用法，在C++中有以下幾種形式可以實作callback，它們都可以被當做函式引數傳遞并可以直接使用類似f(...)的方式呼叫：

指向函式的指標，
多載了operator()的類（有時被叫做functors），包括lambdas.
包含一個可以生成函式指標或者函式參考的轉換函式的類，

C++使用callable type來描述上面這些型別，比如，一個可以被呼叫的物件稱作callable object，我們使用callback來簡化這個稱呼，

撰寫泛型代碼會因為這個用法的存在而可擴展很多，

函式物件 Function Objects

例如一個for_each的實作：

template <typename Iter, typename Callable>
void foreach (Iter current, Iter end, Callable op) {
  while (current != end) {     // as long as not reached the end
    op(*current);              // call passed operator for current element
    ++current;                 // and move iterator to next element
  }
}

使用不同的Function Objects來呼叫這個模板：

// a function to call:
void func(int i) { std::cout << "func() called for: " << i << '\n'; }

// a function object type (for objects that can be used as functions):
class FuncObj {
public:
  void operator()(int i) const { // Note: const member function
    std::cout << "FuncObj::op() called for: " << i << '\n';
  }
};


int main(int argc, const char **argv) {
  std::vector<int> primes = {2, 3, 5, 7, 11, 13, 17, 19};

  foreach (primes.begin(), primes.end(),  func);       // range function as callable (decays to pointer)
  foreach (primes.begin(), primes.end(), &func);         // range function pointer as callable

  foreach (primes.begin(), primes.end(), FuncObj());     // range function object as callable
                                              
  foreach (primes.begin(), primes.end(),     // range lambda as callable
           [](int i) {                   
             std::cout << "lambda called for: " << i << '\n';
           });
  return 0;
}

解釋一下：

foreach (primes.begin(), primes.end(), func); 按照值傳遞時，傳遞函式會decay為一個函式指標，
foreach (primes.begin(), primes.end(), &func); 這個比較直接，直接傳遞了一個函式指標，
foreach (primes.begin(), primes.end(), FuncObj()); 這個是上面說過的functor，一個多載了operator()的類，所以，當呼叫op(*current);時，實際是在呼叫op.operator()(*current);. ps. 如果不加函式宣告后面的const，在某些編譯器中可能會報錯，
Lambda ：這個和前面情況一樣，不解釋了，

處理成員函式及額外的引數

上面沒有提到一個場景：成員函式，因為呼叫非靜態成員函式的方式是object.memfunc(. . . )或ptr->memfunc(. . . )，不是統一的function-object(. . . )，

std::invoke<>()

幸運的是，從C++17起，C++提供了std::invoke<>()來統一所有的callback形式：

template <typename Iter, typename Callable, typename... Args>
void foreach (Iter current, Iter end, Callable op, Args const &... args) {
  while (current != end) {     // as long as not reached the end of the elements
    std::invoke(op,            // call passed callable with
                args...,       // any additional args
                *current);     // and the current element
    ++current;
  }
}

那么，std::invoke<>()是怎么統一所有callback形式的呢？
注意，我們在foreach中添加了第三個引數：Args const &... args. invoke是這么處理的：

如果Callable是指向成員函式的指標，它會使用args的第一個引數作為類的this，args中剩余的引數被傳遞給Callable，
否則，所有args被傳遞給Callable，

使用：

// a class with a member function that shall be called
class MyClass {
public:
  void memfunc(int i) const {
    std::cout << "MyClass::memfunc() called for: " << i << '\n';
  }
};

int main() {
  std::vector<int> primes = {2, 3, 5, 7, 11, 13, 17, 19};

  // pass lambda as callable and an additional argument:
  foreach (
      primes.begin(), primes.end(),              // elements for 2nd arg of lambda
      [](std::string const &prefix, int i) {     // lambda to call
        std::cout << prefix << i << '\n';
      },
      "- value: ");    // 1st arg of lambda

  // call obj.memfunc() for/with each elements in primes passed as argument
  MyClass obj;
  foreach (primes.begin(), primes.end(), // elements used as args
           &MyClass::memfunc,            // member function to call
           obj);                         // object to call memfunc() for
}

注意在callback是成員函式的情況下，是如何呼叫foreach的，

統一包裝

std::invoke()的一個場景用法是：包裝一個函式呼叫，這個函式可以用來記錄函式呼叫日志、測量時間等，

#include <utility>               // for std::invoke()
#include <functional>        // for std::forward()

template<typename Callable, typename... Args>
decltype(auto) call(Callable&& op, Args&&... args) {
    return std::invoke(std::forward<Callable>(op),  std::forward<Args>(args)...);       // passed callable with any additional args
}

一個需要考慮的事情是，如何處理op的回傳值并回傳給呼叫者：

template<typename Callable, typename... Args>
decltype(auto) call(Callable&& op, Args&&... args)

這里使用decltype(auto)（從C++14起）（decltype(auto)的用法可以看之前的文章 : c++11-17 模板核心知識（九）—— 理解decltype與decltype(auto)）

如果想對回傳值做處理，可以宣告回傳值為decltype(auto)：

decltype(auto) ret{std::invoke(std::forward<Callable>(op), std::forward<Args>(args)...)};

...
return ret;

但是有個問題，使用decltype(auto)宣告變數，值不允許為void，可以針對void和非void分別進行處理：

#include <functional>  // for std::forward()
#include <type_traits> // for std::is_same<> and invoke_result<>
#include <utility>     // for std::invoke()

template <typename Callable, typename... Args>
decltype(auto) call(Callable &&op, Args &&... args) {

  if constexpr (std::is_same_v<std::invoke_result_t<Callable, Args...>, void>) {
    // return type is void:
    std::invoke(std::forward<Callable>(op), std::forward<Args>(args)...);
    ... 
    return;
  } else {
    // return type is not void:
    decltype(auto) ret{
        std::invoke(std::forward<Callable>(op), std::forward<Args>(args)...)};
    ... 
    return ret;
  }
}

std::invoke_result<>只有從C++17起才能使用，C++17之前只能用typename std::result_of<Callable(Args...)>::type.

泛型庫的其他基本技術

Type Traits

這個技術很多人應該很熟悉，這里不細說了，

#include <type_traits>

template <typename T> 
class C {

  // ensure that T is not void (ignoring const or volatile):
  static_assert(!std::is_same_v<std::remove_cv_t<T>, void>,
                "invalid instantiation of class C for void type");

public:
  template <typename V> void f(V &&v) {
    if constexpr (std::is_reference_v<T>) {
      ... // special code if T is a reference type
    }
    if constexpr (std::is_convertible_v<std::decay_t<V>, T>) {
      ... // special code if V is convertible to T
    }
    if constexpr (std::has_virtual_destructor_v<V>) {
      ... // special code if V has virtual destructor
    }
  }
};

這里，我們使用type_traits來進行不同的實作，

std::addressof()

可以使用std::addressof<>()獲取物件或者函式真實的地址，即使它多載了operator &. 不過這種情況不是很常見，當你想獲取任意型別的真實地址時，推薦使用std::addressof<>()：

template<typename T>
void f (T&& x) {
    auto p = &x;         // might fail with overloaded operator &
    auto q = std::addressof(x);       // works even with overloaded operator &
    ...
}

比如在STL vector中，當vector需要擴容時，遷移新舊vector元素的代碼：

{
  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)元素
}

這里使用std::addressof()獲取新vector當前元素的地址，然后進行copy(或move)，可以看之前寫的c++ 從vector擴容看noexcept應用場景

std::declval

std::declval可以被視為某一特定型別物件參考的占位符，它不會創建物件，常常和decltype和sizeof搭配使用，因此，在不創建物件的情況下，可以假設有相應型別的可用物件，即使該型別沒有默認建構式或該型別不可以創建物件，

注意，declval只能在unevaluated contexts中使用，

一個簡單的例子：

class Foo;     //forward declaration
Foo f(int);     //ok. Foo is still incomplete
using f_result = decltype(f(11));      //f_result is Foo

現在如果我想獲取使用int呼叫f()后回傳的型別是什么？是decltype(f(11))？看起來怪怪的，使用declval看起來就很明了：

decltype(f(std::declval<int>()))

還有就是之前c++11-17 模板核心知識（一）—— 函式模板中的例子)——回傳多個模板引數的公共型別：

template <typename T1, typename T2,
          typename RT = std::decay_t<decltype(true ? std::declval<T1>()
                                                   : std::declval<T2>())>>
RT max(T1 a, T2 b) {
  return b < a ? a : b;
}

這里在為了避免在?:中不得不去呼叫T1 和T2 的建構式去創建物件，我們使用declval來避免創建物件，而且還可以達到目的，ps. 別忘了使用std::decay_t，因為declval回傳的是一個rvalue references. 如果不用的話，max(1,2)會回傳int&&.

最后看下官網的例子：

#include <utility>
#include <iostream>
 
struct Default { int foo() const { return 1; } };
 
struct NonDefault
{
    NonDefault() = delete;
    int foo() const { return 1; }
};
 
int main()
{
    decltype(Default().foo()) n1 = 1;                   // type of n1 is int
//  decltype(NonDefault().foo()) n2 = n1;               // error: no default constructor
    decltype(std::declval<NonDefault>().foo()) n2 = n1;    // type of n2 is int
    std::cout << "n1 = " << n1 << '\n'
              << "n2 = " << n2 << '\n';
}

完美轉發 Perfect Forwarding

template<typename T>
void f (T&& t) // t is forwarding reference {
    g(std::forward<T>(t));       // perfectly forward passed argument t to g()
}

或者轉發臨時變數，避免無關的拷貝開銷：

template<typename T>
void foo(T x) {
    auto&& val = get(x);
    ...

    // perfectly forward the return value of get() to set():
    set(std::forward<decltype(val)>(val));
}

作為模板引數的參考

template<typename T>
void tmplParamIsReference(T) {
    std::cout << "T is reference: " << std::is_reference_v<T> << '\n';
}

int main() {
    std::cout << std::boolalpha;
    int i;
    int& r = i;
    tmplParamIsReference(i);     // false
    tmplParamIsReference(r);      // false
    tmplParamIsReference<int&>(i);      // true
    tmplParamIsReference<int&>(r);      // true
}

這點也不太常見，在前面的文章c++11-17 模板核心知識（七）—— 模板引數按值傳遞 vs 按參考傳遞提到過一次，這個會改變強制改變模板的行為，即使模板的設計者一開始不想這么設計，

我沒怎么見過這種用法，而且這種用法有的時候會有坑，大家了解一下就行，

可以使用static_assert禁止這種用法：

template<typename T>
class optional {
    static_assert(!std::is_reference<T>::value, "Invalid instantiation of optional<T> for references");
    …
};

延遲計算 Defer Evaluations

首先引入一個概念：incomplete types. 型別可以是complete或者incomplete，incomplete types包含：

類只宣告沒有定義，
陣列沒有定義大小，
陣列包含incomplete types，
void
列舉型別的underlying type或者列舉型別的值沒有定義，

可以理解incomplete types為只是定義了一個識別符號但是沒有定義大小，例如：

class C;     // C is an incomplete type
C const* cp;     // cp is a pointer to an incomplete type
extern C elems[10];     // elems has an incomplete type
extern int arr[];     // arr has an incomplete type
...
class C { };     // C now is a complete type (and therefore cpand elems no longer refer to an incomplete type)
int arr[10];     // arr now has a complete type

現在回到Defer Evaluations的主題上，考慮如下類模板：

template<typename T>
class Cont {
  private:
    T* elems;
  public:
    ...
};

現在這個類可以使用incomplete type，這在某些場景下很重要，例如鏈表節點的簡單實作：

struct Node {
    std::string value;
    Cont<Node> next;        // only possible if Cont accepts incomplete types
};

但是，一旦使用一些type_traits，類就不再接受incomplete type：

template <typename T> 
class Cont {
private:
  T *elems;

public:
  ... 
  
  typename std::conditional<std::is_move_constructible<T>::value, T &&, T &>::type 
  foo();
};

std::conditional也是一個type_traits，這里的意思是：根據T是否支持移動語意，來決定foo()回傳T &&還是T &.

但是問題在于，std::is_move_constructible需要它的引數是一個complete type. 所以，之前的struct Node這種宣告會失敗（不是所有的編譯器都會失敗，其實這里我理解不應該報錯，因為按照類模板實體化的規則，成員函式只有用到的時候才進行實體化），

我們可以使用Defer Evaluations來解決這個問題：

template <typename T> 
class Cont {
private:
  T *elems;

public:
  ... 
  
  template<typename D = T>
  typename std::conditional<std::is_move_constructible<T>::value, T &&, T &>::type 
  foo();
};

這樣，編譯器就會直到foo()被complete type的Node呼叫時才實體化，

（完）

朋友們可以關注下我的公眾號，獲得最及時的更新：

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/228342.html

標籤：C++

上一篇：vs2019 Com組件初探-實作vbs的CreateObject函式邏輯

下一篇：C++基礎知識篇：C++ 回圈