问题描述

首先:我已经阅读过并且现在我知道虚拟模板成员函数(还?)在 C++ 中是不可能的.一种解决方法是使类成为模板，然后也在成员函数中使用模板参数.

first off: I have read and I know now that a virtual template member function is not (yet?) possible in C++. A workaround would be to make the class a template and then use the template-argument also in the member-function.

但是在 OOP 的上下文中，如果类实际上是模板，我发现下面的示例不会很自然".请注意，代码实际上不起作用，但 gcc-4.3.4 报告:error: templates may not ‘virtual’

But in the context of OOP, I find that the below example would not be very "natural" if the class was actually a template. Please note that the code is actually not working, but the gcc-4.3.4 reports: error: templates may not be ‘virtual’

#include <iostream>
#include <vector>

class Animal {
    public:
        template< class AMOUNT >
        virtual void eat( AMOUNT amount ) const { 
            std::cout << "I eat like a generic Animal." << std::endl; 
        }
        virtual ~Animal() { 
        }
};

class Wolf : public Animal {
    public:
        template< class AMOUNT >
        void eat( AMOUNT amount) const { 
            std::cout << "I eat like a wolf!" << std::endl; 
        }
        virtual ~Wolf() { 
        }
};

class Fish : public Animal {
    public:
        template< class AMOUNT >
        void eat( AMOUNT amount) const { 
            std::cout << "I eat like a fish!" << std::endl; 
        }
        virtual ~Fish() { 
        }
};

class GoldFish : public Fish {
    public:
        template< class AMOUNT >
        void eat( AMOUNT amount) const { 
            std::cout << "I eat like a goldfish!" << std::endl; 
        }
        virtual ~GoldFish() { 
        }
};

class OtherAnimal : public Animal {
        virtual ~OtherAnimal() { 
        }
};

int main() {
    std::vector<Animal*> animals;
    animals.push_back(new Animal());
    animals.push_back(new Wolf());
    animals.push_back(new Fish());
    animals.push_back(new GoldFish());
    animals.push_back(new OtherAnimal());

    for (std::vector<Animal*>::const_iterator it = animals.begin(); it != animals.end(); ++it) {
        (*it)->eat();
        delete *it;
    }

    return 0;
}

所以创建一个Fish foo"有点奇怪.然而，我似乎希望为每只动物提供任意数量的食物.

So creating a "Fish< Amount > foo" is kind of strange. However, it seems desirable to me to provide an arbitrary amount of food to eat for each animal.

因此，我正在寻找有关如何实现类似目标的解决方案

Thus, I am searching a solution about how to achieve something like

Fish bar;
bar.eat( SomeAmount food );

这在查看 for 循环时变得特别有用.一个人可能想给所有不同的动物喂食特定量(FoodAmount)(例如通过eat() 和bind1st())，这不容易做到，尽管我觉得这非常直观(因此在某种程度上自然.虽然现在有些人可能想争辩说这是由于向量的统一"特征，我认为/希望应该有可能实现这一点，我真的很想知道如何，因为这是纠结了好久...

This becomes particularly useful when looking at the for-loop. One might like to feed a specific amount (FoodAmount) to all of the different animals (via eat() and bind1st() e.g.), it could not be done that easily, although I wound find this very inuitive (and thus to some extent "natural). While some might want to argue now that this is due to the "uniform"-character of a vector, I think/wish that it should be possible to achieve this and I really would like to know how, as this is puzzling me for quite some time now...

为了澄清我的问题背后的动机，我想编写一个 Exporter 类，并让不同的、更专业的类从中派生.虽然顶级 Exporter-class 通常仅用于装饰/结构目的，但 GraphExporter-class 是派生的，它应该再次作为更专业导出的基类.但是，与 Animal-example 类似，我希望即使在专用/派生类(例如在 SpecialGraphExplorer 上)也能够定义 GraphExporter*，但是在调用write(out_file)"时，它应该为 SpecialGraphExporter 调用适当的成员函数GraphExporter::write(out_file).

To perhaps clarify the motivation behind my question, I want to program an Exporter-class and let different, more specialized classes derive from it. While the top-level Exporter-class is generally only for cosmetic/structural purpose, a GraphExporter-class is derived, that should again serve as a base-class for even more specialzed export. However, similar to the Animal-example, I would like to be able to define GraphExporter* even on specialized/derived classes (e.g. on SpecialGraphExplorer) but when calling "write( out_file )", it should call the appropriate member function for SpecialGraphExporter instead of GraphExporter::write( out_file).

也许这让我的处境和意图更加清晰.

Maybe this makes my situation and intentions clearer.

最好，

阴影

推荐答案

经过一番思考，我认识到这是经典的多方法要求，即基于运行时调度的方法多个参数的类型.相比之下，通常的虚函数是 single dispatch(并且它们仅在 this 类型上调度).