从C语言到C++_22(继承)多继承与菱形继承+笔试选择题

GR鲸鱼

已于 2024-01-19 12:32:34 修改

阅读量862

点赞数 1

分类专栏： ④从C语言到熟悉C++ 文章标签： c++ STL 继承知识点深度学习

于 2023-06-27 17:50:09 首次发布

本文链接：https://blog.csdn.net/GRrtx/article/details/130989000

版权

④从C语言到熟悉C++ 专栏收录该内容

40 篇文章 4 订阅

订阅专栏

本文详细介绍了C++中的继承机制，包括继承的概念、定义格式、访问限定符、赋值操作以及作用域。通过实例解释了如何使用继承创建类层次结构，以及如何处理同名成员和成员函数。此外，还探讨了子类的构造函数、拷贝构造函数、赋值重载和析构函数的默认行为。最后，提到了继承与友元、静态成员的关系，以及多继承和菱形继承的问题及解决方案。

摘要由CSDN通过智能技术生成

回顾一下面向对象三大特性：封装、继承、多态。(其它特性：反射、抽象...)

前面我们学了封装，封装带来了上面好处？:

① C++ Stack 类设计和 C 设计 Stack 对比，封装更好、访问限定符 + 类狭义。

② 迭代器设计，如果没有迭代器，容器访问只能暴露底层结构。 -> 使用复杂、

使用成本很高，对使用者要求极高。

封装了容器底层结构，不暴露底层结构的情况，提供统一的访问容器的方式，

降低使用成本，简化使用。

③ stack/queue/priority_queue 的设计 —— 适配器模式。

现在我们讲讲继承。

1. 继承

1.1 继承的概念

继承（inheritance）机制是面向对象程序设计，使代码可以复用的最重要的手段。

它允许程序员在保持原有类特性的基础上进行扩展，以增加功能。这样产生新的类，称为派生类。

继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

以前我们接触的复用都是函数复用，而继承是类设计层次的复用。

举例：比如我们要设计一个图书管理系统，每个角色的权限是不同的。

角色类：学生、老师、保安、保洁、后勤…… 为了区分这些角色，我们就要设计一些类出来：

class Student
{
    string _name;
    string _tel;
    string _address;
    int _age;
    // ...

    string _stuID;  // 学号
};

class Teacher
{
    string _name;
    string _tel;
    string _address;
    int _age;
    // ...

    string _wordID;  // 工号
};

不难发现其存在大量冗余部分，有些信息是公共的，有些信息是每个角色独有的。

对于有些数据和方法是每个角色都具有的，我们每次都写一边，这就导致设计重复了。

我们说了代码是要讲究复用的，我们要想办法去做一个 "提取" ，把共有的成员变量提取出来。

解决方案：设计一个 Person 类

// 把共有的东西写进来
class Person 
{
    string _name;
    string _tel;
    string _address;
    int _age;
};

然后使用 "继承" 去把这些共有的东西运送给各个角色，先看语法：

class Person 
{
    string _name;
    string _tel;
    string _address;
    int _age;
};

// Student 公有继承了 Person 
class Student : public Person 
{
    string _stuID;  // 学号
};

// Teacher 公有继承了 Person 
class Teacher : public Person 
{
    string _wordID;  // 工号
};

这就是继承。在需要称为子类的类的类名后加上冒号，并跟上继承方式和父类类名即可。

比如说我们这里希望让 Student 以 public 的继承方式继承自 Person。

为了能够演示继承的效果，我们给 Person 类加上个 Print 打印函数：

（把成员函数也继承下来了）

#include<iostream>
using namespace std;

class Person 
{
public:
    void Print()
    {
        cout << "name: " << _name << endl;
        cout << "age:  " << _age << endl;
        cout << endl;
    }
protected:
    string _name = "user";
    string _tel;
    string _address;
    int _age = 18;
};

class Student : public Person
{
    string _stuID;  // 学号
};

class Teacher : public Person 
{
    string _wordID;  // 工号
};

int main()
{
    Person p;
    p.Print();

    Student s;
    s.Print();

    Teacher t;
    t.Print();

    return 0;
}

1.2 继承的定义格式

我们还是拿刚才的 Person 和 Student 举例：

class Student : public Person // Student是子类(派生类),public是继承方式,Person是父类(基类)
{
    string _stuID;  // 学号
};

Student是子类(派生类)，public是继承方式，Person是父类(基类)

把 Person 和 Student 看作是父子关系是比较容易理解的。

子承父业，孩子 Student 从父亲 Person 那里继承一些 "东西" ，

这里的继承方式是 public，即公有继承，还有其他的一些继承方式。

1.3 访问限定符和继承方式

三种访问限定符，分别是 public（公有）、protected（保护）、private（私有）。

这一听名字就能知道，公有就是随便用，保护和私有就是藏起来一点点不让你随便用得到。

① public 修饰的成员，可以在类外面随便访问（直接访问）。

② protected 和 private 修饰的成员，不能在类外随便访问。

③ 定义成 protected 可以让父类成员不能在类外直接访问，但可以在子类中访问。

public、protected、private 不仅仅是访问限定符，它们也可以表示继承的三种继承方式：

三种访问限定符和三种继承方式相碰撞，就产生了 3×3=9 种情况：

① 父类的 private 成员在子类种无论以何种方式继承都是不可见的。这里的不可见指的是父类的私有成员还是被继承到了子类对象中，但是语法上限制了子类对象不管在类里面还是类外都不能去访问父类的 private 成员。

② 父类 private 成员在子类种不能被访问，如果父类成员不想在类外被直接访问，但是想让它们在子类中能被访问，可定义为 protected。不难看出，保护成员限定符是因继承才出现的。

③ 实际上，上面的表格我们通过观察不难发现，父类的私有成员在子类都是不可见的，父类的其他成员在子类的访问方式 == Min（成员在父类的访问限定符，继承方式）：public > protected > private。

④ 使用关键字 class 时默认的继承方式是 private，使用 struct 时默认的继承方式是 public，但是最好还是显式的写出继承方式，提高代码可读性。

⑤ 一共 9 种组合，实际上是大佬们早期设计的时候想复杂了，实际中父类成员基本都是保护和公有，继承方式基本都是用公有继承，几乎很少使用 protected / private 继承。而且也不提倡使用 protected / private 继承，因为 protected / private 继承下来的成员都只能在子类里使用，实际扩展维护性不强。

1.4 继承中的赋值

子类对象可以赋值给父类的对象、父类的指针、父类的引用：

#include<iostream>
using namespace std;

class Person
{
protected:
    string _name;
    string _age;
};

class Student : public Person 
{
public:
    string _stuID;  // 学号
};

int main()
{
    Student s;
    // 子类对象可以赋值给父类对象/指针/引用
    Person p = s;
    Person* pp = &s;
    Person& rp = s;

    return 0;
}

这种操作我们称之为 "切割"（或切片），寓意是把子类中父类的那部分切过来赋值过去。

注意事项：

① 父类对象不能赋值给子类对象

② 父类的指针可以通过强转赋值给子类的指针，但是必须是父类的指针是指向子类对象时才是安全的。这里父类如果是多态类型，可以使用 RTTI（Run-Time Type Information，即运行时类型识别）的 dynamic_cast 来进行识别后进行安全转换。（后面讲解，先了解）

1.5 继承中的作用域

继承体系中的父类和子类都有独立的作用域，如果子类和父类有同名成员，

此时子类成员会屏蔽父类对同名成员的直接访问，这种情况叫做 "隐藏" （也叫重定义）。

在子类成员函数中，可以使用如下方式进行显式访问：

基类::基类成员

注意事项：

① 如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

② 实际运用中在继承体系里最好不要定义同名的成员。父类成员名称不要和子类成员名称冲突。

代码演示：父类和子类的成员函数同名的场景（注意父类和子类的 _num）

#include<iostream>
using namespace std;

class Person
{
protected:
    string _name = "李华";                // 姓名
    string _num = "56465456456464";  // 身份证号
};

class Student : public Person
{
public:
    void Print() 
    {
        cout << "姓名：" << _name << endl;
        cout << "身份证号：" << Person::_num << endl;  // 指定是Person的_num
        cout << "学号：" << _num << endl;  // 默认在自己作用域内找_num
    }
protected:
    string _num = "1007";  // 学号
};

int main(void)
{
    Student s1;
    s1.Print();

    return 0;
}

观察下列代码，A::func 和 B::func 的关系是重载还是隐藏？

#include<iostream>
using namespace std;

class A
{
public:
	void func() 
	{
		cout << "func()" << endl;
	}
};

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

int main() 
{
	B b;
	b.func(10);
}

解读：函数重载要求在同一作用域，我们说了，子类和父类都有独立的作用域，

因为不是在同一作用域，B 中的 func 和 A 中的 func 不可能构成重载，正确答案是构成隐藏。

B 中的 func 和 A 中的 func 构成隐藏，成员函数满足函数名相同就构成隐藏。

2. 子类(派生类)的默认成员函数

默认成员函数复习链接：从C语言到C++⑤(第二章_类和对象_中篇)(6个默认成员函数+运算符重载+const成员)_GR C的博客-CSDN博客

对于默认成员函数，如果不主动实现，编译器会自己生成一份。

那么这些默认成员函数在子类中，它们又是如何生成的？

2.1 子类的构造函数

① 父类成员需调用自己的构造完成初始化。即子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。

② 如果父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。

③ 子类对象初始化先调用父类构造再调子类构造。

代码演示：

#include <iostream>
using namespace std;

class Person 
{
public:
    Person(const char* name)
        : _name(name)
    {
        cout << "Person()" << endl;
    }
protected:
    string _name;
};

class Student : public Person 
{
public:
    Student(const char* name, int num)
        : Person(name)  // 父类成员，调用自己的构造完成初始化
        , _num(num)
    {
        cout << "Student()" << endl;
    }

protected:
    int _num;   // 学号
};

int main()
{
    Student s1("GR", 19);

    return 0;
}

调用父类构造函数初始化继承自父类的成员，自己再初始化自己的成员（规则参考普通类）。

析构、拷贝构造、赋值重载也是类似的。

思考：如何设计一个不能被继承的类？

将父类的构造函数私有化：

#include <iostream>
using namespace std;

class A
{
private:
    A()
    {}

protected:
	int _a;
};

class B : public A
{

};

int main()
{
    B b; // 只有实例化的时候才会报错
    return 0;
}

父类 A 的构造函数私有化后 B 就无法构造对象，因为 B 的构造函数必须要调用 A 的。

A a; 也不行了，A也没办法构造了，而且这只是C++98用的，

C++11提供了关键字 final 写在类的后面，表明这个类不能被继承：

#include <iostream>
using namespace std;

class A final
{

protected:
	int _a;
};

class B : public A // 错误	C3246	"B": 无法从 "A" 继承，因为它已声明为 "final"
{

};

int main()
{
    B b;
    return 0;
}

2.2 子类的拷贝构造函数

子类的拷贝构造函数必须调用父类的拷贝构造完成拷贝初始化：

#include <iostream>
using namespace std;

class Person 
{
public:
    Person(const char* name)
        : _name(name)
    {
        cout << "Person()" << endl;
    }

    Person(const Person& p)
        : _name(p._name)
    {
        cout << "Person(const Person& p)" << endl;
    }
protected:
    string _name;
};

class Student : public Person 
{
public:
    Student(const char* name, int num)
        : Person(name)
        , _num(num)
    {
        cout << "Student()" << endl;
    }

    Student(const Student& s)
        : Person(s)     // 子类的拷贝构造函数必须调用父类的拷贝构造完成拷贝初始化。
        , _num(s._num)
    {
        cout << "Student(const Student& s)" << endl;
    }
protected:
    int _num;   // 学号
};

int main() 
{
    Student s1("GR", 19);
    Student s2(s1);

    return 0;
}

2.3 子类的赋值重载

子类的 operator= 必须要调用父类的 operator= 完成父类的复制：

#include <iostream>
using namespace std;

class Person 
{
public:
    Person(const char* name)
        : _name(name)
    {
        cout << "Person()" << endl;
    }

    Person& operator=(const Person& p) 
    {
        cout << "Person& operator=(const Person& p)" << endl;
        if (this != &p) {
            _name = p._name;
        }
        return *this;
    }

protected:
    string _name;
};

class Student : public Person 
{
public:
    Student(const char* name, int num)
        : Person(name)
        , _num(num)
    {
        cout << "Student()" << endl;
    }
    Student& operator=(const Student& s) 
    {
        cout << "Student& operator=(const Student& s)" << endl;
        if (this != &s)
        {
            // 子类的 operator= 必须要调用父类的 operator= 完成父类的复制
            Person::operator=(s);
            _num = s._num;
        }
        return *this;
    }

protected:
    int _num;   // 学号
};

int main() 
{
    Student s1("GR", 19);
    Student s2("RL", 17);
    s1 = s2;
    return 0;
}

2.4 子类的析构函数

为了保证子类对象先清理子类成员再清理父类成员的顺序，先子后父。

子类析构先子后父，子类对象的析构清理是先调用子类析构再调父类析构。

子类析构函数完成后会自动调用父亲的析构函数，所以不需要我们显式调用。

且子类的析构的函数跟父类析构函数构成隐藏。

由于后面多态的需要，析构函数名字会统一处理成destructor()

（因为构成隐藏，所以非要显示调用的时候要加域作用符）因为要先析构子类，

所以不需要显示调用，编译器自动调用父类析构函数，这样才能保证先析构子类。

#include <iostream>
using namespace std;

class Person
{
public:
    Person(const char* name)
        : _name(name)
    {
        cout << "Person()" << endl;
    }
    ~Person() 
    {
        cout << "~Person()" << endl;
    }

protected:
    string _name;
};

class Student : public Person 
{
public:
    Student(const char* name, int num)
        : Person(name)  // 父类成员，调用自己的构造完成初始化
        , _num(num)
    {
        cout << "Student()" << endl;
    }

    ~Student() 
    {
        cout << "~Student()" << endl;

        //Person::~Person();  
        // 因为要先析构子类，所以不需要显示调用，编译器自动调用父类析构函数
    }

protected:
    int _num;   // 学号
};

int main() 
{
    Student s1("GR", 19);

    return 0;
}

2.5 小总结

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类
中，这几个成员函数是如何生成的呢？

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的operator = 必须要调用基类的operator = 完成基类的复制。
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化先调用基类构造再调派生类构造。
6. 派生类对象析构清理先调用派生类析构再调基类的析构。
7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

3. 继承与友元

友元关系不能继承，也就是说父类友元不能访问子类私有和保护成员。

#include<iostream>
using namespace std;

class Student;
class Person 
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};

class Student : public Person 
{
protected:
	int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._stuNum << endl; // 错误	C2248	“Student::_stuNum”: 无法访问 protected 成员(在“Student”类中声明)
}

void main()
{
	Person p;
	Student s;
	Display(p, s);
}

4. 继承与静态成员

父类定义了 static 静态成员，则整个继承体系里面中有一个这样的成员。

可以理解为共享，父类的静态成员可以在子类共享，父类和子类都能去访问它。

无论派生出多少个子类，都只有一个 static 成员实例：

和构造函数结合，我们就可以有以下应用：用 static 静态成员统计创建了多少个对象

#include <iostream>
using namespace std;

class Person
{
public:
	Person() 
	{
		++_count;
	}
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数
};

int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
	string _seminarCourse;
};

int main()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	Person s5;

	cout << "大家都可以访问：(创建了多少个对象)" << endl;
	cout << "人数：" << Person::_count << endl;
	cout << "人数：" << Student::_count << endl;
	cout << "人数：" << s4._count << endl;

	cout << "顺便一个类把静态成员改变：" << endl;
	s3._count = 0;
	cout << "人数：" << Person::_count << endl;

	cout << "并且他们的地址也都是一样的，因为所有继承体系中只有一个" << endl;
	cout << "人数：" << &Person::_count << endl;
	cout << "人数：" << &Student::_count << endl;
	cout << "人数：" << &s4._count << endl;

	return 0;
}

5. 多继承与菱形继承

先说说单继承，刚才我们讲的其实就是单继承。

单继承：一个子类只有一个直接父类，我们称这种继承关系为单继承。

多继承：一个子类有两个或以上直接父类，我们称这种继承关系为多继承。

大佬早期设计的时候认为多继承挺好的，这也没有出现什么大的毛病。

因为一个子类继承多个父类的情况也挺合理的，比如有的角色，既是学生也是老师；

房车，既是房子也是车；但实际慢慢用起来后问题就慢慢显现出来了，

有多继承就会产生 "菱形继承"。

5.1 菱形继承的概念

菱形继承，又称钻石继承，是多继承的一种特殊情况。

举个例子：研究生助教继承了学生和老师，学生和老师又都继承了人

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。

在Assistant的对象中Person成员会有两份。

#include <iostream>
using namespace std;

class Person 
{
public:
	string _name; // 姓名
};

class Student : public Person 
{
protected:
	int _num; //学号
};

class Teacher : public Person 
{
protected:
	int _id; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

int main()
{
	// 这样会有二义性无法明确知道访问的是哪一个
	Assistant a;
	//a._name = "peter"; // 错误	C2385	对“_name”的访问不明确

	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "GR";
	a.Teacher::_name = "RL";

	return 0;
}

二义性通过指定作用域是可以解决的，告诉编译器是从学生那继承的还是从老师那继承的。

但是数据冗余没有解决，数据冗余带来的最大问题是空间的浪费：

class Person 
{
public:
	string _name;
	int _arr[1000];   // 数据越大，浪费越大
};

5.2 虚拟继承解决菱形继承问题

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。

如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。

需要注意的是，虚拟继承不要在其他地方去使用。

代码：在类的腰部位置加一个 virtual 关键字：

class Person 
{
public:
	string _name;
	int _arr[1000];
};

// 虚继承
class Student : virtual public Person 
{
protected:
	int _num;
};

// 虚继承
class Teacher : virtual public Person 
{
protected:
	int _id;
};

class Assistant : public Student, public Teacher 
{
protected:
	string _majorCourse;
};

现在解决数据冗余的问题，那么它是具体怎么来做的，

这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，

这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到了A。

这里的B C就像两个人分别在两个不同的地方，但是都要去A这个地方，保存了A的地址，那么就可以用地图去导航，但是因为两个人所在的地方不一样，所以到A的距离肯定也会不一样，也就是A的偏移量肯定会不一样（这样说会比较好理解一点）。

很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度上就有问题并且菱形继承虚继承也带来了性能上的损耗（因为多开了地址来存放偏移量）。多继承可以认为是C++的缺陷之一，很多后来的面向对象语言都没有多继承，如Java。

6. 继承与组合

继承和组合：

public继承是一种 is-a 的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种 has-a 的关系。假设B组合了A，每个B对象中都有一个A对象。

继承和组合都可以用，优先使用对象组合，而不是类继承，有什么例子？：

继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用（white-box reuse）。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用（black-box reuse），因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承也可以用组合，就优先用组合。

class A 
{
	// ...
};

// 继承
class B : public A 
{
	// ...
};

class C
{
	// ...
};

// 组合
class D
{
	// ...
	C _c;
};

⬛ 黑箱复用：C对象公有成员D可以直接用，C对象保护成员D不能直接用。

⬜ 白箱复用：C对象公有成员D可以直接用，C对象保护成员D也可以直接用。

我们举个旅游的例子来讲解：

团体出行：人和人之间关系太紧密 —— 耦合度高

自由出行：人和人之间关系松散的，没有很多具体要求 —— 耦合度低

继承就是团体出行，A 任何成员的修改都有可能影响 B 的实现。

组合就是自由出行，C 只要不修改公有，就不会对 D 有影响。

以前提到过，软件开发最好实现：低耦合，高内聚。

总结：适合 is-a 关系，建议继承。适合 has-a 关系，建议组合。都可以，建议组合。

7. 继承的笔试选择题

1. 下面关于继承说法不正确的是（）

A.继承可以使用现有类的所有功能，并在无需重新编写原来类的情况下对这些功能进行扩展

B.继承体系中子类必须要体现出与基类的不同

C.子类对象一定比基类对象大

D.继承呈现了面相对象程序设计的层次结构，体现了有简单到复杂的认知过程

2. 关于继承说法正确的是（）

A.所有的类都可以被继承

B.Car(汽车)类和Tire(轮胎)类可以使用继承方式体现

C.继承是实现代码复用的唯一手段

D.狗是一种动物，可以体现出继承的思想

3. 下面关于访问权限与继承权限说法不正确的是（）

A.访问权限和继承权限是不同的概念

B.访问权限和继承权限关键字上是一样的，但是出现位置不一样

C.如果是protected继承方式，基类public的成员变量能通过基类对象在类外直接访问

D.基类私有的成员变量在子类中都不能直接访问，因为没有被子类继承了

4. 关于同名隐藏的说法正确的是（）

A.同一个类中，不能存在相同名称的成员函数

B.在基类和子类中，可以存在相同名称但参数列表不同的函数，他们形成重载

C.在基类和子类中，不能存在函数原型完全相同的函数，因为编译时会报错

D.成员函数可以同名，只要参数类型不同即可，成员变量不能同名，即使类型不同

5. 下面代码输出结果：( )

class A

{

public:

void f(){ cout<<"A::f()"<<endl; }

int a;

};

class B : public A

{

public:

void f(int a){cout<<"B::f()"<<endl;}

int a;

};

int main()

{

B b;

b.f();

return 0;

}

A.打印A::f()

B.打印B::f()

C.不能通过编译，因为基类和派生类中a的类型以及名称完全相同

D.以上说法都不对

6. 下面说法正确的是（）

A.派生类构造函数初始化列表的位置必须显式调用基类的构造函数，已完成基类部分成员的初始化

B.派生类构造函数先初始化子类成员，再初始化基类成员

C.派生类析构函数不会自动析构基类部分成员

D.子类构造函数的定义有时需要参考基类构造函数

7. 关于派生类构造函数与析构函数说法正确的是（）

A.在派生类对象构造时，先调用基类构造函数，后调用子类构造函数

B.在派生构造函数初始化列表的位置必须显式调用基类构造函数

C.在派生类对象销毁时，先调用基类析构函数，后调用子类析构函数

D.派生类的析构函数只需析构派生类的资源即可

8. 下列代码中f函数执行结束后输出（）

class A

{

public:

A() { cout<<"A::A()"<<endl; }

~A() { cout<<"A::~A()"<<endl; }

int a;

};

class B : public A

{

public:

B() { cout<<"B::B()"<<endl; }

~B() {cout<<"B::~B()"<<endl; }

int b;

};

void f()

{

B b;

}

A.B::B() B::~B()

B.B::B() A::A() A::~A() B::B()

C.A::A() B::B() B::~B() A::~A()

D.以上都不对

9. 下面关于继承权限说法正确的是（）

A.派生类在继承基类时，必须明确指定继承方式

B.Class定义的类，默认的访问权限是protected

C.struct定义的类，默认访问权限是public

D.子类没有继承基类私有的成员

10. 关于基类哪些成员被子类继承说法不正确的是（）

A.静态成员函数

B.所有成员变量

C.基类的友元函数

D.静态成员变量在整个继承体系中只有一份

11. 关于基类与派生类对象模型说法正确的是（）

A.基类对象中包含了所有基类的成员变量

B.子类对象中不仅包含了所有基类成员变量，也包含了所有子类成员变量

C.子类对象中没有包含基类的私有成员

D.基类的静态成员可以不包含在子类对象中

E.以上说法都不对

12. 关于基类与子类对象之间赋值说法不正确的是（）

A.基类指针可以直接指向子类对象

B.基类对象可以直接赋值给子类对象

C.子类对象的引用不能引用基类的对象

D.子类对象可以直接赋值给基类对象

13. 下面哪项结果是正确的（）

class Base1 { public: int _b1; };

class Base2 { public: int _b2; };

class Derive : public Base1, public Base2

{ public: int _d; };

int main(){

Derive d;

Base1* p1 = &d;

Base2* p2 = &d;

Derive* p3 = &d;

return 0;

}

A.p1 == p2 == p3

B.p1 < p2 < p3

C.p1 == p3 != p2

D.p1 != p2 != p3

14. 关于以下菱形继承说法不正确的是（）

class B {public: int b;};

class C1: public B {public: int c1;};

class C2: public B {public: int c2;};

class D : public C1, public C2 {public: int d;};

A.D总共占了20个字节

B.B中的内容总共在D对象中存储了两份

C.D对象可以直接访问从基类继承的b成员

D.菱形继承存在二义性问题，尽量避免设计菱形继承

答案：

1. C

A.这是继承的功能，也是代码复用的体现

B.继承除了吸收基类成员之外，一般还需要扩充自己的数据成员，跟基类有所不一样

C.不一定，有可能子类只是改写父类的方法而已，

并没有增加其自身的数据成员，则大小一样，故错误

D.继承体现了一定的层次结构和认知过程

2. D

A.final说明的类不能被继承

B.应该使用组合，因为Tire类跟Car类属于Has-a的关系

C.模板也是代码复用的重要手段

D.狗是动物的一种，属于is-a关系，是继承的体现

3. D

A.两个权限控制的东西不一样

B.访问权限在类内部，继承权限在类外

C.只要是public成员对象都可以直接访问

D.基类私有成员不能直接访问不是没有被继承，而是权限问题

4. D

A.可以存在，如函数重载

B.基类与子类函数名字相同，参数不同，形成的是隐藏

C.可以共存

D.成员函数在同一个类里面同名，此时构成了重载，但变量一定不能同名，故正确

5. D

A.错误

B.错误

C.不能通过编译是正确的，不过原因不是因为成员变量a的问题，

而是子类同名隐藏了父类方法的原因

D.很显然以上说法都不对

6. D

A.如果父类有默认构造函数，此时就不需要

B.顺序相反，先初始化父类，再是子类

C.会调用，并且按照构造的相反顺序进行调用

D.是的，需要看父类构造函数是否需要参数子类的，从而你决定子类构造函数的定义

7. A

A.先构造父类，在构造子类故正确

B.不一定，如果父类有默认构造函数就不需要

C.刚好相反，先调用子类，在调用父类

D.派生类的析构函数往往还需要连同父类析构函数一起调用，同时清除父类的资源

8. C

分析: 子类实例化对象，由于继承的有父类。所以会先构造父类，

然后在构造子类，析构顺序完全按照构造的相反顺序进行析构。

9. C

A.可以不指定，默认为private

B.Class定义的类，默认的访问权限是private

C.正确，在C++中，这是struct跟class唯一的区别

D. 私有的成员继承下来了，但是在子类中不可见

10. C

A.静态成员函数也可以被继承

B.成员变量所有的都会被继承，无论公有私有

C.友元函数不能被继承，相当于你爹的朋友不一定是你的朋友

D.静态成员属于整个类，不属于任何对象，所以在整体体系中只有一份

11. E

A.静态变量就不被包含

B.同理，静态变量就不被包含

C.父类所有成员都要被继承，因此包含了

D.静态成员一定是不被包含在对象中的

E.很显然，以上说法都不正确

12. B

A.这是赋值兼容规则的其中一条，正确

B.基类不能给子类对象直接赋值，因为父类类型对于子类类型来说类型不完全，故错误

C.不能用父类初始化子类引用

D.这也是赋值兼容规则的其中一条

13. C

分析:p1和p2虽然都是其父类，但在子类内存模型中，其位置不同，所以p1和p2所指子类的位置也不相同，因此p1!=p2,

由于p1对象是第一个被继承的父类类型，所有其地址与子类对象的地址p3所指位置都为子类对象的起始位置，因此p1==p3,所以C正确

14. C

A.C1中b和c1共8个字节，C2中c2和b共8个字节，D自身成员d 4个字节，一共20字节

B.由于菱形继承，最终的父类B在D中有两份

C.子类对象不能直接访问最顶层基类B中继承下来的b成员，因为在D对象中，b有两份，一份是从

C1中继承的，一份是从C2中继承的，直接通过D的对象访问b会存在二义性问题，在访问时候，可

以加类名::b，来告诉编译器想要访问C1还是C2中继承下来的b。

D.菱形继承存在二义性问题，尽量避免设计菱形继承，如果真有需要，一般采用虚拟继承减少数据冗余

本篇完。

笔试面试时会有下面几个问题，不会的还可以回去看看。

1. 什么是菱形继承？菱形继承的问题是什么？
2. 什么是菱形虚拟继承？如何解决数据冗余和二义性的
3. 继承和组合的区别？什么时候用继承？什么时候用组合？

下一篇：类和对象三大特性之一的多态。

穿越回来复习顺便贴个下篇链接：

从C语言到C++_23(多态)抽象类+虚函数表VTBL+多态的面试题_#include <iostream> using namespace std; class c {-CSDN博客

GR鲸鱼

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录