How to handle required default constructor

Question

In writing a copy constructor for one of my classes ( which holds a few objects of other UDTs ), I am required to create a default constructor for those UDTs, even though they were never really meant to have one.

Is it fine to just implement a blank default constructor and be done with it? The only time the default constructor is invoked is during this copying, when the object is created and then the values of the corresponding object are copied to it. Thus, whatever values are assigned to the object in the default constructor will never actually be used.

The problem I see is that some member variables aren't initialized in a blank default constructor. Should I just write one that gives dummy values instead? Any other recommended ways to handle this?

Edit: I understand that a copy constructor doesn't NEED a default constructor if I were to define copy constructors for the other classes, but I didn't, so it does need it.

Answer 1

You say:

when the object is created and then the values of the corresponding object are copied to it.

But ask yourself - how do the values of that "corresponding object" get there in the first place. I.e. how was the corresponding object created?

This previous SO discussion may help clarify matters for you.

Answer 2

Are you actually sure you need a copy constructor? It's unusual (but not impossible) to have a class where the default constructor would be OK, but you need a custom copy constructor. Perhaps you could post the code for your class?

Answer 3

This doesn't sound like the best way to implement a copy constructor. If the contained types provide copy constructors themselves - use those. There might be a reason a type does not provide a default constructor after all.

Answer 4

You can prevent the default constructor by requiring the other object to have copy constructors also (Or use special constructor which pass in all information needed to construct the objects. Generally having default constructor which don't initialize all member variables is a very bad idea. At a minimum make sure the default constructors of the other class initializes all members.

Answer 5

It sounds to me like you need to define copy c'tors for the other classes, as you are creating objects of them by copying other objects.

Answer 6

If you use an initializer list in the copy constructor, you don't need a default constructor:

#include <iostream>
using namespace std;
class Foo {
  Foo();            /* no default constructor */
public:
  Foo(int i)        { cout << "Foo constructor (int)"  << endl; }
  Foo(const Foo& f) { cout << "Foo constructor (copy)" << endl; }
};
class Bar {
  Foo f;
public:
  Bar()             : f(1)   { cout << "Bar constructor (default)" << endl; }
  Bar(const Bar& b) : f(b.f) { cout << "Bar constructor (copy)"    << endl; }
};
int main(void) {
  Bar b;
  Bar b_=b;
  return 0;
}

Results in:

Foo constructor (int)
Bar constructor (default)
Foo constructor (copy)
Bar constructor (copy)

Answer 7

Remember a thumb rule that as far as something is not part of specification , compiler won't do it for you.

If your class contain user defined type and when you create object of it , then compiler has to call default constuctor for each object.

But to initialize data members of object is not complier's task, but you are suppose to do it.

For the case you have mentioned , you need your own custom copy constructor and assignment operator.

Answer 8

If you don't want the compiler to generate a copy constructor or don't want a copy constructor at all, then declare a private copy constructor but don't provide any definition (code) for it. The compiler will see the declarations and not generate one. Also do this with the assignment operator.

I do this with my singleton classes.

Answer 9

If your class isnt meant to be defaultly constructed, don't create a default constructor. If it is, then I'm sure you can figure out a sensible initialization, so that's what you should be using.

Answer 10

The question, the way you stated it, appears to make no sense. Copy-constructor does not need the default constructor, as you seem to believe. Copy-constructor is a completely independent full-fledged constructor that construct an object completely by itself.

If you construct your objects with copy-constructor, then you don't need a default one. If you construct your objects with default constructor, then you can't use the copy-constructor on them. It is not possible to "apply" two different constructors to the same object.

If you construct your objects in both ways, then they become two completely independent constructors, each having its own independent purpose. In this case the question you should be asking yourself is how you want your objects to be defualt-constructed. Only you know that.

Again, you need to clarify your question. I would suspect (from your description) that maybe what you are trying to implement is not copy-constructor, but a copy-assignment operator. But that's just a wild guess.