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数组的常量引用”，字符串字面量（实际上是数组字面量）也适用此规则。因此，它不会返回一对指针，而是尝试返回一对数组，由于数组类型不可复制构造，因此代码无法编译。一种解决方案是将参数显式转换为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 的一部分来处理这种情况。

请注意，fill 的函数参数不是用call_traits表示的：这样做会阻止模板参数推导的正常运行。fill 充当“瘦包装器”，用于执行模板参数推导，编译器将完全优化对 fill 的调用，将其替换为对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]>;
}