The definitive ruling is found in Stroustrup’s FAQs. In short, it doesn’t convey any semantic meaning. It will have a cost. Templates are more useful for containers. Why doesn’t C++ have a universal class Object? We don’t need one: generic programming provides statically type safe alternatives in most cases. Other cases are handled using multiple … Read more
Use a Metaclass I would recommend Method #2, but you’re better off using a metaclass than a base class. Here is a sample implementation: class Singleton(type): _instances = {} def __call__(cls, *args, **kwargs): if cls not in cls._instances: cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs) return cls._instances[cls] class Logger(object): __metaclass__ = Singleton Or in Python3 class Logger(metaclass=Singleton): … Read more
Unfortunately, it isn’t possible. Not even with a helper method. The helper method has the same problems as your second attempt: this is of type B, even in the base class and will call the implementation of M in B: interface I { int M(); } class A : I { int I.M() { return … Read more
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
I hat the same problems with a library of mine providing “plugin”-functionality… I got it finally working… Here was my problem: I had one main assembly using plugins, one assembly with the plugin (Plugin.dll) AND (important) another assembly providing the plugin-functionality (Library.dll). The Plugin.dll referenced the main assembly (in order to be able to extend … Read more
class D1 :B1 Inheritance of classes is private by default, you should make it public: class D1 : public B1
That is completely impossible. The form you see in the design view is an actual instance of your base class. If there is not default constructor, the designer cannot create that instance. You can mark the constructor with the [Obsolete(“Designer only”, true)], and make it throw an exception if called when not in the designer, … Read more
David Joyner had the history, here is the reason. The problem when compiling B<T> is that its base class A<T> is unknown from the compiler, being a template class, so no way for the compiler to know any members from the base class. Earlier versions did some inference by actually parsing the base template class, … 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.
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