c + +多态性：segfault和引用数组的奇怪行为

Question

Here is a MWE that, when compiled with g++ -std=c++11 , produces a segmentation fault:

#include <iostream>
#include <random>

class Rand{
    public:
        Rand(double const& min_inclusive, double const& max_exclusive):
            mt_(std::random_device()()),
            dist_(min_inclusive,max_exclusive){}
        ~Rand(){}
        double get() { return dist_(mt_); }
    private:
        std::mt19937_64 mt_;
        std::uniform_real_distribution<double> dist_;
};

class Base {
    public:
        Base():rnd(0.0,1.0){ std::cout<<"Base created "<<&rnd<<" "<<rnd.get()<<std::endl; }
        virtual ~Base(){};
        Rand rnd;
};

class Child: public Base{
    public:
        Child():var(1.0){ std::cout<<"Child created"<<std::endl; }
        double var;
};

class Other {
    public:
        Other(Base* b):b(b){  std::cout<<"Other created "<<&(b[0].rnd)<<" and "<<&(b[1].rnd)<<"--->"<<b[0].rnd.get()<<" "<<b[1].rnd.get()<<std::endl; }
        Base* b;
};

int main(){
    unsigned int N(2);
    std::cout<<"#############"<<std::endl;
    Base* b(new Base[N]);
    Other o1(b);
    std::cout<<"#############"<<std::endl;
    Child* c(new Child[N]);
    Other o2(c);
    std::cout<<"#############"<<std::endl;
    delete[] b;
    delete[] c;
}

The typical output is :

#############
Base created 0x239c020 0.226514
Base created 0x239ca00 0.902337
Other created 0x239c020 and 0x239ca00--->0.864321 0.302185
#############
Base created 0x239d3f0 0.573563
Child created
Base created 0x239ddd8 0.422187
Child created
Other created 0x239d3f0 and 0x239ddd0--->0.909183 4.94066e-324
#############

In the first part where a Base class is given to Other the references are coherent and the code runs properly.

But when a Child class is given to Other , the first reference is identical but the second is slightly different. The direct consequence of that is that the b[1].rdn.get() is always (very close) '0'. The other indirect consequence is that the code ends with a SegFault...

Moreover, when Child::var is absent, the program works fine, all references are coherent and there is no SegFault.

What am I doing wrong ? Is it impossible to create Other with a child of Base ? If so, it looks like the polymorphism is ruined...

EDIT

According to a nice answer :

#include <iostream>
#include <random>
#include <vector>
#include <memory>

class Rand{
    public:
        Rand(double const& min_inclusive, double const& max_exclusive):
            mt_(std::random_device()()),
            dist_(min_inclusive,max_exclusive){}
        ~Rand(){}
        double get() { return dist_(mt_); }
    private:
        std::mt19937_64 mt_;
        std::uniform_real_distribution<double> dist_;
};

class Base {
    public:
        Base():rnd(0.0,1.0){ std::cout<<"Base created "<<&rnd<<" "<<rnd.get()<<std::endl; }
        virtual ~Base(){};
        Rand rnd;
};

class Child: public Base{
    public:
        Child():var(0.0){ std::cout<<"Child created"<<std::endl; }
        double var;
};

template<typename Type>
class Other {
    public:
        Other(unsigned int N):b_(N){
            std::cout<<"Other created "<<std::endl;
            for(unsigned int i(0);i<b_.size();i++){
                b_[i] = std::make_shared<Type>();
            }
        }
        std::vector<std::shared_ptr<Base> > b_;
};

int main(){
    unsigned int N(2);
    std::cout<<"#############"<<std::endl;
    Other<Base> o1(N);
    std::cout<<"#############"<<std::endl;
    Other<Child> o2(N);
    std::cout<<"#############"<<std::endl;
}

Answer 1

If you have an array of Child you can't treat it as an array of Base . This means that when for example you call b[1].rnd.get() , you invoke undefined behavior.

Why is that? When you have a Child* c and you convert it to Base* , the result of conversion is a pointer to a Base subobject of Child . So (Base*)c + 1 will point to the next byte after that subobject, which in your case is the first byte of var .

When Child doesn't have data members, (Base*)c + 1 points to the next object, so everything works.

In order to achieve polymorphic behavior you should create an array of pointers to Base :

Base** b{new Base*[N]};

Initialize each array element with whatever descendant of Base and enjoy polymorphism.

Edit: as it was reasonably pointed out by vsoftco in the comments, it's better not to use raw pointers and arrays:

std::vector<std::shared_ptr<Base>> b {...}