Boost C++ 函式庫

以下的類別是一個簡單的類別，它透過值來儲存某種類型 T (請參閱 call_traits_test.cpp 檔案)。目的是要說明如何使用每個可用的 call_traits typedef。

template <class T>
struct contained
{
   // define our typedefs first, arrays are stored by value
   // so value_type is not the same as result_type:
   typedef typename boost::call_traits<T>::param_type       param_type;
   typedef typename boost::call_traits<T>::reference        reference;
   typedef typename boost::call_traits<T>::const_reference  const_reference;
   typedef T                                                value_type;
   typedef typename boost::call_traits<T>::value_type       result_type;

   // stored value:
   value_type v_;

   // constructors:
   contained() {}
   contained(param_type p) : v_(p){}
   // return byval:
   result_type value() { return v_; }
   // return by_ref:
   reference get() { return v_; }
   const_reference const_get()const { return v_; }
   // pass value:
   void call(param_type p){}

};

考慮 std::binder1st 的定義

template <class Operation>
class binder1st :
   public std::unary_function<typename Operation::second_argument_type, typename Operation::result_type>
{
protected:
   Operation op;
   typename Operation::first_argument_type value;
public:
   binder1st(const Operation& x, const typename Operation::first_argument_type& y);
   typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const;
};

現在考慮以下相對常見的情況：函式物件將其第二個參數作為參考，這表示 Operation::second_argument_type 是一個參考類型，operator() 現在將會以「參考到參考」作為參數，而這目前是不合法的。這裡的解決方案是修改 operator() 以使用 call_traits

typename Operation::result_type operator()(typename call_traits<typename Operation::second_argument_type>::param_type x) const;

現在，在 Operation::second_argument_type 是參考類型的情況下，參數會以參考方式傳遞，並且不會發生「參考到參考」的情況。

如果我們將陣列的名稱作為 std::make_pair 的一個 (或兩個) 參數傳遞，則範本引數推導會將傳遞的參數推導為「T 的陣列的 const 參考」，這也適用於字串文字 (實際上是陣列文字)。因此，它不是傳回一對指標，而是嘗試傳回一對陣列，並且由於陣列類型不可複製建構，因此程式碼無法編譯。一種解決方案是將 std::make_pair 的引數明確地轉換為指標，但 call_traits 提供了一個更好的自動解決方案，即使在泛型程式碼中 (其中轉換可能會做錯事) 也能安全地運作。

template <class T1, class T2>
std::pair<
   typename boost::call_traits<T1>::value_type,
   typename boost::call_traits<T2>::value_type>
      make_pair(const T1& t1, const T2& t2)
{
   return std::pair<
      typename boost::call_traits<T1>::value_type,
      typename boost::call_traits<T2>::value_type>(t1, t2);
}

在這裡，如果推導的類型是陣列，則推導的引數類型將自動降級為指標，標準的繫結器和配接器中也會發生類似的情況：原則上，在任何「包裝」推導出類型的暫時物件的函式中。請注意，std::make_pair 的函式引數並非以 call_traits 表示：這樣做會阻止範本引數推導運作。

call_traits 範本將「最佳化」以函式參數形式傳遞的小型內建類型。這主要在參數在迴圈主體內使用時才會產生影響。

在以下範例中 (請參閱 fill_example.cpp)，std::fill 的一個版本透過兩種方式進行最佳化：如果傳遞的類型是單一位元組內建類型，則使用 std::memset 來執行填入；否則，會使用傳統的 C++ 實作，但是會使用 call_traits「最佳化」傳遞的參數。

template <bool opt>
struct filler
{
   template <typename I, typename T>
   static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val)
   {
      while(first != last)
      {
         *first = val;
         ++first;
      }
   }
};

template <>
struct filler<true>
{
   template <typename I, typename T>
   static void do_fill(I first, I last, T val)
   {
      std::memset(first, val, last-first);
   }
};

template <class I, class T>
inline void fill(I first, I last, const T& val)
{
   enum { can_opt = boost::is_pointer<I>::value
                   && boost::is_arithmetic<T>::value
                   && (sizeof(T) == 1) };
   typedef filler<can_opt> filler_t;
   filler_t::template do_fill<I,T>(first, last, val);
}

對於小型內建類型而言，之所以「最佳化」的原因是，以 T const 而非 const T& 形式傳遞值時，編譯器可以判斷該值是常數且沒有別名。透過此資訊，編譯器能夠將傳遞的值快取在暫存器中、展開迴圈，或使用明確的平行指令：如果支援任何這些指令。從這裡獲得多少效能取決於您的編譯器 - 我們真的很需要一些精確的效能評測軟體來作為 boost 的一部分，以應對這種情況。

請注意，填入的函式引數並非以 call_traits 表示：這樣做會阻止範本引數推導運作。相反地，填入充當一個「薄包裝函式」，旨在執行範本引數推導，編譯器會完全最佳化掉對填入的呼叫，並將其替換為對 filler<>::do_fill 的呼叫，而該呼叫會使用 call_traits。

namespace boost {
  template<typename T> struct call_traits;

  template<typename T, std::size_t N> struct call_traits<const T[N]>;
  template<typename T> struct call_traits<T &>;
  template<typename T, std::size_t N> struct call_traits<T[N]>;
}