关于C++继承的几个问题

1、一般来说，子类不会继承基类的构造函数、析构函数和重载的赋值运算符，但可以使用它们，也不可以继承友元函数。

2、子类可以继承private类型的成员（包括数据和函数），但不可以直接访问它们，可以通过非private的成员函数去间接访问它们。

#include<iostream>
using namespace std;

class A
{
public:
    void setData(int data)
    {
        this->data = data;
    }

    int getData()
    {
        return data;
    }

    void print1()
    {
        print();
    }
    
private:
    int data;
    void print()
    {
        cout << "A" << endl;
    }
};

class B : public A
{
};

int main()
{
    B b;
    b.setData(2);
    cout << b.getData() << endl;//子类间接访问data数据
    b.print1();//子类间接使用print()函数
}

输出

2
A

3、使用protected数据的两个问题：

(1)子类可以直接访问到基类的protected数据，而不需要通过成员函数。这样的话，在子类重写一个设置数据的函数就可以进行非法数据的赋值。

#include<iostream>
using namespace std;

class A
{
public:
    void setData(int data)
    {
        if (data < 0) this->data = 0;
        else this->data = data;
    }

    int getData()
    {
        return data;
    }
    
protected:
    int data;
};

class B : public A
{
public:
    void setData1(int data)
    {
        this->data = data;
    }
};

int main()
{
    A a;
    B b;

    a.setData(-1);
    cout << a.getData() << endl;
    a.setData(1);
    cout << a.getData() << endl;

    b.setData1(1);
    cout << b.getData() << endl;
    b.setData1(-1);
    cout << b.getData() << endl;
}

 输出

0
1
1
-1

(2)使用protected数据，可能使得子类成员函数的实现十分依赖于基类的实现。例如，若将基类中的protected数据重命名，则所有子类中直接使用该数据的地方都要进行修改。

4、关于构造函数

(1)基类有无参数的构造函数。当声明一个子类对象时，如果子类中没有显式地调用基类中的构造函数的话，编译器会隐式调用基类的无参数构造函数，然后再调用子类的构造函数（如果存在的话）。

#include<iostream>
using namespace std;

class A
{
public:
    A()
    {
        cout << "A" << endl;
    }
    A(int i)
    {
        cout << i << endl;
    }
    A(int j, int k)
    {
        cout << j << " " << k << endl;
    }
};

class B : public A
{
public:
    B()
    {
        cout << "B" << endl;
    }
    B(int i)
    {
        cout << i << endl;
    }
};

int main()
{
    A a;//会调用无参数的构造函数，或是有参数但是都具有默认值的构造函数
    A a1();//不会构造函数
    B b;//隐式调用基类无参数的构造函数
    B b1();//不调用构造函数
    B b2(1);
}

输出 

A
A
B
A
1

(2)基类只有有参数的构造函数。此时，子类中的构造函数必须显式地调用基类中相应的构造函数，然后再调用子类中相应的构造函数（如果存在的话）。此时子类不能存在无参数的构造函数，因为基类中不存在默认构造函数。

#include<iostream>
using namespace std;

class A
{
public:
    A(int i)
    {
        cout << i << endl;
    }
    A(int j, int k)
    {
        cout << j << " " << k << endl;
    }
};

class B : public A
{
public:
    B(int i) : A(i)
    {
        cout << "B: " << i << endl;
    }
    B(int j, int k) : A(j, k)
    {
        cout << "B: " << j << " " << k << endl;
    }
};

int main()
{
    A a(1);
    A a1(1,2);
    B b(1);
    B b1(1,2);
}

输出 

1
1 2
1
B: 1
1 2
B: 1 2

（C++小白，记录学习过程

若有问题，还望大佬指正！！）