By the time your destructor is called, the destructor of inherited classes has already been called. Within constructors and destructors, the dynamic type of the object can effectively be considered to be the same as the static type. That is, when you call virtual methods from within your constructors/destructors it’s not the overriden versions of … Read more
You need to specify the template parameter for it, since myClass is a class template. template<typename T> myClass<T>::myClass(void) : std::stack<T>() { // ^^^ } LIVE BTW: : std::stack<T>() seems to be redundant.
Generic types in C# are not C++ templates; remember, a generic type must work for all possible type arguments. A template need only work for the constructions you actually make. This question is a duplicate; see my answer to Why cannot C# generics derive from one of the generic type parameters like they can in … Read more
I don’t think it is possible. However you can further refine the Shape class by removing the rotate() method from its specification and instead define another subclass of Shape called RotatableShape and let Circle derive from Shape and all other Rotatable classes from RotatableShape. e.g: public class Shape{ //all the generic methods except rotate() } … Read more
It is not allowed by the standard, however you could use one of the following two workarounds to get a similar behaviour. The first would be to use using to change the visibility of the method to private, thus preventing others from using it. The problem with that solution is, that calling the method on … Read more
The constructor of PetStore will call a constructor of Farm; there’s no way you can prevent it. If you do nothing (as you’ve done), it will call the default constructor (Farm()); if you need to pass arguments, you’ll have to specify the base class in the initializer list: PetStore::PetStore() : Farm( neededArgument ) , idF( … Read more
That’s two-phase lookup for you. Base<T>::NO_ZEROFILL (all caps identifiers are boo, except for macros, BTW) is an identifier that depends on T. Since, when the compiler first parses the template, there’s no actual type substituted for T yet, the compiler doesn’t “know” what Base<T> is. So it cannot know any identifiers you assume to be … Read more
The parent class has an explicit constructor, so compiler will not add an implicit ’empty’ constructor to it. Additionally your constructor has a parameter, so compiler can not generate an implicit call to it. That’s why you must do it explicitly. This way: child::child(int a) : parent(a) { }
No, you cannot access derived_int because derived_int is part of Derived, while basepointer is a pointer to Base. You can do it the other way round though: Derived* derivedpointer = new Derived; derivedpointer->base_int; // You can access this just fine Derived classes inherit the members of the base class, not the other way around. However, … Read more
I don’t know if this is what you want, and the way you’d like it implemented, but here’s a try: >>> class Person(object): def _type(self): return self.__class__.__name__ >>> p = Person() >>> p._type() ‘Person’ >>> class Manager(Person): pass >>> m = Manager() >>> m._type() ‘Manager’ >>> Pros: only one definition of the _type method.