使用模板对类层次结构进行函数重载的这种方式安全吗

Question

好吧，这有点复杂，所以请耐心等待。：）

我们有这样一个简单的类层次结构：

class A {};
class DA : public A {};
class DDA : public DA {};

我们在这些类上运行以下函数：

void f(A x) {
  std::cout << "f A" << std::endl;
}
void f(DA x) {
  std::cout << "f DA" << std::endl;
}
void f(DDA x) {
  std::cout << "f DDA" << std::endl;
}

现在，我们想添加另一个函数，以稍微不同的方式处理DA。

（1） 第一次尝试可能是这样的：

void g(A t) {
  std::cout << "generic treatment of A" << std::endl;
  std::cout << "called from g: ";
  f(t);
}
void g(DA t) {
  std::cout << "special treatment of DA" << std::endl;
  std::cout << "called from g: ";
  f(t);
}

但是用每个类的对象调用它显然没有达到预期的效果。

呼叫：

  A a; DA b; DDA c;
  g(a); g(b); g(c)

结果：

generic treatment of A
called from g: f A
special treatment of DA
called from g: f DA
special treatment of DA
called from g: f DA        //PROBLEM: g forgot that this DA was actually a DDA

（2） 因此，我们可能会尝试使用模板：

template<typename T>
void h(T t) {
  std::cout << "generic treatment of A" << std::endl;
  std::cout << "called from h: ";
  f(t);
}
template<>
void h<>(DA t) {
  std::cout << "special treatment of DA" << std::endl;
  std::cout << "called from h: ";
  f(t);
}

结果是：

generic treatment of A
called from h: f A
special treatment of DA
called from h: f DA
generic treatment of A    //PROBLEM: template specialization is not used
called from h: f DDA

那么，我们不使用模板专门化，而是为特殊情况定义一个非模板函数，怎么样？（关于这个非常令人困惑的问题的文章。）事实证明，它的行为方式完全相同，因为根据文章的说法，非模板函数是"一等公民"，但似乎失败了，因为使用它需要类型转换。如果要使用它，那么我们只会回到第一个解决方案（我想），它会忘记DDA的类型。

（3） 现在我在工作中遇到了这个代码，它对我来说似乎很新奇：

template<typename T>
void i(T t, void* magic) {
  std::cout << "generic treatment of A" << std::endl;
  std::cout << "called from i: ";
  f(t);
}
template<typename T>
void i(T t, DA* magic) {
  std::cout << "special treatment of DA" << std::endl;
  std::cout << "called from i: ";
  f(t);
}

但它似乎正是我想要的：

generic treatment of A
called from i: f A
special treatment of DA
called from i: f DA
special treatment of DA
called from i: f DDA

尽管它需要以一种奇怪的方式调用：i（a，&a）；i（b，&b）；i（c，&c）；

现在我有几个问题：

1. 为什么这样做
2. 你认为这是个好主意吗？可能的陷阱在哪里
3. 你还建议用哪种方法来完成这种专业化
4. （类型转换如何适应模板偏序之类的疯狂…）

我希望这是相当清楚的

Answer 1

函数模板重载

template<typename T>
void i(T t, DA* magic) {

仅当参数CCD_ 1可转换为类型CCD_。这显然是&b的情况，但也是&c的情况，因为派生的指针可以转换为基指针。void *功能模板过载始终可用，但根据§13.3.3.2:4:，DA *优先于void *

c++11

13.3.3.2对隐式转换序列进行排序[over.ics.rank]

[…]

4标准转换序列按等级排序：精确匹配比晋升，这是比转换更好的转换。具有相同秩的两个转换序列除非以下规则之一适用，否则无法区分：

[…]

--如果B类是直接或间接从A类派生的，则magic0到A*的转换比转换好B*到void*的转换以及A*到void*的转换优于B*到void*的转换。

正如你所指出的，这是一个完全可行的方案；将魔术封装在另一个模板函数中会更有意义，该函数负责用(a, &a):调用i

template<typename T>
void j(T t) {
    i(t, &t);
}

就安全性而言，这很好；如果CCD_ 20过载丢失，则CCD_；这是否可取由你来决定。

作为替代方案，您可以使用DA *2在模板之间进行选择：

template<typename T>
typename std::enable_if<!std::is_base_of<DA, T>::value>::type g(T t) {
  std::cout << "generic treatment of A" << std::endl;
  f(t);
}
template<typename T>
typename std::enable_if<std::is_base_of<DA, T>::value>::type g(T t) {
  std::cout << "special treatment of DA" << std::endl;
  f(t);
}