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 的一部分，用于处理此类情况。

请注意，填充的函数参数不是用 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]>;
}