【C++面向对象——类与对象】Computer类（头歌实践教学平台习题）【合集】

Rossy Yan

发布于 2025-01-01 09:33:23

21000

代码可运行

文章被收录于专栏：【Educoder实训】头歌实践教学平台【Educoder实训】头歌实践教学平台

运行总次数：0

代码可运行

任务描述

本关任务：声明一个简单的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();
}

测试结果

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-01-01，如有侵权请联系 cloudcommunity@tencent.com 删除

函数

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度