boost::function用法詳解

阿新 • • 發佈：2018-10-10

另一個功能構造函數要求 first 不同類 blank 吸引指向

要開始使用 Boost.Function, 就要包含頭文件 "boost/function.hpp", 或者某個帶數字的版本，從 "boost/function/function0.hpp" 到 "boost/function/function10.hpp". 如果你知道你想保存在 function 中的函數的參數數量，這樣做可以讓編譯器僅包含需要的頭文件。如果包含 "boost/function.hpp", 那麽就會把其它的頭文件也包含進去。

理解被存函數的最佳方法是把它想象為一個普通的函數對象，該函數對象用於封裝另一個函數(或函數對象)。這個被存的函數的最大用途是它可以被多次調用，而無須在創建 function

時立即使用。在聲明 functions 時，聲明中最重要的部分是函數的簽名。這部分即是告訴 function 它將保存的函數或函數對象的簽名和返回類型。我們已經看到，有兩種方法來執行這個聲明。這裏有一個完整的程序，程序聲明了一個 boost::function ，它可以保存返回 bool (或某個可以隱式轉換為 bool 的類型)並接受兩個參數的類函數實體，第一個參數可以轉換為 int, 第二個參數可以轉換為 double.

#include <iostream>
#include "boost/function.hpp"

bool some_func(int i,double d) {
 
  return i>d;
}

int main() {
  boost::function<bool (int,double)> f;
  f=&some_func;
  f(10,1.1);
}

當 function f 首次創建時，它不保存任何函數。它是空的，可以在一個布爾上下文中進行測試。如果你試圖調用一個沒有保存任何函數或函數對象的 function ，它將拋出一個類型 bad_function_call 的異常。為了避免這個問題，我們用普通的賦值語法把一個指向 some_func 的指針賦值給 f 。這導致 f 保存了到 some_func 的指針。最後，我們用參數10 (一個 int

) 和 1.1 (一個 double)來調用 f (用函數調用操作符)。要調用一個 function, 你必須提供被存函數或函數對象所期望的準確數量的參數。

回調的基礎

我們先來看看在沒有 Boost.Function 以前我們如何實現一個簡單的回調，然後再把代碼改為使用 function, 並看看會帶來什麽優勢。我們從一個支持某種簡單的回調形式的類開始，它可以向任何對新值關註的對象報告值的改變。這裏的回調是一種傳統的C風格回調，即使用普通函數。這種回調用可用於象GUI控制這樣的場合，它可以通知觀察者用戶改變了它的值，而不需要對監聽該信息的客戶有任何特殊的知識。

#include <iostream>
#include <vector>
#include <algorithm>
#include "boost/function.hpp"

void print_new_value(int i) {
  std::cout << 
    "The value has been updated and is now " << i << ‘/n‘;
}

void interested_in_the_change(int i) {
  std::cout << "Ah, the value has changed./n";
}

class notifier {
  typedef void (*function_type)(int);
  std::vector<function_type> vec_;
  int value_;
public:
  void add_observer(function_type t) {
    vec_.push_back(t);
  }

  void change_value(int i) {
    value_=i;
    for (std::size_t i=0;i<vec_.size();++i) {
      (*vec_[i])(value_);
    }
  }
};

int main() {
  notifier n;
  n.add_observer(&print_new_value);
  n.add_observer(&interested_in_the_change);

  n.change_value(42);
}

這裏的兩個函數，print_new_value 和 interested_in_the_change, 它們的函數簽名都兼容於 notifier 類的要求。這些函數指針被保存在一個 vector 內，並且無論何時它的值被改變，這些函數都會在一個循環裏被調用。調用這些函數的一種語法是：

(*vec_[i])(value_);

值(value_)被傳遞給解引用的函數指針(即 vec_[i] 所返回的)。另一種寫法也是有效的，即這樣：

vec_[i](value_);

這種寫法看起來更好看些，但更為重要的是，它還可以允許你把函數指針更換為 Boost.Function 而沒有改變調用的語法。現在，工作還是正常的，但是，唉，函數對象不能用於這個 notifier 類。事實上，除了函數指針以外，別的任何東西都不能用，這的確是一種局限。但是，如果我們使用 Boost.Function，它就可以工作。重寫這個 notifier 類非常容易。

class notifier {
  typedef boost::function<void(int)> function_type;
  std::vector<function_type> vec_;
  int value_;
public:
  template <typename T> void add_observer(T t) {
    vec_.push_back(function_type(t));
  }

  void change_value(int i) {
    value_=i;
    for (std::size_t i=0;i<vec_.size();++i) {
      vec_[i](value_);
    }
  }
};

首先要做的事是，把 typedef 改為代表 boost::function 而不是函數指針。之前，我們定義的是一個函數指針；現在，我們使用泛型方法，很快就會看到它的用途。接著，我們把成員函數 add_observer 的簽名改為泛化的參數類型。我們也可以把它改為接受一個 boost::function，但那樣會要求該類的用戶必須也知道 function 的使用方法^[2]，而不是僅僅知道這個觀察者類型的要求就行了。應該註意到 add_observer 的這種變化並不應該是轉向 function 的結果；無論如何代碼應該可以繼續工作。我們把它改為泛型的；現在，不管是函數指針、函數對象，還是 boost::function 實例都可以被傳遞給 add_observer, 而無須對已有用戶代碼進行任何改動。把元素加入到 vector 的代碼有一些修改，現在需要創建一個 boost::function<void(int)> 實例。最後，我們把調用這些函數的語法改為可以使用函數、函數對象以及 boost::function 實例^[3]。這種對不同類型的類似函數的"東西"的擴展支持可以立即用於帶狀態的函數對象，它們可以實現一些用函數很難做到的事情。

^[2] 他們應該知道 Boost.Function,但如果他們不知道呢？我們添加到接口上的任何東西都必須及時向用戶解釋清楚。

^[3] 現在我們知道，一開始我們就應該用這種語法。

class knows_the_previous_value {
  int last_value_;
public:
  void operator()(int i) {
    static bool first_time=true;
    if (first_time) {
      last_value_=i;
      std::cout << 
        "This is the first change of value, /
so I don‘t know the previous one./n";
      first_time=false;
      return;
    }
    std::cout << "Previous value was " << last_value_ << ‘/n‘;
    last_value_=i;
  }
};

這個函數對象保存以前的值，並在值被改變時把舊值輸出到 std::cout 。註意，當它第一次被調用時，它並不知道舊值。這個函數對象在函數中使用一個靜態 bool 變量來檢查這一點，該變量被初始化為 true. 由於函數中的靜態變量是在函數第一次被調用時進行初始化的，所以它僅在第一次調用時被設為 true 。雖然也可以在普通函數中使用靜態變量來提供狀態，但是我們必須知道那樣不太好，而且很難做到多線程安全。因此，帶狀態的函數對象總是優於帶靜態變量的普通函數。notifier 類並不關心這是不是函數對象，只要符合要求就可以接受。以下更新的例子示範了它如何使用。

int main() {
  notifier n;
  n.add_observer(&print_new_value);
  n.add_observer(&interested_in_the_change);
  n.add_observer(knows_the_previous_value());

  n.change_value(42);
  std::cout << ‘/n‘;
  n.change_value(30);
}

關鍵一點要註意的是，我們新增的一個觀察者不是函數指針，而是一個 knows_the_previous_value 函數對象的實例。運行這段程序的輸出如下：

The value has been updated and is now 42
Ah, the value has changed.
This is the first change of value, so I don‘t know the previous one.

The value has been updated and is now 30
Ah, the value has changed.
Previous value was 42

在這裏最大的優點不是放寬了對函數的要求(或者說，增加了對函數對象的支持)，而是我們可以使用帶狀態的對象，這是非常需要的。我們對 notifier 類所做的修改非常簡單，而且用戶代碼不受影響。如上所示，把 Boost.Function 引入一個已有的設計中是非常容易的。

類成員函數

Boost.Function 不支持參數綁定，這在每次調用一個 function 就要調用同一個類實例的成員函數時是需要的。幸運的是，如果這個類實例被傳遞給 function 的話，我們就可以直接調用它的成員函數。這個 function 的簽名必須包含類的類型以及成員函數的簽名。換言之，顯式傳入的類實例要作為隱式的第一個參數，this。這樣就得到了一個在給出的對象上調用成員函數的函數對象。看一下以下這個類：

class some_class {
public:
  void do_stuff(int i) const {
    std::cout << "OK. Stuff is done. " << i << ‘/n‘;
  }
};

成員函數 do_stuff 要從一個 boost::function 實例裏被調用。要做到這一點，我們需要 function 接受一個 some_class 實例，簽名的其它部分為一個 void 返回以及一個 int 參數。對於如何把 some_class 實例傳給 function，我們有三種選擇：傳值，傳引用，或者傳址。如何要傳值，代碼就應該這樣寫^[4]

^[4] 很少會有理由來以傳值的方式傳遞對象參數。

boost::function<void(some_class,int)> f;

註意，返回類型仍舊在最開始，後跟成員函數所在的類，最後是成員函數的參數類型。它就象傳遞一個 this 給一個函數，該函數暗地裏用類實例調用一個非成員函數。要把函數 f 配置為成員函數 do_stuff, 然後調用它，我們這樣寫：

f=&some_class::do_stuff;
f(some_class(),2);

如果要傳引用，我們要改一下函數的簽名，並傳遞一個 some_class 實例。

boost::function<void(some_class&,int)> f;
f=&some_class::do_stuff;
some_class s;
f(s,1);

最後，如果要傳 some_class 的指針^[5]，我們就要這樣寫：

^[5] 裸指針或智能指針皆可。

boost::function<void(some_class*,int)> f;
f=&some_class::do_stuff;
some_class s;
f(&s,3);

好了，所有這些傳遞"虛擬 this"實例的方法都已經在庫中提供。當然，這種技術也是有限制的：你必須顯式地傳遞類實例；而理想上，你更願意這個實例被綁定在函數中。乍一看，這似乎是 Boost.Function 的缺點，但有別的庫可以支持參數的綁定，如 Boost.Bind 和 Boost.Lambda. 我們將在本章稍後的地方示範這些庫會給 Boost.Function 帶有什麽好處。

帶狀態的函數對象

我們已經看到，由於支持了函數對象，就可以給回調函數增加狀態。考慮這樣一個類，keeping_state, 它是一個帶狀態的函數對象。keeping_state 的實例記錄一個總和，它在每次調用操作符執行時被增加。現在，將該類的一個實例用於兩個 boost::function 實例，結果有些出人意外。

#include <iostream>
#include "boost/function.hpp"

class keeping_state {
  int total_;
public:
  keeping_state():total_(0) {}

  int operator()(int i) {
    total_+=i;
    return total_;
  }

  int total() const {
    return total_;
  }
};

int main() {
  keeping_state ks;
  boost::function<int(int)> f1;
  f1=ks;

  boost::function<int(int)> f2;
  f2=ks;

  std::cout << "The current total is " << f1(10) << ‘/n‘;
  std::cout << "The current total is " << f2(10) << ‘/n‘;
  std::cout << "After adding 10 two times, the total is " 
    << ks.total() << ‘/n‘;
}

寫完這段代碼並接著執行它，程序員可能期望保存在 ks 的總和是20，但不是；事實上，總和為0。以下是這段程序的運行結果。

The current total is 10
The current total is 10
After adding 10 two times, the total is 0

原因是每一個 function 實例(f1 和 f2)都含有一個 ks 的拷貝，這兩個實例得到的總和都是10，但 ks 沒有變化。這可能是也可能不是你想要的，但是記住，boost::function 的缺省行為是復制它要調用的函數對象，這一點很重要。如果這導致不正確的語義，或者如果某些函數對象的復制代價太高，你就必須把函數對象包裝在 boost::reference_wrapper 中，那樣 boost::function 的復制就會是一個 boost::reference_wrapper 的拷貝，它恰好持有一個到原始函數對象的引用。你無須直接使用 boost::reference_wrapper ，你可以使用另兩個助手函數，ref 和 cref。這兩函數返回一個持有到某特定類型的引用或 const 引用的 reference_wrapper。在前例中，要獲得我們想要的語義，即使用同一個 keeping_state 實例，我們就需要把代碼修改如下：

int main() {
  keeping_state ks;
  boost::function<int(int)> f1;
  f1=boost::ref(ks);

  boost::function<int(int)> f2;
  f2=boost::ref(ks);

  std::cout << "The current total is " << f1(10) << ‘/n‘;
  std::cout << "The current total is " << f2(10) << ‘/n‘;
  std::cout << "After adding 10 two times, the total is " 
    << ks.total() << ‘/n‘;
}

boost::ref 的用途是通知 boost::function，我們想保存一個到函數對象的引用，而不是一個拷貝。運行這個程序有以下輸出：

The current total is 10
The current total is 20
After adding 10 two times, the total is 20

這正是我們想要的結果。使用 boost::ref 和 boost::cref 的不同之處就象引用與 const 引用的差異，對於後者，你只能調用其中的常量成員函數。以下例子使用一個名為 something_else 的函數對象，它有一個 const 的調用操作符。

class something_else {
public:
  void operator()() const {
    std::cout << "This works with boost::cref/n";
  }
};

對於這個函數對象，我們可以使用 boost::ref 或 boost::cref.

something_else s;
boost::function0<void> f1;
f1=boost::ref(s);
f1();
boost::function0<void> f2;
f2=boost::cref(s);
f2();

如果我們改變了 something_else 的實現，使其函數為非const, 則只有 boost::ref 可以使用，而 boost::cref 將導致一個編譯期錯誤。

class something_else {
public:
  void operator()() {
    std::cout << 
      "This works only with boost::ref, or copies/n";
  }
};

something_else s;
boost::function0<void> f1;
f1=boost::ref(s); // This still works
f1(); 
boost::function0<void> f2;
f2=boost::cref(s); // This doesn‘t work; 
                   // the function call operator is not const
f2();

如果一個 function 包含一個被 boost::reference_wrapper 所包裝的函數對象，那麽復制構造函數與賦值操作就會復制該引用，即 function 的拷貝將引向原先的函數對象。

int main() {
  keeping_state ks;
  boost::function1<int,int> f1;  // 譯註：原文為boost::function<int,int> f1，有誤
  f1=boost::ref(ks);

  boost::function1<int,int> f2(f1);  // 譯註：原文為boost::function<int,int> f2(f1)，有誤 
  boost::function1<short,short> f3;  // 譯註：原文為boost::function<short,short> f3，有誤 
  f3=f1;

  std::cout << "The current total is " << f1(10) << ‘/n‘;
  std::cout << "The current total is " << f2(10) << ‘/n‘;
  std::cout << "The current total is " << f3(10) << ‘/n‘;
  std::cout << "After adding 10 three times, the total is " 
    << ks.total() << ‘/n‘;
}

這等同於使用 boost::ref 並把函數對象 ks 賦給每一個 function 實例。

給回調函數增加狀態，可以發揮巨大的能力，這也正是使用 Boost.Function 與使用函數對象相比具有的非常突出的優點。

與 Boost.Function 一起使用 Boost.Bind

當我們把 Boost.Function 與某個支持參數綁定的庫結合起來使用時，事情變得更為有趣。Boost.Bind 為普通函數、成員函數以及成員變量提供參數綁定。這非常適合於 Boost.Function, 我們常常需要這類綁定，由於我們使用的類本身並不是函數對象。那麽，我們用 Boost.Bind 把它們轉變為函數對象，然後我們可以用 Boost.Function 來保存它們並稍後調用。在將圖形用戶界面(GUIs)與如何響應用戶的操作進行分離時，幾乎總是要使用某種回調方法。如果這種回調機制是基於函數指針的，就很難避免對可以使用回調的類型的某些限制，也就增加了界面表現與業務邏輯之間的耦合風險。通過使用 Boost.Function，我們可以避免這些事情，並且當與某個支持參數綁定的庫結合使用時，我們可以輕而易舉地把上下文提供給調用的函數。這是本庫最常見的用途之一，把業務邏輯即從表示層分離出來。

以下例子包含一個藝術級的磁帶錄音機，定義如下：

class tape_recorder {
public:
  void play() {
    std::cout << "Since my baby left me.../n";
  }

  void stop() {
    std::cout << "OK, taking a break/n";
  }

  void forward() {
    std::cout << "whizzz/n";
  }

  void rewind() {
    std::cout << "zzzihw/n";
  }

  void record(const std::string& sound) {
    std::cout << "Recorded: " << sound << ‘/n‘;
  }
};

這個磁帶錄音機可以從一個GUI進行控制，或者也可能從一個腳本客戶端進行控制，或者從別的源進行控制，這意味著我們不想把這些函數的執行與它們的實現耦合起來。建立這種分離的一個常用的方法是，用專門的對象負責執行命令，而讓客戶對命令如何執行毫無所知。這也被稱為命令模式(Command pattern)，並且在它非常有用。這種模式的特定實現中的一個問題是，需要為每個命令創建單獨的類。以下片斷示範了它看起來是個什麽樣子：

class command_base {
public:
  virtual bool enabled() const=0;
  virtual void execute()=0;

  virtual ~command_base() {}
};

class play_command : public command_base {
  tape_recorder* p_;
public:
  play_command(tape_recorder* p):p_(p) {}

  bool enabled() const {
    return true;
  }

  void execute() {
    p_->play();
  }
};

class stop_command : public command_base {
  tape_recorder* p_;
public:
  stop_command(tape_recorder* p):p_(p) {}

  bool enabled() const {
    return true;
  }

  void execute() {
    p_->stop();
  }
};

這並不是一個非常吸引的方案，因為它使得代碼膨脹，有許多簡單的命令類，而它們只是簡單地負責調用一個對象的單個成員函數。有時候，這是必需的，因為這些命令可能需要實現業務邏輯和調用函數，但通常它只是由於我們所使用的工具有所限制而已。這些命令類可以這樣使用：

int main() {
  tape_recorder tr;

  // 使用命令模式
  command_base* pPlay=new play_command(&tr);
  command_base* pStop=new stop_command(&tr);

  // 在按下某個按鈕時調用
  pPlay->execute();
  pStop->execute();

  delete pPlay;
  delete pStop;
}

現在，不用再創建額外的具體的命令類，如果我們實現的命令都是調用一個返回 void 且沒有參數(先暫時忽略函數 record, 它帶有一個參數)的成員函數的話，我們可以來點泛化。不用再創建一組具體的命令，我們可以在類中保存一個指向正確成員函數的指針。這是邁向正確方向^[6]的一大步，就象這樣：

^[6] 雖然損失了一點效率。

class tape_recorder_command : public command_base {
  void (tape_recorder::*func_)(); 
  tape_recorder* p_;
public:

  tape_recorder_command(
    tape_recorder* p,
    void (tape_recorder::*func)()) : p_(p),func_(func) {}

  bool enabled() const {
    return true;
  }

  void execute() {
    (p_->*func_)();
  }
};

這個命令模式的實現要好多了，因為它不需要我們再創建一組完成相同事情的獨立的類。這裏的不同在於我們保存了一個 tape_recorder 成員函數指針在 func_ 中，它要在構造函數中提供。命令的執行部分可能並不是你要展現給你的朋友看的東西，因為成員指針操作符對於一些人來說可能還不太熟悉。但是，這可以被看為一個低層的實現細節，所以還算好。有了這個類，我們可以進行泛化處理，不再需要實現單獨的命令類。

int main() {
  tape_recorder tr;

  // 使用改進的命令模式
  command_base* pPlay=
    new tape_recorder_command(&tr,&tape_recorder::play);
  command_base* pStop=
    new tape_recorder_command(&tr,&tape_recorder::stop);

  // 從一個GUI或一個腳本客戶端進行調用
  pPlay->execute();
  pStop->execute();

  delete pPlay;
  delete pStop;
}

你可能還沒有理解，我們已經在開始實現一個簡單的 boost::function 版本，它已經可以做到我們想要的。不要重復發明輪子，讓我們重點關註手邊的工作：分離調用與實現。以下是一個全新實現的 command 類，它更容易編寫、維護以及理解。

class command {
  boost::function<void()> f_;
public:
  command() {}
  command(boost::function<void()> f):f_(f) {}

  void execute() {
    if (f_) {
      f_();
    }
  }

  template <typename Func> void set_function(Func f) {
    f_=f;
  }

  bool enabled() const {
    return f_;
  }
};

通過使用 Boost.Function，我們可以立即從同時兼容函數和函數對象——包括由綁定器生成的函數對象——的靈活性之中獲益。這個 command 類把函數保存在一個返回 void 且不接受參數的 boost::function 中。為了讓這個類更加靈活，我們提供了在運行期修改函數對象的方法，使用一個泛型的成員函數，set_function.

template <typename Func> void set_function(Func f) {
  f_=f;
}

通過使用泛型方法，任何函數、函數對象，或者綁定器都兼容於我們的 command 類。我們也可以選擇把 boost:: function 作為參數，並使用 function 的轉型構造函數來達到同樣的效果。這個 command 類非常通用，我們可以把它用於我們的 tape_recorder 類或者別的地方。與前面的使用一個基類與多個具體派生類(在那裏我們使用指針來實現多態的行為)的方法相比，還有一個額外的優點就是，它更容易管理生存期問題，我們不再需要刪除命令對象，它們可以按值傳遞和保存。我們在布爾上下文中使用 function f_ 來測試命令是否可用。如果函數不包含一個目標，即一個函數或函數對象，它將返回 false, 這意味著我們不能調用它。這個測試在 execute 的實現中進行。以下是使用我們這個新類的一個例子：

int main() {
  tape_recorder tr;

  command play(boost::bind(&tape_recorder::play,&tr));
  command stop(boost::bind(&tape_recorder::stop,&tr));
  command forward(boost::bind(&tape_recorder::stop,&tr));
  command rewind(boost::bind(&tape_recorder::rewind,&tr));
  command record;

  // 從某些GUI控制中調用...
  if (play.enabled()) {
    play.execute();
  }

  // 從某些腳本客戶端調用...
  stop.execute();

  // Some inspired songwriter has passed some lyrics
  std::string s="What a beautiful morning...";
  record.set_function(
    boost::bind(&tape_recorder::record,&tr,s));
  record.execute();
}

為了創建一個具體的命令，我們使用 Boost.Bind 來創建函數對象，當通過這些對象的調用操作符進行調用時，就會調用正確的 tape_recorder 成員函數。這些函數對象是自完備的；它們無參函數對象，即它們可以直接調用，無須傳入參數，這正是 boost::function<void()> 所表示的。換言之，以下代碼片斷創建了一個函數對象，它在配置好的 tape_recorder 實例上調用成員函數 play 。

boost::bind(&tape_recorder::play,&tr)

通常，我們不能保存 bind 所返回的函數對象，但由於 Boost.Function 兼容於任何函數對象，所以它可以。

boost::function<void()> f(boost::bind(&tape_recorder::play,&tr));

註意，這個類也支持調用 record, 它帶有一個類型為 const std::string& 的參數，這是由於成員函數 set_function. 因為這個函數對象必須是無參的，所以我們需要綁定上下文以便 record 仍舊能夠獲得它的參數。當然，這是綁定器的工作。因而，在調用 record 之前，我們創建一個包含被錄音的字符串的函數對象。

std::string s="What a beautiful morning...";
record.set_function(
  boost::bind(&tape_recorder::record,&tr,s));

執行這個保存在 record 的函數對象，將在 tape_recorder 實例 tr 上執行 tape_recorder::record，並傳入字符串。有了 Boost.Function 和 Boost.Bind, 就可以實現解耦，讓調用代碼對於被調用代碼一無所知。以這種方式結合使用這兩個庫非常有用。你已經在這個 command 類中看到了，現在我們該清理一下了。由於 Boost.Function 的傑出功能，你所需的只是以下代碼：

typedef boost::function<void()> command;

與 Boost.Function 一起使用 Boost.Lambda

與 Boost.Function 兼容於由 Boost.Bind 創建的函數對象一樣，它也支持由 Boost.Lambda 創建的函數對象。你用 Lambda 庫創建的任何函數對象都兼容於相應的 boost::function. 我們在前一節已經討論了基於綁定的一些內容，使用 Boost.Lambda 的主要不同之處是它能做得更多。我們可以輕易地創建一些小的、無名的函數，並把它們保存在 boost::function 實例中以用於後續的調用。我們已經在前一章中討論了 lambda 表達式，在那一章的所有例子中所創建的函數對象都可以保存在一個 function 實例中。function 與創建函數對象的庫的結合使用會非常強大。

代價的考慮

有一句諺語說，世界上沒有免費的午餐，對於 Boost.Function 來說也是如此。與使用函數指針相比，使用 Boost.Function 也有一些缺點，特別是對象大小的增加。顯然，一個函數指針只占用一個函數指針的空間大小(這當然了！)，而一個 boost::function實例占的空間有三倍大。如果需要大量的回調函數，這可能會成為一個問題。函數指針在調用時的效率也稍高一些，因為函數指針是被直接調用的，而 Boost.Function 可能需要使用兩次函數指針的調用。最後，可能在某些需要與C庫保持後向兼容的情形下，只能使用函數指針。

雖然 Boost.Function 可能存在這些缺點，但是通常它們都不是什麽實際問題。額外增加的大小非常小，而且(可能存在的)額外的函數指針調用所帶來的代價與真正執行目標函數所花費的時間相比通常都是非常小的。要求使用函數而不能使用 Boost.Function 的情形非常罕見。使用這個庫所帶來的巨大優點及靈活性顯然超出這些代價。

幕後的細節

至少了解一下這個庫如何工作的基礎知識是非常值得的。我們來看一下保存並調用一個函數指針、一個成員函數指針和一個函數對象這三種情形。這三種情形是不同的。要真正看到 Boost.Function 如何工作，只有看源代碼——不過我們的做法有些不同，我們試著搞清楚這些不同的版本究竟在處理方法上有些什麽不同。我們也有一個不同要求的類，即當調用一個成員函數時，必須傳遞一個實例的指針給 function1 (這是我們的類的名字)的構造函數。function1 支持只有一個參數的函數。與 Boost.Function 相比一個較為寬松的投條件是，即使是對於成員函數，也只需要提供返回類型和參數類型。這個要求的直接結果就是，構造函數必須被傳入一個類的實例用於成員函數的調用(類型可以自動推斷)。

我們將要采用的方法是，創建一個泛型基類，它聲明了一個虛擬的調用操作符函數；然後，從這個基類派生三個類，分別支持三種不同形式的函數調用。這些類負責所有的工作，而另一個類，function1, 依據其構造函數的參數來決定實例化哪一個具體類。以下是調用器的基類，invoker_base.

template <typename R, typename Arg> class invoker_base {
public:
  virtual R operator()(Arg arg)=0;
};

接著，我們開始定義 function_ptr_invoker, 它是一個具體調用器，公有派生自 invoker_base. 它的目的是調用普通函數。這個類也接受兩個類型，即返回類型和參數類型，它們被用於構造函數，構造函數接受一個函數指針作為參數。

template <typename R, typename Arg> class function_ptr_invoker 
  : public invoker_base<R,Arg> {
  R (*func_)(Arg);
public:
  function_ptr_invoker(R (*func)(Arg)):func_(func) {}

  R operator()(Arg arg) {
    return (func_)(arg);
  }
};

這個類模板可用於調用任意一個接受一個參數的普通函數。調用操作符簡單地以給定的參數調用保存在 func_ 中的函數。請註意(的確有些奇怪)聲明一個保存函數指針的變量的那行代碼。

R (*func_)(Arg);

你也可以用一個 typedef 來讓它好讀一些。

typedef R (*FunctionT)(Arg);
FunctionT func_;

接著，我們需要一個可以處理成員函數調用的類模板。記住，它要求在構造時給出一個類實例的指針，這一點與 Boost.Function 的做法不一樣。這樣可以節省我們的打字，因為是編譯器而不是程序員來推導這個類。

template <typename R, typename Arg, typename T> 
class member_ptr_invoker : 
  public invoker_base<R,Arg> {
  R (T::*func_)(Arg);
  T* t_;
public:
  member_ptr_invoker(R (T::*func)(Arg),T* t)
    :func_(func),t_(t) {}

  R operator()(Arg arg) {
    return (t_->*func_)(arg);
  }
};

這個類模板與普通函數指針的那個版本很相似。它與前一個版本的不同在於，構造函數保存了一個成員函數指針與一個對象指針，而調用操作符則在該對象(t_)上調用該成員函數(func_)。

最後，我們需要一個兼容函數對象的版本。這是所有實現中最容易的一個，至少在我們的方法中是這樣。通過使用單個模板參數，我們只表明類型 T 必須是一個真正的函數對象，因為我們想要調用它。說得夠多了。

template <typename R, typename Arg, typename T> 
class function_object_invoker : 
  public invoker_base<R,Arg> {
  T t_;
public:
  function_object_invoker(T t):t_(t) {}

  R operator()(Arg arg) {
    return t_(arg);
  }
};

現在我們已經有了這些適用的積木，剩下來的就是把它們放在一起組成我們的自己的 boost::function, 即 function1 類。我們想要一種辦法來發現要實例化哪一個調用器。然後我們可以把它存入一個 invoker_base 指針。這裏的竊門就是，提供一些構造函數，它們有能力去檢查對於給出的參數，哪種調用器是正確的。這僅僅是重載而已，用了一點點手法，包括泛化兩個構造函數。

template <typename R, typename Arg> class function1 {
  invoker_base<R,Arg>* invoker_;
public:
  function1(R (*func)(Arg)) : 
  invoker_(new function_ptr_invoker<R,Arg>(func)) {}

  template <typename T> function1(R (T::*func)(Arg),T* p) : 
    invoker_(new member_ptr_invoker<R,Arg,T>(func,p)) {}

  template <typename T> function1(T t) : 
    invoker_(new function_object_invoker<R,Arg,T>(t)) {}

  R operator()(Arg arg) {
    return (*invoker_)(arg);
  }

  ~function1() {
    delete invoker_;
  }
};

如你所見，這裏面最難的部分是正確地定義出推導系統以支持函數指針、類成員函數以及函數對象。無論使用何種設計來實現這類功能的庫，這都是必須的。最後，給出一些例子來測試我們這個方案。

bool some_function(const std::string& s) {
  std::cout << s << " This is really neat/n";
  return true;
}

class some_class {
public:
  bool some_function(const std::string& s) {
    std::cout << s << " This is also quite nice/n";
    return true;
  }
};

class some_function_object {
public:
  bool operator()(const std::string& s) {
    std::cout << s << 
      " This should work, too, in a flexible solution/n";
    return true;
  }
};

我們的 function1 類可以接受以下所有函數。

int main() {
  function1<bool,const std::string&> f1(&some_function);
  f1(std::string("Hello"));

  some_class s;
  function1<bool,const std::string&> 
    f2(&some_class::some_function,&s);

  f2(std::string("Hello"));

  function1<bool,const std::string&>
    f3(boost::bind(&some_class::some_function,&s,_1));

  f3(std::string("Hello"));

  some_function_object fso;
  function1<bool,const std::string&> 
    f4(fso);
  f4(std::string("Hello"));
}

它也可以使用象 Boost.Bind 和 Boost.Lambda 這樣的 binder 庫所返回的函數對象。我們的類與 Boost.Function 中的類相比要簡單多了，但是也已經足以看出創建和使用這樣一個庫的問題以及相關解決方法。知道一點關於一個庫是如何實現的事情，對於有效使用這個庫是非常有用的。

boost::function用法詳解

另一個功能構造函數要求 first 不同類 blank 吸引指向要開始使用 Boost.Function, 就要包含頭文件 "boost/function.hpp", 或者某個帶數字的版本，從 "boost/function/function0.hpp" 到 "b

boost::function用法詳解

回調的基礎

類成員函數

帶狀態的函數對象

與 Boost.Function 一起使用 Boost.Bind

與 Boost.Function 一起使用 Boost.Lambda

代價的考慮

幕後的細節

boost::function用法詳解

boost::algorithm用法詳解之字符串關系判斷

Boost.Lambda 用法詳解（一）

boost::algorithm用法詳解之字串關係判斷

boost::bind()函式的用法詳解

JavaScript中return的用法詳解

SVN trunk(主線) branch(分支) tag(標記) 用法詳解和詳細操作步驟

js 定時器用法詳解——setTimeout()、setInterval()、clearTimeout()、clearInterval()

selenium用法詳解

C# ListView用法詳解

linux cp命令參數及用法詳解---linux 復制文件命令cp

Python數據類型方法簡介一————字符串的用法詳解

C# ListView用法詳解（轉）

java中的instanceof用法詳解

@RequestMapping 用法詳解

Css中路徑data:image/png;base64的用法詳解 (轉載)

global用法詳解

java中靜態代碼塊的用法—— static用法詳解

<!CDATA[]]用法詳解

Es6 Promise 用法詳解

boost::function用法詳解

回調的基礎

類成員函數

帶狀態的函數對象

與 Boost.Function 一起使用 Boost.Bind

與 Boost.Function 一起使用 Boost.Lambda

代價的考慮

幕後的細節

相關推薦