C++ inheritance with non-default constructors

Question

For a project I am looking at a case where the following situation exists. There is a class foo which requires an identifying number x when constructed. So its constructor argument looks something like foo(x).

Now I want to derive a class based on foo, called bar, which will basically hold two foo's internally and to the outside world acts as a single foo. The way I want to do this is by use of two constructor arguments y and z for bar, which will then, in the constructor, generate foo(y) and foo(z). I hope it's clear.

My current implementation looks something like:

class bar : public foo {
public:
    bar(int y, int z)
    {
        _foo_ptr_1 = foo::foo(y);
        _foo_ptr_2 = foo::foo(z);
    };

private:
    foo *_foo_ptr_1;
    foo *_foo_ptr_2;
};

Where foo is a class that is an already existing class looking something like:

class foo {
public:
    foo(int x) :
    _private_var(x) {
    };
};

Now, I know that since foo has no default constructor with zero arguments this will not work. I would prefer not to add a meaningless constructor with zero arguments to foo for several reasons. Is there a nice way to get this working? Right now my compiler (gcc under Ubuntu) gives me the following error:

error::no matching function for call to foo::foo()

A quick attempt to try and work around this is by replacing the constructor of bar:

bar(int y, int z) : foo(y)

But this also does not work.

I have not been able to find a working solution for this yet online, and would be gratefull for any help.

_foo_ptr_1 = foo::foo(y) is not how you construct classes in C++! — Rook
– Rook, Commented May 15, 2014 at 14:55
Are you sure you have foo *_foo_ptr_1; in your real code? Where is this error message issued? — πάντα ῥεῖ
– πάντα ῥεῖ, Commented May 15, 2014 at 14:56
Since bar is a foo itself, are you sure you need additional two foos inside? Maybe one additional foo would be enough? — Paweł Stawarz
– Paweł Stawarz, Commented May 15, 2014 at 15:04
Does bar need its own ID? in which case it should accept one as an argument. If it does not need an ID, why is it inheriting from foo? — Rook
– Rook, Commented May 15, 2014 at 15:06

Community · Accepted Answer · 2017-05-23 12:21:25Z

4

The problem here is that you are trying to work around the inheritance.

By deriving form foo you are saying that a bar is a foo. And a foo has a _private_var, so you have to fill this var with a meaningful value.

If you want to act in the same way as a foo, but not share its implementation, you want to share only an interface with foo. This is done in C++ by using a class with only pure virtual functions and a default constructor. For instance call it foo_interface. This should then be implemented by foo (with a 'real' implementation) and by bar with an implementation to combines the results of two foo's

Also you shoudl instantiate foo* in a different way:

   _foo_ptr_1 = foo::foo(y);

should be

   _foo_ptr_1 = new foo(y);

or even better, if you can, don't make foo a pointer. As explained here: https://stackoverflow.com/a/23681932/137369

edited May 23, 2017 at 12:21

CommunityBot

11 silver badge

answered May 15, 2014 at 15:03

Thirler

20.8k14 gold badges68 silver badges98 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Rook · Accepted Answer · 2014-05-15 15:03:57Z

3

This works just fine for me:

bar(int y, int z) : foo(y)
{
  _foo_ptr_1 = new foo(y);
  _foo_ptr_2 = new foo(z);
}

Please not that trying to invoke a class constructor directly like it was a static method is not how classes are constructed in C++. At the very least, you use new classname(arguments), as above.

This is not really recommended however... explicit memory management using new and delete is easy to get wrong.

First, consider that you may not have to allocate any foo instances at all.. you can just have simple member variables:

class bar : public foo {
public:
  bar(int y, int z) : foo(y), _foo_1(y), _foo_2(z)
  {
  }

private:
  foo _foo_1;
  foo _foo_2;
};

If you really must construct new instances the hard way, you should consider using smart pointers such as unique_ptr.

class bar : public foo {
public:
  bar(int y, int z) : foo(y), _foo_ptr_1(new foo(y)), _foo_ptr_2(new foo(z))
  {
  }

private:
  std::unique_ptr<foo> _foo_ptr_1;
  std::unique_ptr<foo> _foo_ptr_2;
};

unique_ptr ensures that your resources are correctly deallocated when their owner is destroyed. If your _foo member variables don't belong exclusively to their parent bar instance, then you can use shared_ptr instead. It is well worth reading up on the use of these utility classes.

edited May 15, 2014 at 15:03

answered May 15, 2014 at 14:58

Rook

6,2053 gold badges39 silver badges45 bronze badges

2 Comments

Thirler Over a year ago

+1 for everyone that suggests not to use pointers when you can avoid them ;)

ws7 Over a year ago

This seems to be working, at least for the trimmed down case, so thanks a lot.

Collectives™ on Stack Overflow

C++ inheritance with non-default constructors

2 Answers 2

Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related