从派生的可变参数模板类调用基模板的虚拟方法

这本质上是后续之前的一个问题 https://stackoverflow.com/q/26351963/315052（不是我提出的，但我对答案感兴趣）。

问题是： 为什么编译器/链接器无法解析派生类对虚函数的调用？在这种情况下，派生类是具有可变参数的模板类，它多次对同一模板类应用多重继承（对可变参数中的每种类型应用一次）。

在下面的具体示例中，派生类是JobPlant，并且它正在被调用Worker。调用摘要work()调用时方法无法链接workaround()以预期方式链接并执行。

这些是链接失败，如下所示ideone http://ideone.com/mxfoKd:

/home/g6xLmI/ccpFAanK.o: In function `main':
prog.cpp:(.text.startup+0x8e): undefined reference to `Work<JobA>::work(JobA const&)'
prog.cpp:(.text.startup+0xc9): undefined reference to `Work<JobB>::work(JobB const&)'
prog.cpp:(.text.startup+0xff): undefined reference to `Work<JobC>::work(JobC const&)'
collect2: error: ld returned 1 exit status

点击此链接 http://ideone.com/yDaBSf用于演示解决方法的工作原理。

Job是一个抽象基类，它具有关联的派生类。Work是执行工作的抽象模板类。Worker是一个模板，用于标识JOB并执行它（struct代替class纯粹是为了减少语法混乱）：

struct Job { virtual ~Job() {} };

struct JobA : Job {};
struct JobB : Job {};
struct JobC : Job {};

template <typename JOB>
struct Work {
    virtual ~Work() {}
    virtual void work(const JOB &) = 0;
    void workaround(const Job &job) { work(dynamic_cast<const JOB &>(job)); }
};

template <typename PLANT, typename... JOBS> struct Worker;

template <typename PLANT, typename JOB, typename... JOBS>
struct Worker<PLANT, JOB, JOBS...> {
    bool operator()(PLANT *p, const Job &job) const {
        if (Worker<PLANT, JOB>()(p, job)) return true;
        return Worker<PLANT, JOBS...>()(p, job);
    }
};

template <typename PLANT, typename JOB>
struct Worker<PLANT, JOB> {
    bool operator()(PLANT *p, const Job &job) const {
        if (dynamic_cast<const JOB *>(&job)) {
            p->Work<JOB>::work(dynamic_cast<const JOB &>(job));
            //p->Work<JOB>::workaround(job);
            return true;
        }
        return false;
    }
};

A JobPlant是一个模板类，参数化为JOBS，找到一个Worker执行一个job. The JobPlant继承自Work对于每个工作类型JOBS. MyJobPlant是一个实例JobPlant，并实现了虚拟work相关方法Work抽象类。

template <typename... JOBS>
struct JobPlant : Work<JOBS>... {
    typedef Worker<JobPlant, JOBS...> WORKER;
    bool worker(const Job &job) { return WORKER()(this, job); }
};

struct MyJobPlant : JobPlant<JobA, JobB, JobC> {
    void work(const JobA &) { std::cout << "Job A." << std::endl; }
    void work(const JobB &) { std::cout << "Job B." << std::endl; }
    void work(const JobC &) { std::cout << "Job C." << std::endl; }
};

int main() {
    JobB j;
    MyJobPlant().worker(j);
}

你明确地调用p->Work<JOB>::work()，即纯虚方法Work<JOB>。这个方法没有实现（毕竟它是纯粹的）。

派生类可能已实现/重写该方法并不重要。这Work<JOB>::表示您想要该类的版本，而不是派生类的版本。不会发生动态调度。

(Work<JOB>::work()是用于从派生类中的重写方法调用基类方法的语法，并且您确实需要基类方法。）

当你删除然后明确Work<JOB>::，结果是歧义错误。当尝试解析名称时work，编译器首先尝试确定哪个基类包含该名称。之后，下一步将是不同的重载解决方案work该类中的方法。

不幸的是，第一步会导致歧义：多个基类包含该名称work。然后编译器永远不会尝试找出匹配的重载。 （它们并不是真正的重载，而是相互冲突，因为它们来自不同的类）。

通常这可以通过将基类方法名称带入派生类来解决using（或者无论如何，它在技术上被称为什么using做）。如果你添加using所有的声明work基类的方法，编译器找到名称work在派生类中（没有歧义），然后可以继续进行重载决策（也没有歧义）。

可变参数模板使事情变得复杂，因为我不认为using Work<JOBS>::work...;是合法的（我的编译器也不这么认为）。但如果你“手动”编写基类，所有的工作方法都可以带入最终类中：

template <typename JOB, typename... JOBS>
struct CollectWork : Work<JOB>, CollectWork<JOBS...> {
   using Work<JOB>::work;
   using CollectWork<JOBS...>::work;
};

template <typename JOB>
struct CollectWork<JOB> : Work<JOB> {
   using Work<JOB>::work;
};

template<typename... JOBS>
struct JobPlant : CollectWork<JOBS...> {                                           
   using CollectWork<JOBS...>::work;
   typedef Worker<JobPlant, JOBS...> WORKER;
   bool worker(const Job &job) { return WORKER()(this, job); }
};

通过这种构造，有问题的p->work(dynamic_cast<const JOB &>(job)); 编译并运行成功 http://ideone.com/bySbiG.