Calling a single slot from a signal isn't very interesting, sowe can make the Hello, World program more interesting by splittingthe work of printing "Hello, World!" into two completely separateslots. The first slot will print "Hello" and may look likethis:

從信號(hào)調(diào)用單個(gè)插槽不是很有意思，因此我們將打印“Hello, World!”的工作拆分到兩個(gè)完全獨(dú)立的插槽，讓 Hello, World 程序更有趣點(diǎn)。第一個(gè)插槽將打印“Hello”，可能看起來(lái)像這樣：

struct Hello 
{
  void operator()() const
  {
    std::cout << "Hello";
  }
};

The second slot will print ", World!" and a newline, to completethe program. The second slot may look like this:

第二個(gè)插槽將打印“, World!”并回車以完成該程序。第二個(gè)插槽可能看起來(lái)像這樣：

struct World
{
  void operator()() const
  {
    std::cout << ", World!" << std::endl;
  }
};

Like in our previous example, we can create a signalsig that takes no arguments and has avoid return value. This time, we connect both ahello and a world slot to the samesignal, and when we call the signal both slots will be called.

就像我們的上個(gè)例子，我們創(chuàng)建信號(hào)sig，它沒有參數(shù)并且返回值為void。這次，我們將hello和 world插槽都連接到同一個(gè)信號(hào)，當(dāng)我們調(diào)用該信號(hào)，兩個(gè)插槽都將會(huì)被調(diào)用。

boost::signal<void ()> sig;

sig.connect(Hello());
sig.connect(World());

sig();

boost::signal0<void> sig;

sig.connect(Hello());
sig.connect(World());

sig();

By default, slots are called in first-in first-out (FIFO) order,so the output of this program will be as expected:

默認(rèn)情況下，插槽以先進(jìn)先出（FIFO）的次序被調(diào)用，因此該程序的輸出應(yīng)該是：

Hello, World!

Slots are free to have side effects, and that can mean that someslots will have to be called before others even if they are not connected in that order. The Boost.Signalslibrary allows slots to be placed into groups that are ordered insome way. For our Hello, World program, we want "Hello" to beprinted before ", World!", so we put "Hello" into a group that mustbe executed before the group that ", World!" is in. To do this, wecan supply an extra parameter at the beginning of theconnect call that specifies the group. Group valuesare, by default, ints, and are ordered by the integer< relation. Here's how we construct Hello, World:

插槽可以隨意具有副作用，即某些插槽必須在另一些之前調(diào)用，即使它們不是按那個(gè)次序連接的。Boost.Signals 庫(kù)允許插槽被置于按某種方式排序的編組中。對(duì)于我們的 Hello, World 程序，我們要“Hello”在“, World!”之前打印，所以我們將“Hello”放入一個(gè)組，該組將在“, World!”所在組之前執(zhí)行。為了做到這一點(diǎn)，我們可以在connect調(diào)用的頭部提供一個(gè)額外的參數(shù)，以指定該組。編組的值默認(rèn)為int，并按整型的 < 關(guān)系排序。我們這樣構(gòu)造 Hello, World：

boost::signal<void ()> sig;
sig.connect(1, World());
sig.connect(0, Hello());
sig();

boost::signal0<void> sig;
sig.connect(1, World());
sig.connect(0, Hello());
sig();

This program will correctly print "Hello, World!", because theHello object is in group 0, which precedes group 1 wherethe World object resides. The groupparameter is, in fact, optional. We omitted it in the first Hello,World example because it was unnecessary when all of the slots areindependent. So what happens if we mix calls to connect that use thegroup parameter and those that don't? The "unnamed" slots (i.e., thosethat have been connected without specifying a group name) can beplaced at the front or back of the slot list (by passingboost::signals::at_front or boost::signals::at_backas the last parameter to connect, respectively), and defaults to the end of the list. Whena group is specified, the final parameter describes where the slotwill be placed within the group ordering. If we add a new slotto our example like this:

該程序?qū)⒄_打印出“Hello, World!”，因?yàn)?code class="computeroutput">Hello 對(duì)象在組 0，它在World 對(duì)象所在的組 1 之前。編組參數(shù)實(shí)際上是可選的。在第一個(gè) Hello World 例子中我們省略了它，因?yàn)楫?dāng)所有的插槽都獨(dú)立時(shí)，編組是不必要的。那么，如果我們混合調(diào)用使用和不使用編組參數(shù)的連接會(huì)怎樣？“未命名”插槽（即那些連接 時(shí)未指定組名的插槽）可置于插槽鏈表的頭部或尾部（通過(guò)向connect分別傳入boost::signals::at_front 或boost::signals::at_back作為最后的參數(shù)），而默認(rèn)為鏈表的結(jié)尾。當(dāng)指定了編組時(shí)，最后的參數(shù)描述的是插槽在組內(nèi)的次序。如果我們?nèi)缦孪蛭覀兊睦犹砑有碌牟宀郏?/p>

struct GoodMorning
{
  void operator()() const
  {
    std::cout << "... and good morning!" << std::endl;
  }
};

sig.connect(GoodMorning());

... we will get the result we wanted:

……我們將得到我們想要的結(jié)果：

Hello, World!
... and good morning!

Signals can propagate arguments to each of the slots they call.For instance, a signal that propagates mouse motion events mightwant to pass along the new mouse coordinates and whether the mousebuttons are pressed.

信號(hào)可以向它們調(diào)用的每個(gè)插槽傳遞參數(shù)。例如，一個(gè)傳遞鼠標(biāo)移動(dòng)事件的信號(hào)可能要傳入新的鼠標(biāo)坐標(biāo)以及是否按了鼠標(biāo)鍵。

As an example, we'll create a signal that passes twofloat arguments to its slots. Then we'll create a fewslots that print the results of various arithmetic operations onthese values.

作為一個(gè)例子，我們將創(chuàng)建一個(gè)信號(hào)，它將傳入兩個(gè)float 參數(shù)到它的插槽。然后我們將創(chuàng)建幾個(gè)插槽，它們將打印對(duì)這兩個(gè)參數(shù)進(jìn)行算術(shù)運(yùn)算的各種結(jié)果。

void print_sum(float x, float y)
{
  std::cout << "The sum is " << x+y << std::endl;
}

void print_product(float x, float y)
{
  std::cout << "The product is " << x*y << std::endl;
}

void print_difference(float x, float y)
{
  std::cout << "The difference is " << x-y << std::endl;
}

void print_quotient(float x, float y)
{
  std::cout << "The quotient is " << x/y << std::endl;
}

boost::signal<void (float, float)> sig;

sig.connect(&print_sum);
sig.connect(&print_product);
sig.connect(&print_difference);
sig.connect(&print_quotient);

sig(5, 3);

boost::signal2<void, float, float> sig;

sig.connect(&print_sum);
sig.connect(&print_product);
sig.connect(&print_difference);
sig.connect(&print_quotient);

sig(5, 3);

This program will print out the following:

該程序?qū)⒋蛴≥敵鋈缦拢?/p>

The sum is 8
The product is 15
The difference is 2
The quotient is 1.66667

So any values that are given to sig when it iscalled like a function are passed to each of the slots. We have todeclare the types of these values up front when we create thesignal. The type boost::signal<void (float,float)> means that the signal has a voidreturn value and takes two float values. Any slotconnected to sig must therefore be able to take twofloat values.

當(dāng)像函數(shù)一樣調(diào)用 sig 時(shí)，輸入它的任何值都傳給了每一個(gè)插槽。創(chuàng)建信號(hào)時(shí)，我們必須預(yù)先聲明這些值的類型。類型 boost::signal<void (float,float)> 表明信號(hào)具有 void返回值并接受兩個(gè) float 值。因此任何連接到sig的插槽都必須能夠接受兩個(gè)float 值。

Just as slots can receive arguments, they can also returnvalues. These values can then be returned back to the caller of thesignal through a combiner. The combiner is a mechanismthat can take the results of calling slots (there many be noresults or a hundred; we don't know until the program runs) andcoalesces them into a single result to be returned to the caller.The single result is often a simple function of the results of theslot calls: the result of the last slot call, the maximum valuereturned by any slot, or a container of all of the results are somepossibilities.

正如插槽可以接收參數(shù)，它們也可以返回值。然后這些值可以通過(guò)合并器（combiner）返 回給信號(hào)的調(diào)用者。合并器是這樣一種工具，它接收插槽調(diào)用的結(jié)果（可能沒有結(jié)果，也可能有100個(gè)結(jié)果；程序運(yùn)行時(shí)才知道），并且把它們合并成單一的結(jié)果 返回給調(diào)用者。該單一的結(jié)果往往是插槽調(diào)用結(jié)果的一個(gè)簡(jiǎn)單函數(shù)，可能是：最后的插槽調(diào)用的結(jié)果、所有插槽返回值的最大值，或包含所有結(jié)果的容器。

We can modify our previous arithmetic operations exampleslightly so that the slots all return the results of computing theproduct, quotient, sum, or difference. Then the signal itself canreturn a value based on these results to be printed:

我們可以稍微修改前面的算術(shù)運(yùn)算的例子，使插槽分別返回加減乘除的計(jì)算結(jié)果。然后信號(hào)本身就可以根據(jù)這些結(jié)果返回一個(gè)值，并打印出來(lái)。

float product(float x, float y) { return x*y; }
float quotient(float x, float y) { return x/y; }
float sum(float x, float y) { return x+y; }
float difference(float x, float y) { return x-y; }

boost::signal<float (float x, float y)> sig;

sig.connect(&product);
sig.connect(&quotient);
sig.connect(&sum);
sig.connect(&difference);

std::cout << sig(5, 3) << std::endl;

float product(float x, float y) { return x*y; }
float quotient(float x, float y) { return x/y; }
float sum(float x, float y) { return x+y; }
float difference(float x, float y) { return x-y; }

boost::signal2<float, float, float> sig;

sig.connect(&product);
sig.connect(&quotient);
sig.connect(&sum);
sig.connect(&difference);

std::cout << sig(5, 3) << std::endl;

This example program will output 2. This is because thedefault behavior of a signal that has a return type(float, the first template argument given to theboost::signal class template) is to call all slots andthen return the result returned by the last slot called. Thisbehavior is admittedly silly for this example, because slots haveno side effects and the result is the last slot connect.

該例程將輸出 2。這是因?yàn)榫哂蟹祷仡愋停?code class="computeroutput">float，即輸入 boost::signal類模板的第一個(gè)模板參數(shù)）的信號(hào)的默認(rèn)行為是，調(diào)用所有的插槽，然后返回最后一個(gè)被調(diào)用插槽的結(jié)果。對(duì)本例來(lái)說(shuō)，該行為確實(shí)有點(diǎn)傻，因?yàn)檫@些插槽沒有副作用并且結(jié)果就是最后的插槽連接。

A more interesting signal result would be the maximum of thevalues returned by any slot. To do this, we create a customcombiner that looks like this:

一個(gè)更有意思的信號(hào)結(jié)果是，求所有插槽返回值的最大值。為了做到這一點(diǎn)，我們創(chuàng)建了一個(gè)自定義合并器，看起來(lái)像這樣：

template<typename T>
struct maximum
{
  typedef T result_type;

  template<typename InputIterator>
  T operator()(InputIterator first, InputIterator last) const
  {
    // If there are no slots to call, just return the
    // default-constructed value
    if (first == last)
      return T();

    T max_value = *first++;
    while (first != last) {
      if (max_value < *first)
        max_value = *first;
      ++first;
    }
  
    return max_value;
  }
};

The maximum class template acts as a functionobject. Its result type is given by its template parameter, andthis is the type it expects to be computing the maximum based on(e.g., maximum<float> would find the maximumfloat in a sequence of floats). When amaximum object is invoked, it is given an inputiterator sequence [first, last) that includes theresults of calling all of the slots. maximum uses thisinput iterator sequence to calculate the maximum element, andreturns that maximum value.

maximum 類模板就像一個(gè)函數(shù)對(duì)象。它的結(jié)果類型由其模板參數(shù)給出，并且它正是基于該類型計(jì)算最大值（例如，maximum<float>將在一系列 float中查找最大的 float）。當(dāng)調(diào)用maximum 對(duì)象時(shí)，將給出一個(gè)輸入迭代器序列[first, last)，其中包含了所有插槽調(diào)用的結(jié)果。maximum利用該輸入迭代器序列來(lái)計(jì)算最大元素，并返回那個(gè)最大值。

We actually use this new function object type by installing itas a combiner for our signal. The combiner template argumentfollows the signal's calling signature:

我們要把這個(gè)新的函數(shù)對(duì)象作為合并器安裝到我們的信號(hào)，才能實(shí)際使用它。合并器模板參數(shù)跟在信號(hào)的調(diào)用簽名式之后。

boost::signal<float (float x, float y), 
              maximum<float> > sig;

boost::signal2<float, float, float, 
               maximum<float> > sig;

Now we can connect slots that perform arithmetic functions anduse the signal:

現(xiàn)在我們可以連接執(zhí)行算術(shù)功能的插槽并使用信號(hào)了：

sig.connect(&quotient);
sig.connect(&product);
sig.connect(&sum);
sig.connect(&difference);

std::cout << sig(5, 3) << std::endl;

The output of this program will be 15, becauseregardless of the order in which the slots are connected, the productof 5 and 3 will be larger than the quotient, sum, ordifference.

該程序的輸出為 15，因?yàn)椴还懿宀鄣倪B接次序如何，5 和 3 的乘積將大于商、和，或差。

In other cases we might want to return all of the valuescomputed by the slots together, in one large data structure. Thisis easily done with a different combiner:

在其他情況下，我們可能要同時(shí)返回插槽計(jì)算的所有值，如保存在一個(gè)大型的數(shù)據(jù)結(jié)構(gòu)中。這可以用一個(gè)不同的合并器來(lái)輕松完成：

template<typename Container>
struct aggregate_values
{
  typedef Container result_type;

  template<typename InputIterator>
  Container operator()(InputIterator first, InputIterator last) const
  {
    return Container(first, last);
  }
};

Again, we can create a signal with this new combiner:

我們?cè)俅斡眠@個(gè)新的合并器創(chuàng)建信號(hào)：

boost::signal<float (float, float), 
    aggregate_values<std::vector<float> > > sig;

sig.connect(&quotient);
sig.connect(&product);
sig.connect(&sum);
sig.connect(&difference);

std::vector<float> results = sig(5, 3);
std::copy(results.begin(), results.end(), 
    std::ostream_iterator<float>(cout, " "));

boost::signal2<float, float, float,
    aggregate_values<std::vector<float> > > sig;

sig.connect(&quotient);
sig.connect(&product);
sig.connect(&sum);
sig.connect(&difference);

std::vector<float> results = sig(5, 3);
std::copy(results.begin(), results.end(), 
    std::ostream_iterator<float>(cout, " "));

The output of this program will contain 15, 8, 1.6667, and 2. Itis interesting here thatthe first template argument for the signal class,float, is not actually the return type of the signal.Instead, it is the return type used by the connected slots and willalso be the value_type of the input iterators passedto the combiner. The combiner itself is a function object and itsresult_type member type becomes the return type of thesignal.

該程序的輸出將包含 15、8、1.6667，和 2。這里有趣的是，signal類的第一個(gè)模板參數(shù)，float，竟然不是信號(hào)的返回類型。相反，該參數(shù)是所連接插槽的返回類型，并且它也是傳入合并器的輸入迭代器的value_type。合并器本身是個(gè)函數(shù)對(duì)象，并且它的result_type成員類型將成為信號(hào)的返回類型。

The input iterators passed to the combiner transform dereferenceoperations into slot calls. Combiners therefore have the option toinvoke only some slots until some particular criterion is met. Forinstance, in a distributed computing system, the combiner may askeach remote system whether it will handle the request. Only oneremote system needs to handle a particular request, so after aremote system accepts the work we do not want to ask any otherremote systems to perform the same task. Such a combiner need onlycheck the value returned when dereferencing the iterator, andreturn when the value is acceptable. The following combiner returnsthe first non-NULL pointer to a FulfilledRequest datastructure, without asking any later slots to fulfill therequest:

傳給合并器的輸入迭代器會(huì)將解引用操作轉(zhuǎn)換為插槽調(diào)用。因此合并器可選擇僅調(diào)用某些符合特定條件的插槽。例如，在分布計(jì)算系統(tǒng)中，合并器可能會(huì)詢問(wèn) 每個(gè)遠(yuǎn)程系統(tǒng)能否處理請(qǐng)求。對(duì)于一個(gè)特定請(qǐng)求，僅需一個(gè)遠(yuǎn)程系統(tǒng)進(jìn)行處理，因此當(dāng)一個(gè)遠(yuǎn)程系統(tǒng)接受該工作后，我們將不再要求任何其他遠(yuǎn)程系統(tǒng)來(lái)做同一個(gè)任 務(wù)。這樣一個(gè)合并器只需檢查迭代器解引用的返回值，并當(dāng)該值可以接受時(shí)就返回。以下的合并器返回第一個(gè)指向FulfilledRequest數(shù)據(jù)結(jié)構(gòu)的非空指針，而不必要求任何以后的插槽來(lái)完成請(qǐng)求：

struct DistributeRequest {
  typedef FulfilledRequest* result_type;

  template<typename InputIterator>
  result_type operator()(InputIterator first, InputIterator last) const
  {
    while (first != last) {
      if (result_type fulfilled = *first)
        return fulfilled;
      ++first;
    }
    return 0;
  }
};

Slots aren't expected to exist indefinately after they areconnected. Often slots are only used to receive a few events andare then disconnected, and the programmer needs control to decidewhen a slot should no longer be connected.

插槽不要求在它們被連接后無(wú)限期地存在。往往插槽只是用來(lái)接收一些事件然后斷開，而程序員需要控制決定何時(shí)插槽不應(yīng)該再繼續(xù)連接。

The entry point for managing connections explicitly is theboost::signals::connection class. Theconnection class uniquely represents the connectionbetween a particular signal and a particular slot. Theconnected() method checks if the signal and slot arestill connected, and the disconnect() methoddisconnects the signal and slot if they are connected before it iscalled. Each call to the signal's connect() methodreturns a connection object, which can be used to determine if theconnection still exists or to disconnect the signal and slot.

顯式管理連接的入口點(diǎn)是boost::signals::connection 類。connection 類唯一代表了特定信號(hào)與特定插槽之間的連接。connected() 方法檢查信號(hào)與插槽是否仍保持連接，如果信號(hào)與插槽是連接著的，disconnect() 方法斷開它們的連接。每次調(diào)用信號(hào)的 connect() 方法，就返回一個(gè)連接對(duì)象，該對(duì)象用于確定連接是否仍然存在，或者用于斷開信號(hào)和插槽。

boost::signals::connection c = sig.connect(HelloWorld());
if (c.connected()) {
// c is still connected to the signal
  sig(); // Prints "Hello, World!"
}

c.disconnect(); // Disconnect the HelloWorld object
assert(!c.connected()); c isn't connected any more

sig(); // Does nothing: there are no connected slots

Slots can be temporarily "blocked", meaning that they will beignored when the signal is invoked but have not been disconnected. Theblock member functiontemporarily blocks a slot, which can be unblocked viaunblock. Here is an example ofblocking/unblocking slots:

插槽可以被臨時(shí)“阻塞”，即當(dāng)信號(hào)被調(diào)用時(shí)，這些插槽將被忽略，但并沒有被斷開。block 成員函數(shù)臨時(shí)地阻塞一個(gè)插槽，可通過(guò) unblock解除阻塞。這是一個(gè)阻塞/開啟插槽的例子：

boost::signals::connection c = sig.connect(HelloWorld());
sig(); // Prints "Hello, World!"

c.block(); // block the slot
assert(c.blocked());
sig(); // No output: the slot is blocked

c.unblock(); // unblock the slot
sig(); // Prints "Hello, World!"

The boost::signals::scoped_connection classreferences a signal/slot connection that will be disconnected whenthe scoped_connection class goes out of scope. Thisability is useful when a connection need only be temporary,e.g.,

boost::signals::scoped_connection 類引用了一個(gè)信號(hào)/插槽的連接，當(dāng)scoped_connection類出作用域時(shí)，該連接將會(huì)被斷開。當(dāng)僅需臨時(shí)連接時(shí)，該功能很有用，如：

{
  boost::signals::scoped_connection c = sig.connect(ShortLived());
  sig(); // will call ShortLived function object
}
sig(); // ShortLived function object no longer connected to sig

One can disconnect slots that are equivalent to a given functionobject using a form of thedisconnect method, so long asthe type of the function object has an accessible ==operator. For instance:

你可以使用disconnect方法斷開與給定函數(shù)對(duì)象等價(jià)的多個(gè)插槽，只要該函數(shù)對(duì)象的類型具有可訪問(wèn)的==運(yùn)算符。例如：

void foo();
void bar();

signal<void()> sig;

sig.connect(&foo);
sig.connect(&bar);

// disconnects foo, but not bar
sig.disconnect(&foo);

void foo();
void bar();

signal0<void> sig;

sig.connect(&foo);
sig.connect(&bar);

// disconnects foo, but not bar
sig.disconnect(&foo);

Boost.Signals can automatically track the lifetime of objectsinvolved in signal/slot connections, including automaticdisconnection of slots when objects involved in the slot call aredestroyed. For instance, consider a simple news delivery service,where clients connect to a news provider that then sends news toall connected clients as information arrives. The news deliveryservice may be constructed like this:

Boost.Signals 能自動(dòng)跟蹤信號(hào)/插槽連接中所涉及對(duì)象的生命期，包括當(dāng)插槽調(diào)用中涉及的對(duì)象銷毀時(shí)自動(dòng)斷開插槽。例如，考慮一個(gè)簡(jiǎn)單的新聞發(fā)送服務(wù)，其中客戶會(huì)連接到新 聞提供者，而新聞提供者一有信息到達(dá)，就發(fā)送新聞到所有連接的客戶。該新聞發(fā)送服務(wù)可能像這樣構(gòu)造：

class NewsItem { /* ... */ };

boost::signal<void (const NewsItem&)> deliverNews;

class NewsItem { /* ... */ };

boost::signal1<void, const NewsItem&> deliverNews;

Clients that wish to receive news updates need only connect afunction object that can receive news items to thedeliverNews signal. For instance, we may have aspecial message area in our application specifically for news,e.g.,:

希望接收新聞更新的客戶只需連接一個(gè)函數(shù)對(duì)象，該對(duì)象可以接收傳給deliverNews信號(hào)的新聞條目，例如：

struct NewsMessageArea : public MessageArea
{
public:
  // ...

  void displayNews(const NewsItem& news) const
  {
    messageText = news.text();
    update();
  }
};

// ...
NewsMessageArea newsMessageArea = new NewsMessageArea(/* ... */);
// ...
deliverNews.connect(boost::bind(&NewsMessageArea::displayNews, 
                                newsMessageArea, _1));

However, what if the user closes the news message area,destroying the newsMessageArea object thatdeliverNews knows about? Most likely, a segmentationfault will occur. However, with Boost.Signals one need only makeNewsMessageArea trackable, and the slotinvolving newsMessageArea will be disconnected whennewsMessageArea is destroyed. TheNewsMessageArea class is made trackable by derivingpublicly from the boost::signals::trackable class,e.g.:

不過(guò)，如果用戶關(guān)閉新聞?dòng)嵪^(qū)，銷毀了 deliverNews所知的 newsMessageArea 對(duì)象，那會(huì)怎么樣？最有可能的是產(chǎn)生段錯(cuò)誤。然而，你只需在使用 Boost.Signals 時(shí)，讓NewsMessageArea 可跟蹤（trackable），那么當(dāng) newsMessageArea 被銷毀時(shí)，調(diào)用 newsMessageArea 的插槽就會(huì)被斷開。通過(guò)公有繼承自boost::signals::trackable 類，NewsMessageArea 類就會(huì)變成可跟蹤的，例如：

struct NewsMessageArea : public MessageArea, public boost::signals::trackable
{
  // ...
};

At this time there is a significant limitation to the use oftrackable objects in making slot connections: functionobjects built using Boost.Bind are understood, such that pointersor references to trackable objects passed toboost::bind will be found and tracked.

目前，用 trackable 對(duì)象制作插槽連接有個(gè)重要的限制：它理解使用 Boost.Bind 構(gòu)建的函數(shù)對(duì)象，如傳入boost::bind的 trackable 對(duì)象指針或引用將會(huì)被發(fā)現(xiàn)和跟蹤。

Warning: User-defined function objects and functionobjects from other libraries (e.g., Boost.Function or Boost.Lambda)do not implement the required interfaces for trackableobject detection, and will silently ignore any bound trackableobjects. Future versions of the Boost libraries will addressthis limitation.

警告：用戶自定義函數(shù)對(duì)象和來(lái)自其他庫(kù)的函數(shù)對(duì)象（例如來(lái)自 Boost.Function 或 Boost.Lambda），沒有實(shí)現(xiàn)所要求的trackable 對(duì)象檢測(cè)接口，將會(huì)默默地忽略任何綁定的可跟蹤對(duì)象。Boost庫(kù)的未來(lái)版本將會(huì)解除該限制。

Signal/slot disconnections occur when any of these conditionsoccur:

以下任一條件發(fā)生時(shí)，信號(hào)/插槽將斷開：

These events can occur at any time without disrupting a signal'scalling sequence. If a signal/slot connection is disconnected atany time during a signal's calling sequence, the calling sequencewill still continue but will not invoke the disconnected slot.Additionally, a signal may be destroyed while it is in a callingsequence, and which case it will complete its slot call sequencebut may not be accessed directly.

這些事件可以發(fā)生于任何時(shí)間，而不會(huì)破壞信號(hào)的調(diào)用序列。如果信號(hào)/插槽的連接在信號(hào)調(diào)用序列的任意時(shí)刻被斷開，調(diào)用序列仍將繼續(xù)，只是不會(huì)調(diào)用被斷開的插槽。此外，信號(hào)可以在調(diào)用序列中間被銷毀，這時(shí)，它將完成其插槽調(diào)用序列，只是不可以被直接訪問(wèn)。

Signals may be invoked recursively (e.g., a signal A calls aslot B that invokes signal A...). The disconnection behavior doesnot change in the recursive case, except that the slot callingsequence includes slot calls for all nested invocations of thesignal.

信號(hào)可以被遞歸調(diào)用（例如，信號(hào)A調(diào)用插槽B，而插槽B又調(diào)用信號(hào)A……）。遞歸情況下，斷開的行為不會(huì)改變，只是插槽調(diào)用序列包括所有嵌套的信號(hào)調(diào)用。

Slots in the Boost.Signals library are created from arbitraryfunction objects, and therefore have no fixed type. However, it iscommonplace to require that slots be passed through interfaces thatcannot be templates. Slots can be passed via theslot_type for each particular signal type and anyfunction object compatible with the signature of the signal can bepassed to a slot_type parameter. For instance:

Boost.Signals 庫(kù)中的插槽可以從任意的函數(shù)對(duì)象創(chuàng)建，因此沒有固定的類型。不過(guò)通常要求通過(guò)不可模板化的接口傳遞插槽。對(duì)于每個(gè)特定的信號(hào)類型，都可以通過(guò)slot_type傳遞插槽，而與信號(hào)的簽名式兼容的任意函數(shù)對(duì)象，都可以傳給 slot_type 參數(shù)。例如：

class Button 
{
  typedef boost::signal<void (int x, int y)> OnClick;

public:
  void doOnClick(const OnClick::slot_type& slot);

private:
  OnClick onClick;
};

void Button::doOnClick(
      const OnClick::slot_type& slot
    )
{
  onClick.connect(slot);
}

void printCoordinates(long x, long y)
{
  std::cout << "(" << x << ", " << y << ")\n";
}

void f(Button& button)
{
  button.doOnClick(&printCoordinates);
}

class Button 
{
  typedef boost::signal2<void,int,int> OnClick;

public:
  void doOnClick(const OnClick::slot_type& slot);

private:
  OnClick onClick;
};

void Button::doOnClick(
      const OnClick::slot_type& slot
    )
{
  onClick.connect(slot);
}

void printCoordinates(long x, long y)
{
  std::cout << "(" << x << ", " << y << ")\n";
}

void f(Button& button)
{
  button.doOnClick(&printCoordinates);
}

The doOnClick method is now functionally equivalentto the connect method of the onClicksignal, but the details of the doOnClick method can behidden in an implementation detail file.

doOnClick 方法現(xiàn)在功能上等效于onClick 信號(hào)的connect 方法，但是 doOnClick 方法的細(xì)節(jié)可以隱藏于細(xì)節(jié)實(shí)現(xiàn)文件中。