346 lines
7.9 KiB
Markdown
346 lines
7.9 KiB
Markdown
<!--
|
||
* @Author: error: error: git config user.name & please set dead value or install git && error: git config user.email & please set dead value or install git & please set dead value or install git
|
||
* @Date: 2025-05-12 13:19:46
|
||
* @LastEditors: error: git config user.name & please set dead value or install git
|
||
* @LastEditTime: 2025-05-12 14:10:25
|
||
-->
|
||
## 4.阅读代码，并按要求练习。
|
||
``` cpp
|
||
class A
|
||
{
|
||
public:
|
||
A(int num):data1(num) {}
|
||
~A(){
|
||
cout<<" Destory A"<<endl;
|
||
}
|
||
void f() const{
|
||
cout<<" Excute A::f() ";
|
||
cout<<" Data1="<<data1<<endl;
|
||
}
|
||
void g()
|
||
{
|
||
cout<<" Excute A::g() "<<endl;
|
||
}
|
||
private:
|
||
int data1;
|
||
};
|
||
|
||
class B : public A
|
||
{
|
||
public:
|
||
B(int num1,int num2):A(num1),data2(num2) {}
|
||
~B(){
|
||
cout<<" Destory B"<<endl;
|
||
}
|
||
void f( ) const{
|
||
cout<<" Excute B::f() ";
|
||
cout<<" Data1="<< data1;
|
||
cout<<" Data2="<<data2<<endl;
|
||
}
|
||
void f(int n) const{
|
||
cout<<" Excute B::f(int) ";
|
||
cout<<" n="<<n;
|
||
cout<<" Data1="<< data1;
|
||
cout<<" Data2="<<data2<<endl;
|
||
}
|
||
void h(){
|
||
cout<<" Excute B::h() "<<endl;
|
||
}
|
||
private:
|
||
int data2;
|
||
};
|
||
```
|
||
|
||
## 下面是问题
|
||
- ##### 1)完成 B 类的构造函数，使得参数 num1 对应 data1，num2 对应 data2；
|
||
|
||
✅已完成：
|
||
|
||
```cpp
|
||
B(int num1, int num2) : A(num1), data2(num2) {}
|
||
```
|
||
|
||
这正确地将 `num1` 传递给基类 A，`num2` 初始化 `data2`。✅
|
||
|
||
---
|
||
|
||
- ##### 2)尝试在 main 函数中使用这两个类，编译程序看是否有编译错误？指出错误的原因。
|
||
|
||
|
||
✅已完成：
|
||
|
||
```cpp
|
||
B b(1, 2);
|
||
b.f();
|
||
b.g();
|
||
b.f(3);
|
||
b.h();
|
||
```
|
||
|
||
若此时 A 中 `data1` 是 `private`，则：
|
||
|
||
* ✅ `b.f()`、`b.g()`、`b.f(3)`、`b.h()` 都能编译通过。
|
||
* ⚠️ 但 `B::f()` 中访问 `data1` 会报错（因为 `B` 不能访问 `A::data1` 的 `private` 成员）。
|
||
---
|
||
|
||
- ##### 3)将基类中的 private 改为 protected，再编译。理解 protected 访问权限，在public 继承方式下的可访问性。
|
||
|
||
|
||
|
||
✅ 将 A 的成员 `private → protected` 后
|
||
|
||
* `B` 就可以访问 `A::data1`。
|
||
* 所以 `B::f()` 和 `f(int)` 中访问 `data1` 合法。
|
||
* `protected` 在 `public` 继承下，**对子类可见，对外仍然不可见**。
|
||
|
||
---
|
||
- ##### 4)修改 main 函数，如下所示，看看哪些语句合法？为什么？执行的是基类的实现，还是派生类的实现？
|
||
``` cpp
|
||
int main()
|
||
{
|
||
B b(1,2);
|
||
b.f();
|
||
b.g();
|
||
b.f(3);
|
||
b.h();
|
||
return 0;
|
||
}
|
||
```
|
||
✅已完成：
|
||
|
||
```cpp
|
||
int main() {
|
||
B b(1, 2);
|
||
b.f(); // ✅ 调用 B::f()
|
||
b.g(); // ✅ 调用 A::g()
|
||
b.f(3); // ✅ 调用 B::f(int)
|
||
b.h(); // ✅ 调用 B::h()
|
||
}
|
||
```
|
||
|
||
**全部合法**，执行的都是定义在类中的相应成员函数，优先使用派生类的版本。
|
||
|
||
---
|
||
- ##### 5)将继承 A 类的继承方式改为 private，编译能通过吗？再执行 4)中的main 函数，看看哪些语句变得不合法了？为什么？
|
||
✅ 改为 `private` 继承后：
|
||
|
||
```cpp
|
||
class B : private A
|
||
```
|
||
|
||
现在，`A` 的成员都变成 `B` 的私有成员。
|
||
|
||
* `main()` 中 `b.g();` 不合法（`A::g()` 是 `private` 了）
|
||
* `b.f();` 也不合法，因为 `A::f()` 被隐藏
|
||
* ❌ **除了 `b.f(3)` 和 `b.h()` 还行，其余都报错**
|
||
|
||
---
|
||
|
||
- ##### 6)将继承 A 类的继承方式改回 public，并实现 B 类自定义的拷贝构造和赋值函数。
|
||
|
||
✅已构造A类的operator+
|
||
|
||
```cpp
|
||
class B : public A {
|
||
// ...
|
||
public:
|
||
B(const B& other) : A(other), data2(other.data2) {}
|
||
B& operator=(const B& other) {
|
||
if (this != &other) {
|
||
A::operator=(other);
|
||
//或者
|
||
this->A::operator=(other);
|
||
//这种写法也可以
|
||
data2 = other.data2;
|
||
}
|
||
return *this;
|
||
}
|
||
};
|
||
```
|
||
|
||
|
||
---
|
||
- ##### 7)分别创建 A 和 B 类的两个对象 a 和 b，分别执行 a.f()，b.f()，a.g()，b.g()，a.f(1)，b.f(1)，a.h()，b.h()，请问哪些可以通过编译，执行结果如何？
|
||
✅ 调用：
|
||
|
||
```cpp
|
||
A a(1);
|
||
B b(2, 3);
|
||
a.f(); // ✅ A::f()
|
||
b.f(); // ✅ B::f()
|
||
a.g(); // ✅ A::g()
|
||
b.g(); // ✅ A::g() 继承而来
|
||
a.f(1); // ❌ 无此函数
|
||
b.f(1); // ✅ B::f(int)
|
||
a.h(); // ❌ 无此函数
|
||
b.h(); // ✅ B::h()
|
||
```
|
||
|
||
---
|
||
- ##### 8)增加代码 A * p=new B(1,2);，理解向上类型转换的安全性。
|
||
✅已完成：
|
||
```cpp
|
||
A* p = new B(1, 2);
|
||
```
|
||
|
||
✅ 安全，称为“向上转型”（upcasting），**B 是 A 的子类**。安全的主要原因：
|
||
“向上类型转换的安全性”是面向对象编程中一个很关键但也容易被忽略的点，尤其在 C++ 中。
|
||
|
||
---
|
||
|
||
## ✅ 什么是向上类型转换（Upcasting）？
|
||
|
||
向上类型转换：**将派生类对象的指针或引用转换为基类类型的指针或引用**。
|
||
|
||
比如：
|
||
|
||
```cpp
|
||
class A { };
|
||
class B : public A { };
|
||
|
||
B b;
|
||
A* pa = &b; // 向上类型转换（Upcasting）
|
||
```
|
||
|
||
---
|
||
|
||
## ✅ 安全性的本质
|
||
|
||
### ✅ **向上转换是安全的、隐式允许的**
|
||
|
||
因为：
|
||
|
||
* 每个派生类对象**本质上包含一个完整的基类子对象部分**。
|
||
* 所以把 `B*` 转为 `A*` 是有意义的：`A` 的部分总是存在的。
|
||
|
||
> 换句话说，你永远可以“安全地把一个更具体的对象视为一个更抽象的对象”。
|
||
|
||
---
|
||
|
||
## ✅ 示例
|
||
|
||
```cpp
|
||
class A {
|
||
public:
|
||
void foo() { cout << "A::foo\n"; }
|
||
};
|
||
|
||
class B : public A {
|
||
public:
|
||
void bar() { cout << "B::bar\n"; }
|
||
};
|
||
|
||
int main() {
|
||
B b;
|
||
A* pa = &b; // 向上转换，安全
|
||
|
||
pa->foo(); // ✅合法，调用 A 的函数
|
||
// pa->bar(); // ❌错误：A 类型中没有 bar()
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## ❗ 注意事项：类型“退化”
|
||
|
||
向上转换后：
|
||
|
||
* **只能访问基类中的成员**，即便实际指向的是一个派生类对象；
|
||
* 若函数是非虚函数，则会“静态绑定”到基类版本；
|
||
* 若函数是虚函数，则会“动态绑定”到派生类重写版本（见多态）；
|
||
|
||
---
|
||
|
||
## ✅ 与向下转换对比
|
||
|
||
| 类型转换方式 | 安全性 | 是否隐式 | 风险 |
|
||
| --------- | ----- | ---- | ---------------- |
|
||
| 向上转换（B→A） | ✅ 安全 | ✅ 是 | 无 |
|
||
| 向下转换（A→B） | ❌ 不安全 | ❌ 否 | 若对象本非 B 类型，结果未定义 |
|
||
|
||
|
||
|
||
---
|
||
- ##### 9)在 8)的基础上，执行 p->f()，输出是什么？与 B* p=new B(1,2); p->f();的结果一样吗？
|
||
✅执行后：
|
||
|
||
默认情况下（`f()` 非虚函数）：
|
||
|
||
```cpp
|
||
p->f(); // 输出 A::f()
|
||
```
|
||
|
||
若你希望执行的是 `B::f()`，**应将 A 的 `f()` 声明为 `virtual`**。
|
||
|
||
---
|
||
- ##### 10)在 8)的基础上，执行 p->f(1)，能通过编译吗？为什么？
|
||
✅编译？
|
||
|
||
```cpp
|
||
p->f(1); // ❌ 报错：A 类中无 f(int)
|
||
```
|
||
|
||
即使实际对象是 B，编译器只看指针类型（A），而 A 没有 `f(int)`。
|
||
|
||
---
|
||
- ##### 11)在 8)的基础上，执行 p->g()和 p->h()，能行吗？为什么？
|
||
✅编译？
|
||
|
||
```cpp
|
||
p->f(1); // ❌ 报错：A 类中无 f(int)
|
||
```
|
||
|
||
即使实际对象是 B，编译器只看指针类型（A），而 A 没有 `f(int)`。
|
||
|
||
---
|
||
- ##### 12)在 8)的基础上，执行 delete p;，输出是什么？B 类的析构函数执行了吗？
|
||
✅输出：
|
||
|
||
如果 `A` 的析构函数不是 `virtual`，那么：
|
||
|
||
```cpp
|
||
delete p; // 只会调用 A 的析构函数，❌ 不会调用 B 的析构函数
|
||
```
|
||
|
||
输出：
|
||
|
||
```
|
||
Destory A
|
||
```
|
||
|
||
⚠️ 此时会发生**资源泄漏**，因为 `B` 中资源未释放！
|
||
|
||
✅ 正确写法是：
|
||
|
||
```cpp
|
||
class A {
|
||
public:
|
||
virtual ~A() {
|
||
cout << "Destory A" << endl;
|
||
}
|
||
// ...
|
||
};
|
||
```
|
||
|
||
这样 `delete p;` 才会调用 B 的析构函数 → 输出顺序：
|
||
|
||
```
|
||
Destory B
|
||
Destory A
|
||
```
|
||
|
||
---
|
||
|
||
## ✅ 总结重点
|
||
|
||
| 问题 | 核心知识 |
|
||
| ---- | -------------------------- |
|
||
| 2–3 | 访问权限（private vs protected） |
|
||
| 4–5 | 继承方式（public/private）影响成员访问 |
|
||
| 6 | 拷贝构造函数 & 赋值操作符 |
|
||
| 7–11 | 多态、向上转型、成员函数隐藏 |
|
||
| 12 | 虚析构函数，资源释放 |
|
||
|
||
---
|
||
|