Is a default constructor called on a class member variable if I am explicitly constructing it in the class constructor in c++?

Question

So if I have something like the following:

class MyClass{
    public:
        MyClass(){
            // do other stuff
            *oc = OtherClass(params);
        }
    private:
        OtherClass* oc;
}

When is a constructor called on OtherClass? Would its default be called once as soon as the MyClass initialization begins, and then be redefined with its value constructor during the MyClass constructor? Or does it just not exist during "//do other stuff". What if no default constructor is provided for other class, only a value? Would it be good practice to construct it where it is defined as a member variable?

not exactly a dupe but give this a read: https://stackoverflow.com/questions/1711990/what-is-this-weird-colon-member-syntax-in-the-constructor — NathanOliver, Jun 15 '22 at 13:31
`*oc = OtherClass(params);` may be a cause of crash if the pointer `oc` is not initialzied in "do other stuff". — MikeCAT, Jun 15 '22 at 13:32
@MikeCAT In theory it is being initialized in the MyClass constructor here, so there would be a crash no? Or do you mean it would need an earlier initialization before the *oc = OtherClass(params)? — , Jun 15 '22 at 13:34
Your class has a pointer. Pointers do not have constructors (or destructors) — john, Jun 15 '22 at 13:35
@qwerasdfzxcv Your class has a pointer, the pointer is not being initialised anywhere, therefore using the pointer results in a (likely) crash. — john, Jun 15 '22 at 13:35
@qwerasdfzxcv If you removed both `*` from the code above then the code would reflect the question you are trying to ask (I think). And the answer to that question would be yes, the default constructor would be called. — john, Jun 15 '22 at 13:37
Is there someway I can use a pointer there and have it initialize successfully? — , Jun 15 '22 at 13:46

score 0 · Answer 1 · answered Jun 15 '22 at 13:38

A default constructor is one that can be called without parameters. For example this is a default constructor:

struct foo { 
    foo(){}    // (should not actually be user defined)
};

This is also a default constructor:

struct bar {
    bar(int x = 42) {}
};

In your code it might be that the constructor that is called is a default constructor, but it does not matter for your code, because you do pass a parameter.

When is a constructor called on OtherClass?

In the line *oc = OtherClass(params);.

Would its default be called once as soon as the MyClass initialization begins, and then be redefined with its value constructor during the MyClass constructor?

If you do not provide an initializer members are default initialized. Confusingly for a pointer this means it is not initialized.

Or does it just not exist during "//do other stuff".

The member does exist before, but its value is indeterminate. You cannot use the value without invoking undefined behavior.

What if no default constructor is provided for other class, only a value?

See above. The existance of a default constructor of OtherClass is not relavant here. It would be relevant if the member was OtherClass and not a pointer, because for members of class type default initialization calls the default constructor.

Would it be good practice to construct it where it is defined as a member variable?

It is good practice to provide an initializer for members rather than assign in the constructor:

class MyClass{
    public:
        MyClass() : oc(params) {
        }
    private:
    

    OtherClass oc;
}

I replaced the member with an instance rather than a pointer, because using a raw pointer as member opens up a can of worms that would require an even longer answer. For more on that read What is The Rule of Three?. Note that when the member is not a pointer but a OtherClass then suddenly it matters if OtherClass has a default constructor, because if you do not provide an initializer, then the member will be default constructed. Though in the above I used the member initializer list and the member will be initialized by the constructor that takes one parameter.

Goswin von Brederlow · Answer 2 · 2022-06-15T20:15:26.140

ÓtherClass *oc; is a pointer and as such has no constructor. It has to be initialized to a valid object before you can dereference it.

You can ensure oc is initialized by, well, initializing it:

MyClass() : oc(new OtherClass()) {
    ...
    *oc = OtherClass(params);
}

This will create a dummy oc when the class it created and then copy or move assign the real object to *oc later. This is wasteful, so why not initialize it with the final value directly:

MyClass() : oc(new OtherClass(params)) {
    ...
}

or if you have to compute params first:

MyClass : oc(nullptr) {
    ...
    oc = new OtherClass(params);
}

Initializing oc with nullptr first isn't required but it is dirt cheap and it ensures accidentally using oc will access a nullptr and fail instead of oc being some random value that might not crash.

You can also, and better, ensure initialization by inlineing that:

class MyClass {
    ...
    private:
        OtherClass *oc(nullptr);
}

With that the compiler will initialize oc whenever you don't initialize it in an initializer list in the constructor.

That said: Do you really need a pointer there? You need a destructor, copy/move constructors and aissgnment operators to handle the pointer directly. An Otherclass oc; would be much easier to deal with.

But if you do need a pointer then you should use a smart pointer to handle ownership for you. That means use std::unique_ptr or more likely std::shared_ptr for it. You might not even need anything past the constructor that way. But think about what it means for copy/move to have the pointer shared. Read about the rule of 0/3/5.

Is a default constructor called on a class member variable if I am explicitly constructing it in the class constructor in c++?

2 Answers2