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
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
Interfaces define that a class MUST be able to do something. This means that you know the object being worked on will do what you want to be able to do. It allows you greater freedom and is one of the advantages of OOP. This is a deep topic but a very basic example would … 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
There’s a difference between new and virtual/override. You can imagine, that a class, when instantiated, is nothing more than a table of pointers, pointing to the actual implementation of its methods. The following image should visualize this pretty well: Now there are different ways, a method can be defined. Each behaves different when it is … 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
If you are just adding behavior, and not depending on additional instance values, you can assign to the object’s __class__: from math import pi class Circle(object): def __init__(self, radius): self.radius = radius def area(self): return pi * self.radius**2 class CirclePlus(Circle): def diameter(self): return self.radius*2 def circumference(self): return self.radius*2*pi c = Circle(10) print c.radius print c.area() … Read more
No. A reference to a derived class must actually refer to an instance of the derived class (or null). Otherwise how would you expect it to behave? For example: object o = new object(); string s = (string) o; int i = s.Length; // What can this sensibly do? If you want to be able … Read more