C++，2参数类模板的部分特化：无法将函数定义与现有声明匹配

Question

我目前正在实现一个数据集帮助器类模板，该模板将浮点值 (Scalar) 存储在一个动态大小的 Eigen::Matrix 中，该模板由不同值类型的向量 (Element) 构成，另外还存储对此输入向量的引用.现在我想部分专门化向量值类型中的构造函数，保留标量类型中的模板以显式实例化。

不幸的是，我在 VS 2010 上遇到“无法将函数定义与现有声明匹配”。代码很简单：

template <class Scalar, class Element> struct DataSet
{
    DataSet(std::vector<Element> const & source);

    // several generic member functions here ...

    Eigen::Matrix<Scalar, ...  > data;
    std::vector<Element> const & source;
};

template<class Scalar>
DataSet<Scalar, SomeClass>::DataSet(std::vector<SomeClass> const & input)
{
    // special impl for Element==SomeClass ...
}

SomeClass 应该由编译器自动计算出来，如果正确完成但我尝试了所有有意义的组合但仍然得到：

*.cpp(79) C2244 : unable to match function definition to an existing declaration
see declaration of 'DataSet<Scalar, Element>::DataSet'

我还没有通过搜索互联网找到匹配的示例。提前致谢！

编辑：

为了更具体，在我的真实案例中，我希望能够为 Element 的不同类型的构造函数定义几个部分特化，例如：

template<Scalar>
DataSet<Scalar, FirstClass>::DataSet(std::vector<FirstClass> const & first)
: data()
, source(first)
{
    // special impl here ...
}

template<Scalar>
DataSet<Scalar, std::shared_ptr<SecondClass> >::DataSet(std::vector<std::shared_ptr<SecondClass> > const & second)
: data()
, source(second)
{
    // special impl here ...
}

不希望将类完全重新声明/专门化为某个类型名。那么作为一个模板就没有什么用了。我想要解决方案，否则我的问题可能有其他策略。

FIN：

由于看起来无法通过仅特化构造函数（这与类的隐式特化有关）来在类模板和构造函数之间共享类型 Element，因此我从类中删除了引用 source完全模板并将所需信息复制到通用容器中，并通过重载实现构造函数。

Answer 1

在定义构造函数时，您没有为它的类显式提供两个模板参数。这需要修改如下：

template<typename T_Scalar, typename T_Element>
DataSet<T_Scalar, T_Element>                    // template args for type
::DataSet(std::vector<T_Element> const &input)  // but none for constructor
{
    // stuff
}

切向相关：与方法不同，template arguments for classes cannot be deduced from constructor calls。那就是：until C++17 comes around！哇！

您面临的下一个绊脚石是模板特化不会“继承”其主模板的成员。假设他们会这样做有点直观，但事实并非如此。在我找到官方理由之前，我认为这是因为模板参数可能会使某些成员完全不适用于专业化，从而导致隐含的“继承”有问题。如果是这样，将决定要求完全重新声明/不值得添加神秘的语法来指定哪些主要的“基础”成员是“继承的”......当您可以简单地使用 real 继承时以确保它们是。

无论如何，这意味着要获得部分特化，您需要先声明整个事物——在这种情况下，是类及其构造函数——然后才能特化构造函数的定义。你没有提前声明这些，所以编译器正确地抱怨它看不到声明。

// Define specialised class
template<typename T_Scalar>
class DataSet<T_Scalar, SomeClass>
{
public:
    // Declare its ctor
    DataSet(std::vector<SomeClass> const &);
}

// Implement its ctor
template<typename T_Scalar>
DataSet<T_Scalar, SomeClass> // complete template args
::DataSet(std::vector<SomeClass> const &input)
{
    // stuff
}

See my working example of an equivalent template class, showing general vs. specialised instantiations.

增加你原来的困惑，这是公平的！ - 请注意，如果模板类本身包含模板函数，则行外定义确实会变得非常复杂，因为您需要 2 template 子句，例如

template<typename TA, typename TB>
class Widget {
    template<typename TC>
    void accept_gadget(TC &&gadget);
};

template<typename TA, typename TB>
template<typename TC>
Widget<TA, TB>
::accept_gadget(TC &&gadget)
{
    /* ... */
}

如果the proposal to allow namespace class 在未来的版本中被接受，那么在许多情况下会有很大帮助，尤其是包括这种离线模板定义。很遗憾，它没有进入 C++17 ......而且很奇怪，它曾经丢失在第一名！

Answer 2

根据 §14.7.3.16：

在为类模板的成员或出现在命名空间范围内的成员模板的显式特化声明中，成员模板和它的一些封闭类模板可以保持非特化，除非声明不应显式特化类成员如果它的封闭类模板也没有明确专门化，则为模板。

不过，您仍然可以使用 std::enable_if 来部分专业化您的构造函数：

template <class Scalar, class Element> struct DataSet
{
    template <class T>
    DataSet(std::vector<T> const & input, std::enable_if_t<!std::is_same<T, SomeClass>{}> * = nullptr) {
        std::cout << "Element\n";
    }
    template <class T>
    DataSet(std::vector<T> const & input, std::enable_if_t<std::is_same<T, SomeClass>{}> * = nullptr) {
        std::cout << "SomeClass\n";
    }
};

但是这种方式是有限制的：

• 您的所有条件都必须是排他性的
• 您必须为要处理的每个新类修改类的代码。

相反，我建议您使用模板辅助结构：

DataSet(std::vector<Element> const & input) {
    Helper<Element>::do_it(input);
}

您可以根据需要进行专业化：

template <class Element>
struct Helper {
    static void do_it(std::vector<Element> const & input) {
        std::cout << "General form with Element\n";
    }
};


template<>
struct Helper<SomeClass> {
    static void do_it(std::vector<SomeClass> const & input) {
        std::cout << "SomeClass\n";
    }
};

template<>
struct Helper<SomeOtherClass> {
    static void do_it(std::vector<SomeOtherClass> const & input) {
        std::cout << "SomeOtherClass\n";
    }
};

...