Question

问题：

有没有办法从C ++中的专用模板函数调用“基本”模板函数，子类在覆盖它们时可以访问父类虚拟方法的方式？（注意：我怀疑答案是“不”，但是喜欢错了）

背景信息：

我经常发现自己专门设计模板功能只是因为特殊情况需要额外的预处理或后处理，而不是因为代码的“胆量”已经改变。

举一个人为的例子：

使用继承，您可以执行以下操作：

struct base { 
    virtual void go() { printf("%p", this); }
};
struct foo : base { 
    virtual void go() { printf("this foo lives at "); base::go(); } 
};

...并且调用foo :: go（）将打印“this foo live at＆lt; address＆gt;”

使用模板：

template <typename T>
void go(T const &t) { printf("%p\n", &t); }

template <>
void go(foo const &f) { 
    printf("this foo lives at "); 
    ??? how to access "base" template ??? 
}

你可以通过分解一堆小辅助函数并专门化它们而不是你真正关心的函数，以一种丑陋的方式解决这个问题：

template <typename T>
void _go_pre(T const &t) { /* do nothing */ }

template <typename T>
void _go_post(T const &t) { /* do nothing */ }

template <typename T>
void go(T const &t) { 
    _go_pre(t); /* just in case */
    printf("%p\n", &t); 
    _go_post(t); 
}

template<>
void _go_pre(foo const &t) { printf("this foo lives at "); }

...但是这会使代码显着混乱，因为现在“基础”模板需要预测“子”专业化可能覆盖它的所有方式，并且大多数类型将使用这些钩子中的少数（如果有的话）。混乱变得难以理解并且很快就无法维护，因为这些钩子的原因在定义时并不为人所知，并且您必须测试已使用/未使用的钩子的不同组合。

所有这些与您在子类无法访问父类提供的原始版本的世界中使用虚拟方法覆盖时遇到的问题完全相同。

Answer 1

直接不可能。但是，您可以使用这样的更少（和IMO不那么丑陋）的助手：

template <typename T>
void base_go(T const &t) { printf("%p\n", &t); }

template <typename T>
void go(T const &t) { base_go(t); }

template<>
void go(foo const &t) { printf("this foo lives at "); base_go(t); }

作为替代方案，您可以将base_变体放入单独的命名空间，而不是为其提供修改后的名称。

Answer 2

如果你的foo是普通类型，你可以简单地创建一个（非模板）函数重载并调用里面的模板化版本：

#include <iostream>

struct A {};
template<class T>
void f(T const&) {
    std::cout << "in f<T>(T const&)" << std::endl;
}

void f(A const& a) { 
    std::cout << "in f(A const&)" << std::endl;
    f<A>(a);
}

int main() {
    A a;
    f(a);
    return 0;
}

从“覆盖”它的C ++模板专业化调用“基础”模板函数？

2 个答案: