C++：模板类的部分实现

Question

Suppose I have a hierarchy of two classes:

class Base {
public:
    virtual ~Base() {}
    virtual int next(int x) const { return x+1; }
};

class Derived: public Base {
public:
    virtual int prev(int x) const { return x-1; }
};

I want to create a Modifier class template that could apply to both Base and Derived and changes the behaviour of next() (if used with Base ) or both next() and prev() (if used with Derived ). Here is an inelegant solution with code duplication:

template<class BaseOrDerived> class Modifier;

template<> class Modifier<Base>: public Base {
    const Base& obj;
    const int k;
public:
    Modifier(const Base& _obj, int _k) : obj(_obj), k(_k) {}
    virtual int next(int x) const { return obj.next(x)+k; }
};

template<> class Modifier<Derived>: public Derived {
    const Derived& obj;
    const int k;
public:
    Modifier(const Derived& _obj, int _k) : obj(_obj), k(_k) {}
    virtual int next(int x) const { return obj.next(x)+k; }
    virtual int prev(int x) const { return obj.prev(x)-k; }
};

Now the question: how to do this better? Can I write down the first specialization Modifier<Base> in full (or write it in a general form without any template specialization), and then somehow "add" the method prev() to a specialization of the template class Modifier<Derived> ?

I tried to do this by making Modifier<Derived> inherit from both Derived and Modifier<Base> and using a virtual inheritance, but this results in a rather ugly diamond inheritance diagram, with duplicated obj member variables of two different types, and is not really what I want: the two template specializations do not need to inherit from one another, they just need to implement the same behaviour for next() .

Thanks in advance for any suggestions.

Answer 1

This all sounds a bit too tricksy for me - I would just make k a member of Base and have done with it - but if you really want to do it this way then simple template inheritance (aka static polymorphism) will do the job.

So what I have done here is structured the Modifier templates into a class hierarchy and done away with them inheriting from the actual classes whose behaviour they are modifying, since that is what is messing you up. And when you do that, this is what you end up with:

template<class BaseOrDerived> class Modifier;

template<class BaseOrDerived> class ModifierCommon{
    friend class Modifier<Derived>;
    const BaseOrDerived& obj;
    const int k;
public:
    ModifierCommon(const BaseOrDerived& _obj, int _k) : obj(_obj), k(_k) {}
    virtual int next(int x) const { return obj.next(x)+k; }
};

template<> class Modifier<Base>: public ModifierCommon<Base> {
    using ModifierCommon<Base>::ModifierCommon;
};

template<> class Modifier<Derived>: public ModifierCommon<Derived> {
    using ModifierCommon<Derived>::ModifierCommon;
public:
    virtual int prev(int x) const { return obj.prev(x)-k; }
};

And that's all there is to it, best of luck. But, as I say, personally I wouldn't do it at all, you're just over-egging the pudding.

Demo

---

Hokay, as per the comments the OP has moved the goalposts a bit so let's see what we can do.

To be able to access, for example, Modifier<Base> as if (more or less) it was a true Base object, you can add a couple of tweaks to the ModifierCommon template as follows:

template<class BaseOrDerived> class ModifierCommon{
...
public:
    // Add these
    BaseOrDerived* operator->() { return &this->obj; }
    const BaseOrDerived* operator->() const { return &this->obj; }
    operator BaseOrDerived& () const { return this->obj; }
    // End add these
...
};

So, after taking out a couple of const s, the whole thing now becomes:

template<class BaseOrDerived> class ModifierCommon{
    friend class Modifier<Derived>;
    BaseOrDerived& obj;
    const int k;
public:
    ModifierCommon(BaseOrDerived& _obj, int _k) : obj(_obj), k(_k) {}
    BaseOrDerived* operator->() { return &this->obj; }
    const BaseOrDerived* operator->() const { return &this->obj; }
    operator BaseOrDerived& () const { return this->obj; }
    virtual int next(int x) const { return obj.next(x)+k; }
};

And here's an example of how you might use it (I added a test method called foo to Base and another called bar to Derived ):

void call_me_using_base (Base &b) { }
void call_me_using_derived (Derived &d) { }

int main()
{
    Base b;
    std::cout << b.next (100) << "\n";
    Modifier<Base> mb (b, 42);
    std::cout << mb.next (100) << "\n";
    std::cout << mb->foo (10) << "\n";
    call_me_using_base (mb);

    Derived d;
    std::cout << d.next (100) << "\n";
    std::cout << d.next (100) << "\n";
    Modifier<Derived> md (d, 84);
    std::cout << md.next (100) << "\n";
    std::cout << md.prev (100) << "\n";
    std::cout << md->bar (21) << "\n";
    call_me_using_derived (md);
}

Updated demo

And no, I still wouldn't do this. Design a proper class hierarchy like everybody else does.