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呼叫時才例項化。
（完）
朋友們可以關注下我的公眾號，獲得最及時的更新：
