具有特征参数的模板专业化函数

Question

我正在尝试为 Eigen 类型编写一些具有模板专业化的函数，遵循这个问题：Eigen: type deduction in template specialization of base-class

这是我写的：

#include <type_traits>
#include <Eigen/Core>

namespace isEigenPlainObjectBaseDetail {
    template <typename T>
    std::true_type test(const Eigen::PlainObjectBase<T>);
    std::false_type test(...);
}
template <typename T>
struct isEigenPlainObjectBase :
        public decltype(isEigenPlainObjectBaseDetail::test(std::declval<T>())) {};

template <typename T, typename Enable = void>
void foo(T& obj) {
    std::cout << "Generic Called!\n";
}

template <typename T, typename std::enable_if<isEigenPlainObjectBase<T>::value>::type>
void foo(T& obj) {
    std::cout << "Eigen Specialization Called!";
}

int main() {
    Eigen::MatrixXd m;
    Eigen::VectorXd v;
    int i = 0;
    foo(i);
    foo(m);
    foo(v);
    return 0;
}

但这每次都会调用泛型函数：

Generic Called!
Generic Called!
Generic Called!

我做错了什么？如何为具有特征矩阵和向量的函数编写模板特化？

Answer 1

不确定这是唯一的问题（没有安装 Eigen，所以我无法检查；抱歉）但是...

您可以部分专门化结构和类，而不是函数。

所以这段代码

template <typename T, typename Enable = void>
void foo(T& obj) {
    std::cout << "Generic Called!\n";
}

template <typename T, typename std::enable_if<isEigenPlainObjectBase<T>::value>::type>
void foo(T& obj) {
    std::cout << "Eigen Specialization Called!";
}

不起作用，我很惊讶编译。

编辑：正如 Quentin 所指出的（谢谢！）第二个模板参数是非类型的；所以两个foo() 之间没有冲突，但第二个被排除在外，因为非类型模板参数的类型为void。这是不允许的。

要使用 SFINAE，您应该通过 class 或 struct；像

template <typename T, typename = void>
struct foo
 {
   static void func (T & obj)
    { std::cout << "Generic Called!\n"; }
 };

template <typename T
struct foo<T, typename std::enable_if<isEigenPlainObjectBase<T>::value>::type>
 {
   static void func (T & obj)
    { std::cout << "Eigen Specialization Called!"; } 
 };

并且可以用作

foo<decltype(i)>::func(i);
foo<decltype(m)>::func(m);
foo<decltype(v)>::func(v);

也许你可以定义一个bar() 模板辅助函数

template <typename T>
void bar (T & t)
 { foo<T>::func(t); }

只需调用

bar(i);
bar(m);
bar(v);

或者使用标签调度更简单。

如果你定义了几个foo() 接收不同的附加参数

template <typename T>
void foo (T &, std::false_type const &)
 { std::cout << "Generic Called!\n" }

template <typename T>
void foo (T &, std::true_type const &)
 { std::cout << "Eigen Specialization Called!"; }

您应该能够使用像这样的 bar() 辅助函数选择正确的 foo()

template <typename T>
void bar (T & t)
 { foo(t, isEigenPlainObjectBase<T>{}); }

和以前一样，只需调用

bar(i);
bar(m);
bar(v);

[注意：未测试]

Answer 2

如果您只是想为您传入的两种类型专门化一个函数，它可能比您想象的要简单得多。

当前代码：

template <typename T, typename Enable = void>
void foo(T& obj) {
    std::cout << "Generic Called!\n";
}

template <typename T, typename std::enable_if<isEigenPlainObjectBase<T>::value>::type>
void foo(T& obj) {
    std::cout << "Eigen Specialization Called!";
}

新代码：

template <typename T>
void foo(T& obj);

template <>
void foo(Eigen::MatrixXd& obj) {
    std::cout << "Eigen Specialization Called!" << std::endl;
}

template <>
void foo(Eigen::VectorXd& obj) {
    std::cout << "Eigen Specialization Called!" << std::endl;
}

template <typename T>
void foo(T& obj) {
    std::cout << "Generic Called!" << std::endl;
}

注意，不是为了测试而编译的。

另一种方法是为你感兴趣的类型添加一个特征，你会怎么做？

我推荐的方式如下。 （注意未编译/测试）

template<typename T>
struct isEigenTrait;

//specializations for all of the eigen types you are interested in
template<>
struct isEigenTrait<Eigen::MatrixXd> {
   typedef std::true_type value;
};

//...

template<typename T>
struct isEigenTrait {
   typedef std::false_type value;
};

template<class T, std::enable_if_t<isEigenTrait<T>::value, true_type> = 0>
void foo(T& obj) {
    std::cout << "Eigen Specialization Called!" << std::endl;
}

template<class T, std::enable_if_t<isEigenTrait<T>::value, false_type> = 0>
void foo(T& obj) {
    std::cout << "Generic Called!" << std::endl;
}

从 c++ 参考修改的代码应该可以工作。

为了在一个特征中获得所有特征矩阵，我相信以下应该可行。

//specializations for all of the eigen types you are interested in
template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime>
struct isEigenTrait< Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> > {
   typedef std::true_type value;
};

您可能需要对要添加 isEigenTrait 的每种模板类型执行相同操作。