5

以下是g++的STL实现（STL的sgi版本）的摘录。我想知道他们为什么使用部分专业化而不是函数重载。

template <class InputIterator, class OutputIterator>
struct __copy_dispatch
{
  OutputIterator operator()(InputIterator first, InputIterator last,
                            OutputIterator result) {
    return __copy(first, last, result, iterator_category(first));
  }
};

//If the inputiterator and the outputiterator is all type T
//This is a partial specialization of the generalized version
template <class T>
struct __copy_dispatch<T*, T*>//-----------------------(1)
{
  T* operator()(T* first, T* last, T* result) {
    typedef typename __type_traits<T>::has_trivial_assignment_operator t; 
    return __copy_t(first, last, result, t());
  }
};

//Strictly speaking this is a partial specialization of the last template function
template <class T>
struct __copy_dispatch<const T*, T*>//-----------------(2)
{
  T* operator()(const T* first, const T* last, T* result) {
    typedef typename __type_traits<T>::has_trivial_assignment_operator t; 
    return __copy_t(first, last, result, t());
  }
};


//The generalized version of copy
template <class InputIterator, class OutputIterator>
inline OutputIterator copy(InputIterator first, InputIterator last,
                           OutputIterator result)
{
  return __copy_dispatch<InputIterator,OutputIterator>()(first, last, result);
}

//A overload version
inline char* copy(const char* first, const char* last, char* result) {
  memmove(result, first, last - first);
  return result + (last - first);
}

如果我使用重载版本，例如：

#include <iostream>

using namespace std;


template <class InputIterator, class OutputIterator>
OutputIterator copy_dispatch(InputIterator first, InputIterator last,
                            OutputIterator result) {
    cout << "now in first" << endl;
    return result;
}
template <class T>
T* copy_dispatch(T* first, T* last, T* result) {
    cout << "now in second" << endl;
    return 0;
}
template <class T>
T* copy_dispatch(const T* first, const T* last, T* result) {
    cout << "now in third" << endl;
    return 0;
}

int main( void ) {
    int a[]={1,2,3,4,5,6};
    double b[] = {1.0,2.0,3.0,4.0,5.0,6.0};
    int c[]={0,0,0,0,0,0};
    int const d[]={0,0,0,0,0,0};

    copy_dispatch(a,a+6, b);
    copy_dispatch(a, a+6, c);
    copy_dispatch(d, d+6, c);

}

输出是：

now in first
now in second
now in third

似乎它也可以正常工作？

那么是否有任何进一步的理由使用具有部分特化的仿函数类而不是函数重载

更新

以下是 STL 的 sgi 实现的一些其他摘录：

//sgi 4.5
template<bool>
struct _Destroy_aux
{
  template<typename _ForwardIterator>
    static void
    __destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      for (; __first != __last; ++__first)
        std::_Destroy(&*__first);
    }
};
 
template<>
struct _Destroy_aux<true>
{
  template<typename _ForwardIterator>
    static void
    __destroy(_ForwardIterator, _ForwardIterator) { }
 
};

//in an old version of sgi 2.9 this is implemented with function overload
template <class ForwardIterator>
inline void
__destroy_aux(ForwardIterator first, ForwardIterator last, __false_type) {
  for ( ; first < last; ++first)
    destroy(&*first);
}
 
template <class ForwardIterator> 
inline void __destroy_aux(ForwardIterator, ForwardIterator, __true_type) {}
 
template <class ForwardIterator, class T>
inline void __destroy(ForwardIterator first, ForwardIterator last, T*) {
  typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;
  __destroy_aux(first, last, trivial_destructor());
4

3 回答 3

3

函数模板特化不参与重载决议，并且类模板不能推导出它们的参数。这导致函数模板重载和普通函数作为部分和显式特化的代理的不规则模式。

为了结合两全其美，大多数通用代码都会执行您在问题中显示的内容

//The generalized version of copy
template <class InputIterator, class OutputIterator>
inline OutputIterator copy(InputIterator first, InputIterator last,
                           OutputIterator result)
{
  return __copy_dispatch<InputIterator,OutputIterator>()(first, last, result);
}

顶级函数模板推导出其参数（帮助用户编写紧凑的代码），内部类模板专门用于各种特殊情况（帮助编译器启用优化）。每个体面的编译器都将内层函数对象的顶层函数包装器内联，因此没有开销。

更新：正如您注意到的那样，从技术上讲，您可以通过将部分类模板特化替换为函数模板重载，并将显式类模板特化替换为普通函数（而不是允许的显式函数模板特化，如在Sutter 的专栏，不会参与重载决议）。

因为委托给类模板函数对象的函数模板对于部分特化和显式特化都表现得更加规律，因此库编写者和用户等需要维护或修改时就不那么微妙了。这是保持简单的原则。

于 2013-06-21T12:18:35.867 回答
2

这主要是一个偏好问题。可以使用类模板部分特化来完成的函数调用的任何编译时调度，也可以使用函数模板重载来完成，反之亦然。事实上，标准通过引用重载函数模板的部分排序（14.5.5.2）来定义类模板部分特化的部分排序。

也就是说，有时您需要一个编译时选项来控制要调用的单个函数之外的其他内容或更多内容。类模板可以有任意数量的成员函数和成员 typedef，而不仅仅是一个函数。在 C++11 之前constexpr，静态类成员是迄今为止设置依赖于模板参数的常量表达式的最佳方式，因此它的特化可以用作模板参数、数组边界等。

于 2013-06-21T22:18:26.140 回答
0

我会添加一个案例，您的解决方案有“问题”

template <class T> void foo(T t) { std::cout << "foo<T>" << std::endl; }   // (a)
template <class T> void foo(T* t) { std::cout << "foo<T*>" << std::endl; } // (b)

void bar() {
    int i = 0;

    foo(i);          // call (a) f<int>(int)
    foo(&i);         // call (b) f<int>(int*)
    foo<int*>(&i);   // call (a) f<int*>(int*) and not (b)
}

所以在你的情况下，如果我打电话

copy_dispatch<char*, char*>

我没有像 STL 那样获得专业化。

于 2013-08-17T10:27:32.350 回答