C ++中的继承。 为什么错了？

Question

class Human 
{
    protected:
        string name;
    public:
        Human () : name ("Jim") {}
        Human (string n) : name (n) {}
};

class Adult : public Human
{
    private:
        string passportId;
    public:
        Adult ()// : name ("Eric"), passportId ("N0123") - *THIS IS ERROR* 
        {
            // this is ok
            name = "Eric";  
            passportId = "N0934956";
        }

        Adult (string n, string id)// : name(n), passportId(id) *THIS IS ERROR*
        { 
            // this is ok
            name = n;
            passportId = id;
        }
};

So we have base class Human and derived class Adult . in the code (where is the implementation of constructor) you can see comment lines.

Why is it wrong to use such initialization in this situation?

Adult (string n, string id) : name(n), passportId(id) {} // *THIS IS ERROR*

Answer 1

The correct form is:

Adult(string n, string id) : Human(n), passportId(id) {}

The initialization list is for initializing base classes and your own members. You don't initialize your bases' members, they do that themselves.

Answer 2

Using an initializer list you can only initialize your own member variables.

You have to use the Human constructor in the initializer list:

Adult (string n, string id)
    : Human(n), passportId(id)
    {}

Answer 3

The base class is being constructed before the derived class so you won't be able to instantiate the base class' members in the initialization list.

However, you can call the base class' constructor in the initialization list like this

Adult() : Human("Eric"), passportId("N0123") { } 

Answer 4

Before executing the member-initialization-list of Adult , the base class default-constructor is invoked and executed. During the base class subobject initialization, the member name (which is a member of the base class) is constructed (and initialized). That means, by the time the member initialization list of the derived class is executed, name already exists, which is why your program is ill-formed.

What you should be doing is : select the appropriate base class constructor so as to initialize name properly. Here is how you do it:

Adult (string n, string id) : Human(n), passportid(id) {}

Hope that helps.

Answer 5

Member initialiser lists (that is, the initialisers after : in a constructor) can only initialise base classes and members of the constructor's class. Initialising members of a base class is the job of the base class's constructor.

Answer 6

This does not work because you try to access a member of an object that has not been constructed yet. What you can do is

class Human 
{
    protected:
        string name;
    public:
        Human () : name ("Jim") {}
        Human (string n) : name (n) {}
};

class Adult : public Human
{
    private:
        string passportId;
    public:
        Adult () : Human ("Eric"), passportId ("N0123") 
        {
        }

        Adult (string n, string id) : Human(n), passportId(id)
        { 
        }
};

That works, because it instructs the compiler to create the base class part of your object with the given values. Later in the code - as you have done already within the constructor - you can access the protected members.

Answer 7

Because your derived class Adult contains Human as an object and you have to call its constructor in order to create it. When your Adult object dies, the destructors are called in reverse order. First Adult 's destructor then Human 's destructor.

Answer 8

In the first initialisation:

Adult ()// : name ("Eric"), passportId (N0123) - *THIS IS ERROR* 

you probably forgot the " around the passportId, and on the second:

Adult (string n, string id)// : name(name), passportId(id) *THIS IS ERROR*

I think you mixed up n and name , and also, looks like you should rather call the parent constructor like so:

Adult (string n, string id) : Human(n), passportId(id)

Answer 9

你把名字和n混在一起了吗？

Adult (string n, string id) : name(n), passportId(id) {}