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;
};

现在考虑在 functor 将其第二个参数作为引用的相对常见的情况下会发生什么，这意味着 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]>;
}