如何在派生类构造函数中初始化基类成员变量？

我为什么不能这样做？

class A
{
public:
    int a, b;
};

class B : public A
{
    B() : A(), a(0), b(0)
    {
    }

};

你不能初始化a，并b在B因为它们不是成员B。它们是的成员A，因此只能对其A进行初始化。您可以将它们公开，然后在中进行分配B，但是不建议这样做，因为这会破坏封装。而是在中创建一个构造函数A以允许B（或的任何子类A）对其进行初始化：

class A 
{
protected:
    A(int a, int b) : a(a), b(b) {} // Accessible to derived classes
    // Change "protected" to "public" to allow others to instantiate A.
private:
    int a, b; // Keep these variables private in A
};

class B : public A 
{
public:
    B() : A(0, 0) // Calls A's constructor, initializing a and b in A to 0.
    {
    } 
};

撇开事实，他们是private，因为a和b是的成员A，他们是为了通过初始化A的构造函数，而不是由一些其他类的构造函数（衍生与否）。

尝试：

class A
{
    int a, b;

protected: // or public:
    A(int a, int b): a(a), b(b) {}
};

class B : public A
{
    B() : A(0, 0) {}
};

不知何故，没有人列出最简单的方法：

class A
{
public:
    int a, b;
};

class B : public A
{
    B()
    {
        a = 0;
        b = 0;
    }

};

你不能在初始化列表中访问基地的成员，但构造函数本身，就像任何其他成员方法，可以访问public和protected基类的成员。

# include<stdio.h>
# include<iostream>
# include<conio.h>

using namespace std;

class Base{
    public:
        Base(int i, float f, double d): i(i), f(f), d(d)
        {
        }
    virtual void Show()=0;
    protected:
        int i;
        float f;
        double d;
};


class Derived: public Base{
    public:
        Derived(int i, float f, double d): Base( i, f, d)
        {
        }
        void Show()
        {
            cout<< "int i = "<<i<<endl<<"float f = "<<f<<endl <<"double d = "<<d<<endl;
        }
};

int main(){
    Base * b = new Derived(10, 1.2, 3.89);
    b->Show();
    return 0;
}

如果您要初始化派生类对象中存在的基类数据成员，而您想通过派生类构造函数调用来推送这些值，则这是一个工作示例。

虽然这在极少数情况下很有用（如果不是这种情况，则该语言会直接允许使用），但请查看Member idiom中的Base。这不是一个无代码的解决方案，您必须添加一个额外的继承层，但是它可以完成工作。为了避免样板代码，您可以使用boost的实现

你为什么不能这样做？因为该语言不允许您在派生类的初始化程序列表中初始化基类的成员。

你怎么能做到这一点？像这样：

class A
{
public:
    A(int a, int b) : a_(a), b_(b) {};
    int a_, b_;
};

class B : public A
{
public:
    B() : A(0,0) 
    {
    }
};

如果您没有为类成员指定可见性，则默认为“私有”。如果要在子类中访问成员，则应将其设为私有或受保护。

聚合类（如您的example（*）中的A）必须将其成员公开，并且没有用户定义的构造函数。它们通过初始化器列表初始化，例如A a {0,0};或在您的情况下B() : A({0,0}){}。基本集合类的成员不能在派生类的构造函数中单独初始化。

（*）确切地说，正如正确提到的那样，class A由于私人非静态成员的缘故，原件并非汇总