Typedef for complicated base class

Question

I am using private inheritance to model my has-a relationship, but my base class type is rather complicated (well, a little bit), and I would like to have a typedef for it. Is something like the following possible in C++

struct S : private typedef std::vector<int> Container {};

Currently I am doing:

template< typename Container = std::vector<int> >
struct S : private Container {};

But this

makes my class to a template class. This is not a big problem for my current application (since it is a template class anyway), but in general is not nice.
could lead to bugs, when people think they are allowed to specify their own container.

Declare the `typedef` (or `using`) as a member? Note that inheriting from `std::vector` is generally not advisable, use a member instead — Alan Birtles, Jan 15 '23 at 20:33
You either have to make your typedef outside the class then inherit from that or live with having to type it in twice. If the vector was a member variable you wouldn't have a or problem — Alan Birtles, Jan 15 '23 at 20:37
You can just use the injected class name. Inside `S` the base is named by `vector`. — StoryTeller - Unslander Monica, Jan 15 '23 at 20:56

score 1 · Accepted Answer · answered Jan 15 '23 at 23:02

Considering that:

Inheriting from standard containers is not advisable;
Composition can replace private inheritance in most cases;
You want to control the container that will be used;

you could prefer private composition:

struct S {
  using Container = std::vector<int>; // outside struct also possible
  private: Container container;  
};

There is no code duplication here: with inheritance, you'd just have a container sub-object whereas with composition you'd have a container member, and both would use the same code.

There is no decisive advantage of private inheritance, since other classes could not use the public members defined in the base class. The only advantage is that you can use public members in the class definition, whereas with composition, you'll have to prefix the member with the object name.

In my real code, I do not inherit from std:: containers, but from my own ones. (I am writing a container for Cuda), and since Cuda-C++ is quite limited, I have a lot of SFINAE, and each member function is implemented roughly three times. Thus, private inheritance is much easier to work with from this point of view. — tommsch, Jan 16 '23 at 09:24

Typedef for complicated base class

1 Answers1