【C++面向对象——类与对象】Computer类（头歌实践教学平台习题）【合集】
目录😋
任务描述
相关知识
一、不同访问属性成员的访问方式
1. public成员
2. private成员
3. protected成员
二、观察构造函数和析构函数的执行过程
1. 构造函数
2. 析构函数
三、学习类的组合使用方法
1. 类的组合概念
2. 实现示例
实验步骤
测试说明
通关代码
测试结果
任务描述
本关任务：声明一个简单的Computer类，含有数据成员芯片（cpu）、内存（ram）、光驱（cdrom）等等，以及两个公有成员函数run、stop。
相关知识
为了完成本关任务，你需要掌握
- 不同访问属性的成员的访问方式
- 构造函数和析构函数的执行过程
- 类的组合使用方法
一、不同访问属性成员的访问方式
访问控制符：在 C++ 中，类的成员（包括数据成员和成员函数）可以有三种访问控制符：
public（公共的）、private（私有的）和protected（受保护的）。
1.public成员：可以在类的外部直接访问。例如：
class MyClass { public: int publicVariable; void publicFunction() { // 函数体 } }; int main() { MyClass obj; obj.publicVariable = 10; // 直接访问public数据成员 obj.publicFunction(); // 直接调用public成员函数 return 0; }
2.private成员：只能在类的内部访问。这是一种数据隐藏的机制，用于保护类的数据不被外部随意修改。例如：
class MyClass { private: int privateVariable; public: void setPrivateVariable(int value) { privateVariable = value; // 在类内部访问private数据成员 } int getPrivateVariable() { return privateVariable; // 在类内部访问private数据成员 } }; int main() { MyClass obj; // obj.privateVariable = 20; // 错误，不能在类外部直接访问private成员 obj.setPrivateVariable(20); // 通过public成员函数来间接访问和修改private成员 int value = obj.getPrivateVariable(); return 0; }
3.protected成员：它类似于
private成员，在类的外部不能直接访问。但是，protected成员可以在派生类（继承该类的子类）中访问。例如：class BaseClass { protected: int protectedVariable; public: void setProtectedVariable(int value) { protectedVariable = value; } }; class DerivedClass : public BaseClass { public: void modifyProtectedVariable() { protectedVariable += 10; // 在派生类中访问基类的protected成员 } }; int main() { DerivedClass obj; // obj.protectedVariable = 30; // 错误，不能在类外部直接访问protected成员 obj.setProtectedVariable(30); obj.modifyProtectedVariable(); return 0; }
二、观察构造函数和析构函数的执行过程
1. 构造函数
- 定义和作用：构造函数是一种特殊的成员函数，它的名字与类名相同，没有返回值类型（包括
void）。它主要用于初始化类的对象。例如：class MyClass { public: int value; MyClass() { value = 0; // 初始化数据成员 } };- 执行时机：当创建一个对象时，构造函数会自动被调用。例如：
int main() { MyClass obj; // 调用MyClass的默认构造函数 return 0; }- 重载构造函数：可以有多个构造函数，它们的参数列表不同，这称为构造函数的重载。例如：
class MyClass { public: int value; MyClass() { value = 0; } MyClass(int initValue) { value = initValue; } }; int main() { MyClass obj1; // 调用默认构造函数 MyClass obj2(10); // 调用带参数的构造函数 return 0; }2. 析构函数
- 定义和作用：析构函数也是一种特殊的成员函数，它的名字是在类名前面加上
~符号，没有参数和返回值类型。它主要用于在对象销毁时释放资源，如动态分配的内存、打开的文件等。例如：class MyClass { public: int* dynamicArray; MyClass() { dynamicArray = new int[10]; } ~MyClass() { delete[] dynamicArray; // 释放动态分配的内存 } };- 执行时机：析构函数在对象的生命周期结束时自动被调用。如果对象是在栈上创建的，那么当对象所在的作用域结束时，析构函数就会被调用；如果对象是在堆上创建的（使用
new创建），那么当使用delete删除对象时，析构函数会被调用。例如：int main() { MyClass obj1; // 在栈上创建对象，作用域结束时析构函数被调用 MyClass* obj2 = new MyClass; // 使用obj2 delete obj2; // 使用delete时析构函数被调用 return 0; }
三、学习类的组合使用方法
1. 类的组合概念
- 类的组合是指一个类的对象作为另一个类的数据成员。通过这种方式，可以将复杂的问题分解为多个简单的类来实现，从而提高代码的可维护性和复用性。例如，假设有一个
Engine类表示汽车发动机，和一个Car类，Car类中包含一个Engine对象作为其数据成员来表示汽车有一个发动机。2. 实现示例
- 首先定义
Engine类：class Engine { public: void start() { // 启动发动机的代码 std::cout << "Engine started." << std::endl; } void stop() { // 停止发动机的代码 std::cout << "Engine stopped." << std::endl; } };- 然后定义
Car类，其中包含Engine对象：class Car { private: Engine engine; public: void drive() { engine.start(); // 汽车行驶的代码 std::cout << "Car is driving." << std::endl; } void park() { // 汽车停车的代码 engine.stop(); } };- 在
main函数中使用：int main() { Car myCar; myCar.drive(); myCar.park(); return 0; }- 在这个例子中，
Car类组合了Engine类，Car类的对象myCar可以通过其内部的Engine对象engine来调用Engine类的成员函数start和stop，从而实现汽车的行驶和停车功能。
实验步骤
参考实验指导书第四章的实验步骤 4：
- 声明CPU类（可使用第二题中的CPU类）、RAM类、CDROM类。
- 声明Computer类：声明私有数据成员cpu、ram、cdrom，声明公有成员函数run、stop，可在其中输出提示信息。
- 在主程序中声明一个Computer的对象，调用其成员函数，观察类对象及其成员变量的构造与析构顺序，以及成员函数的调用。
测试说明
根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。
预期输出：
构造了一个Computer! Computer开始运行! CPU开始运行! RAM开始运行! CDROM开始运行! Computer停止运行! CPU停止运行! RAM停止运行! CDROM停止运行! 析构了一个Computer!
通关代码
#include <iostream>
using namespace std;
class CPU
{
public:
CPU (){}
~CPU () {}
void Run() {cout << "CPU开始运行!" << endl; }
void Stop() {cout << "CPU停止运行!" << endl; }
};
class RAM
{
public:
RAM () {}
~RAM () {}
void Run() {cout << "RAM开始运行!" << endl; }
void Stop() {cout << "RAM停止运行!" << endl; }
};
class CDROM
{
public:
CDROM () {}
~CDROM () {}
void Run() {cout << "CDROM开始运行!" << endl; }
void Stop() {cout << "CDROM停止运行!" << endl; }
};
class Computer
{
private:
CPU cpu;
RAM ram;
CDROM cdrom;
public:
Computer (CPU c, RAM r, CDROM cd)
{
cpu = c;
ram = r;
cdrom = cd;
cout << "构造了一个Computer!" << endl;
}
~Computer () {cout << "析构了一个Computer!"; }
CPU GetCPU() const { return cpu; }
RAM GetRAM() const { return ram; }
CDROM GetCDROM() const {return cdrom; }
void setCPU(CPU c) { cpu = c; }
void setRAM(RAM r) { ram = r; }
void setCDROM(CDROM cd) { cdrom = cd; }
void Run() {
cout << "Computer开始运行!" << endl;
/********** Begin **********/
cpu.Run();
ram.Run();
cdrom.Run();
/********** End **********/
}
void Stop () {
cout << "Computer停止运行!" << endl;
/********** Begin **********/
cpu.Stop();
ram.Stop();
cdrom.Stop();
/********** End **********/
}
};
int main() {
CPU c;
RAM r;
CDROM cd;
Computer computer(c, r, cd);
computer.Run();
computer.Stop();
}
测试结果
