简化大量模板特化

Question

所以我有大量这个模板的模板特化：

template <typename T> // Same
struct foo { // Same
    using type_name = T; // Same
    foo(const int base) : _base(base) {} // May take other parameters
    void func(const T& param) {} // This function signature will be the same but body will differ
    int _base; // Same but may have more members
}; // Same

所以一个示例专业化是：

template<>
struct foo<float> {
    using type_name = T;
    foo(const int base, const int child) : _base(base), _child(child) {}
    void func(const T& param) { cout << param * _child << endl; }
    int _base;
    int _child;
};

显然这是一个玩具示例，_func 的主体将更多地参与其中。但我认为这表达了这个想法。我显然可以制作一个宏来帮助处理样板文件，并将该函数的专用版本的实现放在一个实现文件中。

但我希望 C++ 为我提供了一种无需宏就能做到这一点的方法。是否有另一种方法可以避免一遍又一遍地编写样板文件？

Answer 1

你可以对函数进行多个专业化，但不能对整个类进行专业化

喜欢这个

#include <iostream>
#include <string>

template<typename T>
struct foo {
    //common generic code
    using type_name = T;
    foo(const int base, const int child) : _base(base), _child(child) {}
    void func(const T& param);
    int _base;
    int _child;
};

template<>
void foo<float>::func(const type_name&) {
    //implementation
    std::cout << "float" << std::endl;
}

template<>
void foo<int>::func(const type_name&) {
    //implementation
    std::cout << "int" << std::endl;
}


int main() {
    foo<int> tint(0, 0);
    foo<float> fint(0, 0);

    tint.func(0);
    fint.func(0);
}

Answer 2

您可以使用一些轻量级的数据结构继承来帮助您将成员布局和构造函数定义与主模板的差异区分开来。

//Define an internal aggregate type you can specialize for your various template parameters
template <typename T>
struct foo_data {
    foo(const int base) : _base(base) {}
    int _base;
};

//Then derive privately from the data struct (or publicly if you really desire)
template <typename T>
struct foo : private foo_data<T> {
    using type_name = T;
    using foo_data<T>::foo_data<T>; //Make the base class constructors visible
    void func(const T& param); //Use member specialization as suggested by the other answer
};

我会让你决定这种方式是否更好，但结果是所有常见的部分都与所有不常见的部分完全分开。

在另一个答案下的评论中，我错误地将其描述为 CRTP。它不是，也没有 CRTP 的任何缺点。

如果您确实需要保留标准布局，则可以手动模拟继承，使用显式委托和完美转发。

template <typename T>
struct foo {
    using type_name = T;
    template <typename... Args>
    foo(Args&&... args) : base_data_(std::forward<Args>(args)...) {}
    void func(const T& param); //Use member specialization as suggested by the other answer
    foo_data<T> base_data_; 
};

一个缺点是我不认为委托构造函数会像所写的那样正确地使用 SFINAE，而且它还吃掉了noexcept 说明符和explicit。解决这些问题（如果需要）留给读者作为练习。

Answer 3

在实现模板化类型的特化时，没有很好的方法可以避免符号中的一些冗余。有一些技术可以避免实际代码的重复，例如

1. 使用特征模板来提供特定类型的东西

   template<typename T>
   struct foo_traits { ... };  // provide many specialisations
   
   template<typename T>        // no specialisations
   struct foo
   {
       using traits = foo_traits<T>;
   
       template<typename...Aars>
       explicit foo(Args&&...args)
        : data(std::forward<Args>(args)...) {}
   
       int do_something_specific(T x)
       { return traits::do_something(data,x); }
     private:
       typename traits::data data;
   };
   

2. 一种非常相似的方法是使用专门的基类：

   template<typename T>
   struct foo_base { ... };    // provide many specialisations
   
   template<typename T>        // no specialisations
   struct foo : foo_base<T>
   {
       using base = foo_base<T>;
   
       template<typename...Aars>
       explicit foo(int m, Args&&...args)
        : base(std::forward<Args>(args)...)
        , more_data(m) {}
   
       int do_something_specific(T x)
       { return base::do_something(x,more_data); }
     private:
       int more_data;
   };
   

   foo 的构造函数是一个可变参数模板，以便允许基类的构造函数接受任意数量和类型的参数。

3. 您可以使用公共基类并专门化派生类。这可以通过Curiously recurring template pattern (CRTP)

   来完成

   template<typename Derived>
   struct foo_base            // no specializations
   {
       using type = typename Derived::type;
       int do_something(type x)
       {
           auto result = static_cast<Derived*>(this)->specific_method(x);
           return do_some_common_stuff(result);
       }
     protected:
       foo_base(type x) : data(x) {}
       type data;
     private:
       int do_some_common_stuff(type x)
       { /* ... */ }
   };
   
   template<typename T>       // some specialisations
   struct foo : foo_base<foo<T>>
   {
       using base = foo_base<foo>;
       using type = T;
       using common_type = typename base::common_type;
       using base::do_something;
       explicit foo(type x, type y)
         : base(x), extra_data(y) {}
     protected:
       type specific_method(type x)
       { /* ... */ }
     private:
       type extra_data;
   };
   

   请注意，foo_base 已经是一个模板（与普通多态的情况不同），因此您已经可以在那里做很多特定的事情。只有以不同方式完成的事情（不仅仅是不同类型）需要foo 的特化。

4. 最后，您可以将这些方法结合起来，例如特征类与 CRTP。

所有这些方法都实现了某种类型的静态或编译时多态，而不是真正的或动态多态：没有虚函数因此没有虚拟表，也没有表查找的开销。都是在编译时解决的。

Answer 4

这通常是通过继承来完成的——你把不可变的部分放到基类中，然后专门化子类。

我认为您不需要为此提供示例，但如果您需要，请告诉我。