Is having std::vector of a class as an attribute the same class a good design choice?

Question

My problem statement is as below. There is a concept of "domain" which consists of many "subdomains". Now, those subdomains are domains in their own right. Following is the basic method I can do the things. I can probably use an auto_ptr or something, but lets leave it for now.

class Domain
{
private:
    Domain* subdomains;
}

However, I was able to compile and run the following program which I think does the same thing and gives me what I want.

#include <iostream>
#include <vector>
#include <string>

class Domain
{
private:
    std::string name_;
public:
    std::vector<Domain> subdomains;
    Domain(std::string name) : name_(name) {};
    std::string name() {return name_;}
    void addSubDomain(std::string subDomainName);
};

void Domain::addSubDomain(std::string subDomainName)
{
    subdomain.push_back(Domain(subDomainName));
}

int main()
{
    std::cout<<"Hello, World"<<std::endl;
    Domain domain("wow");
    domain.addSubDomain("wow-child");
    std::cout<<"Domain name is "<<domain.name()<<std::endl;
    std::cout<<"Subdomain name is "<<domain.subdomain[0].name()<<std::endl;
    return 0;
}

The output which I get on running this is

$./main 
Hello, World
Domain name is wow
Subdomain name is wow-child

My question is whether there are any pitfalls that I may have missed while implementing the following thing? Right now, there is nothing I can see. If there are no pitfalls, then this is the a really good solution to my problems.

EDIT

In case this is not a solution, then is there another solution that I can use which does not involve the management of raw pointers?

Answer 1

This is undefined behavior because at the point you define the member, the class is not yet completely defined. At that point, std::vector<Domain> needs to be instantiated though, from the template std::vector<T> to a class std::vector<Domain> (to determine its size, among others). When that instantiation happens, the Standard requires the class to be completely defined.

Answer 2

As Johannes correctly points out, your program is undefined. But, your program would be perfectly valid if it did this:

class Domain {
    …
    std::vector<Domain*> subdomains;
    …
};

Of course, you'd have to manage the pointers. (Exception safety, RAII, Rule of Three, etc, etc, etc).

Answer 3

After reading the other answers and many other questions from the stackoverflow. I would like to sum up the answer in my own words. Though Johannes has answered the question correctly, there is more to the answer that I would like to add. So, here it is.

1. The behaviour of the code given in the question is undefined in C++03 across all types of usages due to reasons given by Johannes's answer. However, in C++11 standard, the requirement has been changed. The behavior is still undefined unless the class specifically allows it.

   C++11 $17.6.4.8 Other functions (...) 2. the effects are undefined in the following cases: (...) In particular - if an incomplete type (3.9) is used as a template argument when instantiating a template component, unless specifically allowed for that component.

2. The current examples works because of the specfic implementation of the std::vector which does not contain any attributes of the type T but only of the type T*. Hence, this is a case of lucky compilation, which may or may not always work depending on the containers.

3. The solution to the problem is to currently use the Boost::Containers since they specifically support the incomplete types.

4. The std::unique_ptr and std::shared_ptr pointer can be used as a replacement for the raw pointer model for management if one wishes, with little catches. The answer to that question is here. And one can see the detailed explanation here. So, if one needs a std::container, then he can use the container of pointers using the above pointers. However, there are some conditions which must be satisfied. Those conditions are described in the links given above.

All in all, the best way right now is to use the boost::containers. However, they introduce a dependency on boost. In case you want to avoid the dependency, then you can use the std::unique_ptr and std::shared_ptr. However, there are some conditions and limitations as to what can be done.

boost::shared_ptr also allows incomplete types to be used. But, that too has some limitations.