How to make the templated classes keep the inheritance?

Question

The following is the simplified code to show my idea.

#include <iostream> 

struct base {
    virtual int test(){return 0;}
};

struct derived : public base {
    virtual int test(){return 1;}
};

template <typename T>
struct foo : public T {
    virtual int  bar() { return 2;}
};


typedef foo<base> foo_base;
typedef foo<derived> foo_derived;

int main(int argc, char ** argv) {

base * p = new derived(); //It is OK.
std::cout<<p->test()<<std::endl;

foo_base * foo_p = new foo_derived(); //It is not OK 
std::cout<<foo_p->bar()<<std::endl;

foo_base * foo_p2 =(foo_base *)(new foo_derived()); //It is working 
std::cout<<foo_p2->bar()<<std::endl;

delete foo_p2;
delete foo_p;
delete p;

return 0;
}

I know it is not OK due to the template changing the class inheritance. Is there an elegant way to make the inheritance keep the same after applying the template ?

More specifically, is it possible to build an inheritance between foo<base> and foo<derived>, for example, by using some proxy templates or special pattern like CRTP to rebuild same inheritance after the template instantiation?

It's unclear what you're asking. If you use a `base *` it will work for all your examples. What does "make the inheritance keep the same" mean? Same what? — super, May 05 '18 at 19:28
`foo` and `foo` are completely unrelated classes. Both inherit from `base` though, so casting a pointer to `base*` is OK. Prefer `static_cast` and `dynamic_cast`, don't use C-style casts. Then the compiler will help you to prevent invalid casts. — rustyx, May 05 '18 at 19:30
The short answer is: no there isn't. Templates, in C++, don't work this way. Where you're getting off track is when you say "applying the template". Templates don't get "applied". They get instantiated. Instantiating means a new class gets created. The name of the class happens to be `foo`, for example. But it's a class, no different, fundamentally, than a class called `foo`, or `bar`. Now, take your example, remove the template and explicitly create two classes, named `A` and `B`, in place of `foo` and `foo`, and you will be able to answer your question yourself. — Sam Varshavchik, May 05 '18 at 19:37
@super sorry for my unclear expression. I know if using a base * for all the pointers , there will be no problem. However, the code is just a simplified version of real code. I want to add some functions such as bar in the template into the original framework, and want to replace all (base *) in to (foo_base *) by using a namespace alias such as using base = myns::foo_base, just to keep the original code unchanged. under such condition, I can not find an easy way to make the changes on the fly. — whitebob, May 05 '18 at 19:59
@SamVarshavchik, thanks for you reply. In fact i am not quite agree with you that A and B are not related after the instantiation. You can find after the C_style cast, or using reinterpret_cast, the foo_derived could indeed be used, and if you try foo_p2->test(), it will return 1, just as what we expected. — whitebob, May 05 '18 at 20:05
@rustyx, thanks for reply. the C-style casting is just for demonstrating my aim, I won't use it in real code : ). Just want to know if there is a way to automatically rebuild the inheritance between the two classes after template instantiation. — whitebob, May 05 '18 at 20:08
Their only relationship is that they have a common superclass. Just because two classes have the same superclass doesn't mean that an instance of one of those classes can be casted to the other one. C++ does not work this way. — Sam Varshavchik, May 05 '18 at 20:22
Your code exhibits *undefined behavior*. Appearing to work is one common manifestation of UB. That's what makes C++ dangerous. `(foo_base *)(new foo_derived())` is UB. Your interpretation that "it works" is flawed; in fact it only *appears to work*, and only in this specific scenario with this specific compiler and OS. The code is still bad. As you start expanding the classes, it will malfunction. — rustyx, May 05 '18 at 20:39
@rustyx, you are absolutely right, I don't want have the undefined behaviour and that's the reason why i want to find a safe and easy way to make it "really work". Is there any method to build the inheritance after the instantiation? as you know, in real world, foo_base and foo_derived could be both concrete classes in a composite design pattern, while the framework may need the enhanced bar functions thus we can not use a base * but foo_base * to do the polymorph. — whitebob, May 05 '18 at 20:53
@SamVarshavchik, Well, I think not only the superclass. They are instantiated from the same template, thus share a lot in common. In my opinion, they are somehow like "ISA" relationship, just not guarded by the grammar of C++. — whitebob, May 05 '18 at 20:59
Each class created by a template is an independent class that has no relationship, whatsoever, with any other class created by the same template. `foo` and `foo` have just as much relationship between themselves as `class X` and `class Y`. A template creates new classes. Full stop. The End. Nothing to be said further. If the same template instantiates a different class, it's also a new class. Full stop. The End. If `A` and `B` have a relationship, it means nothing, as far as `foo` and `foo` is concerned. They are new classes. Their similar names mean absolutely nothing, whatsoever. — Sam Varshavchik, May 05 '18 at 21:32
@SamVarshavchik, thanks for further explanation. I just want to know if it is possible to build an inheritance between foo and foo if A and B have inheritance, for example, through multi inheritance such as template struct foo : public T1, public T2 { ... }; typedef foo foo_base; typedef foo,derived> foo_derived; or things like that to make this possible. — whitebob, May 05 '18 at 21:56
It is possible to do that by specializing the template, but each such specialization will have to be explicitly defined. That is, if `A` inherits from `B` you will have to explicitly declare such template specialization. And `foo` will then inherit from `foo`. But if you have a pair of other classes, `C` and `D, you'll have to, again, declare such specialization. Template specialization is a fairly complicated topic. — Sam Varshavchik, May 05 '18 at 22:06
@SamVarshavchik, Yes, you are right. and I want to find an easy way to deal with all of them, instead of explicitly repeat the concrete template specializations. If the template could automatically resolve the inheritance and build the instant class with same inheritance, that would be the best solution. — whitebob, May 05 '18 at 22:19
C++ [does not have reflection](https://stackoverflow.com/questions/359237/why-does-c-not-have-reflection). Until such time that it does, C++ simply does not support this functionality. — Sam Varshavchik, May 05 '18 at 22:58
@SamVarshavchik, Thanks for the link. I will do more searches for possible ways. — whitebob, May 05 '18 at 23:06

score 0 · Answer 1 · answered May 12 '18 at 15:10

As said by Sam Varshavchik in the comments, you cannot automate this process completely since C++ does not have reflection, and thus can't list base classes. However, you've already gone down the route of typedefing your template instantiations, and this is the perfect place to list base classes yourself (hanges highlighted in comments):

struct base {
    // Don't forget the virtual destructor for polymorphic destruction
    virtual ~base() = default;

    virtual int test() const { return 0; }
};

struct derived : base {
    int test() const override { return 1; }
};

// U... is the list of thebase classes for T
template <typename T, typename... U>
struct foo : T, foo<U>... {
    //        ^^^^^^^^^^^ Inheritance is mirrored here

    virtual int bar() const { return 2; }
};

// base has no base class
typedef foo<base> foo_base;

// derived has one base class, base.
typedef foo<derived, base> foo_derived;

Live example on Coliru

How to make the templated classes keep the inheritance?

1 Answers1