Differences Between Python and C++ Constructors

Question

I\'ve been learning more about Python recently, and as I was going through the excellent Dive into Python the author noted here that the __init__ method is not tech

Answer 1

The difference is owing to Python's dynamic typing. Unlike C++ where variables are declared with types and allocated in memory, Python's variables are created when assigned at run time. C++ no-arg constructors are automatically called so that they can initialize data members. In Python, it is done on demand and __init__ is looked up by the inheritance tree, only the lowest one is called and once. If a superclass data attribute is needed, super().__init__() is explicitly called like C++ initialization list. Below is an example where Base.s is initialized:

class   Base:
    def __init__(self, base):
        print("Base  class init called")
        self.base = base
class   Super(Base):
    def __init__(self, base):
        print("Super class init called")
        #super(Super, self).__init__(base)
        super().__init__(base)
class   Sub(Super):
    def __init__(self, base):
        print("Default __init__ is called")
        super().__init__(base)

sub = Sub({"base3": 3, "base4": 4})
print(sub.__dict__, sub.base)

Output:

Default __init__ is called
Super class init called
Base  class init called
{'base': {'base3': 3, 'base4': 4}} {'base3': 3, 'base4': 4}

Also, init is just like an ordinary function and can be called afterwards as such:

Sub.__init__(sub, 'abc')
print(sub.__dict__, sub.base)

Output:

Default __init__ is called
Super class init called
Base  class init called
{'base': 'abc'} abc

Answer 2

In Python an object is created, by __new__, and that sort of generic default object is modified by __init__. And __init__ is just an ordinary method. In particular it can be called virtually, and calling methods from __init__ calls them virtually.

In C++ raw memory for an object is allocated in some way, statically, or on a call stack, or dynamically via operator new, or as part of another object. Then the constructor for the type that you're instantiating initializes the raw memory to suitable values. A constructor for a given class automatically calls constructors of base classes and members, so construction is guaranteed a "bottom up" construction, making the parts first.

C++ adds language support for two specially important aspects of the idea of construction from parts:

• If a constructor fails (by throwing an exception), then parts that have been successfully constructed are destroyed, automatically, and memory for the object is deallocated, automatically.
• During execution of the body of a constructor of a type T the object is of type T, so calls to virtual methods will resolve as if the object is of type T (which it is, at this point), where T can be a base class of the class you instantiated.

The first point means that with a properly designed C++ class, when you have an object at hand it's guaranteed usable as-is. If the construction fails then you simply don't end up with an object at hand.

Also, the rules of C++ are designed to ensure that for every object of most derived class T there is one and only one T constructor call. I used to call it the single constructor call guarantee. It's not specified as such any place in the standard, and you can foil it by using very low level facilities of the language, but it's there, it's what the detailed rules of the standard are designed to accomplish (it's much the same as you won't find any single rule about semicolon-termination of statements, yet all the myriad syntax rules for various statements conspire to yield a simple high level rule).

The single constructor call guarantee, and the automatic cleanup guarantee, and the changing type of an object as constructors of base classes are exectued, are perhaps the three most important differences from a Python object construction.

There's much much more to be said, but I think these are the most important ideas.

Cheers & hth.,

Answer 3

The distinction that the author draws is that, as far as the Python language is concerned, you have a valid object of the specified type before you even enter __init__. Therefore it's not a "constructor", since in C++ and theoretically, a constructor turns an invalid, pre-constructed object into a "proper" completed object of the type.

Basically __new__ in Python is defined to return "the new object instance", whereas C++ new operators just return some memory, which is not yet an instance of any class.

However, __init__ in Python is probably where you first establish some important class invariants (what attributes it has, just for starters). So as far as the users of your class are concerned, it might as well be a constructor. It's just that the Python runtime doesn't care about any of those invariants. If you like, it has very low standards for what constitutes a constructed object.

I think the author makes a fair point, and it's certainly an interesting remark on the way that Python creates objects. It's quite a fine distinction, though and I doubt that calling __init__ a constructor will ever result in broken code.

Also, I note that the Python documentation refers to __init__ as a constructor (http://docs.python.org/release/2.5.2/ref/customization.html)

As a special constraint on constructors, no value may be returned

... so if there are any practical problems with thinking of __init__ as a constructor, then Python is in trouble!

The way that Python and C++ construct objects have some similarities. Both call a function with a relatively simple responsibility (__new__ for an object instance vs some version of operator new for raw memory), then both call a function which has the opportunity to do more work to initialize the object into a useful state (__init__ vs a constructor).

Practical differences include:

• in C++, no-arg constructors for base classes are called automatically in the appropriate order if necessary, whereas for __init__ in Python, you have to explicitly init your base in your own __init__. Even in C++, you have to specify the base class constructor if it has arguments.

• in C++, you have a whole mechanism for what happens when a constructor throws an exception, in terms of calling destructors for sub-objects that have already been constructed. In Python I think the runtime (at most) calls __del__.

Then there's also the difference that __new__ doesn't just allocate memory, it has to return an actual object instance. Then again, raw memory isn't really a concept that applies to Python code.

Answer 4

A constructor in many other languages allocates space for the object being constructed; in Python this is the job of the allocator method, __new__(). __init__() is just an initializer method.