使用类、继承、多态、纯虚函数和纯析构函数实现电脑组装（附C++代码）

已于 2025-01-11 11:32:55 修改
阅读量1k 收藏 7
点赞数 35
分类专栏： C++ 文章标签： 电脑 c++ 开发语言
于 2024-12-24 20:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40280673/article/details/144673077
版权

在这里插入图片描述

💪 图像算法工程师，专业从事且热爱图像处理，图像处理专栏更新如下👇：
📝《图像去噪》
📝《超分辨率重建》
📝《语义分割》
📝《风格迁移》
📝《目标检测》
📝《图像增强》
📝《模型优化》
📝《模型实战部署》
📝《图像配准融合》
📝《数据集》
📝《高效助手》
📝《C++》

在这里插入图片描述

目录

一、需求

电脑主要组成部件为 CPU(用于计算)，显卡(用于显示)，内存条(用于存储)；

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商；

创建电脑类提供让电脑工作的函数数，并且调用每个零件工作的接口；

测试时组装三台不同的电脑进行工作。

二、实现

2.1 虚函数、抽象类定义

按照上面要求，先将CPU、显卡和内存条的虚函数、抽象类定义好，代码见下：

// 抽象不同零件类
// 抽象CPU类
class CPU
{
public:
        // 抽象的计算函数
        virtual void calculator() = 0;
};

// 抽象显卡类
class VideoCard
{
public:
    // 抽象的显示函数
    virtual void display() = 0;
};

// 抽象内存条类
class Memory
{
public:
        // 抽象的存储函数
        virtual void storage() = 0;
};

2.2 电脑类

要将2.1中各个硬件组装起来，需要定义电脑类，代码见下：

// 电脑类
class Computer
{
public:
        Computer(CPU * cpu,VideoCard * vc,Memory * mem)      // 用三个指针接收三个零件
        {
            m_cpu = cpu;
            m_vc = vc;
            m_mem = mem;
        }

        // 提供工作的函数
        void work()
        {
            // 让零件工作起来，调用接口
            m_cpu->calculator();      // 让三个零件工作起来
            m_vc->display();
            m_mem->storage();
        }
        // 提供析构函数，释放3个电脑零件
    ~Computer()
    {
        // 释放CPU零件
        if (m_cpu != NULL)
        {
            delete m_cpu;
            m_cpu = NULL;
        }
        // 释放CPU零件
        if (m_vc != NULL)
        {
            delete m_vc;
            m_vc = NULL;
        }
        // 释放CPU零件
        if (m_mem != NULL)
        {
            delete m_mem;
            m_mem = NULL;
        }
    }
private:
        CPU * m_cpu;        // CPU零件指针              // 都是父类的指针
        VideoCard * m_vc;   // 显卡零件指针
        Memory * m_mem;     // 内存条零件指针
};

2.3 Intel厂商电脑制作

将2.1中的各个纯虚函数重写，使 Intel厂商各个硬件运行起来，代码见下：

// Intel厂商
class IntelCPU : public CPU
{
public:
        virtual void calculator()
        {
            cout << "Intel的CPU开始计算了!" << endl; 
        }
};

class IntelVideoCard : public VideoCard
{
public:
        virtual void display()
        {
            cout << "Intel的显卡开始显示了!" << endl;
        }
};

class IntelMemory : public Memory
{
public:
        virtual void storage()
        {
            cout << "Intel的内存条开始存储了!" << endl;
        }
};

2.4 Lenovo厂商电脑制作

同理，将2.1中的各个纯虚函数重写，使Lenovo厂商各个硬件运行起来，代码见下：

// Lenove厂商
class LenovoCPU : public CPU
{
public:
        virtual void calculator()
        {
            cout << "Lenovo的CPU开始计算了!" << endl;
        }
};

class LenovoVideoCard : public VideoCard
{
public:
        virtual void display()
        {
            cout << "Lenovo的显卡开始显示了!" << endl;
        }
};

class LenovoMemory : public Memory
{
public:
        virtual void storage()
        {
            cout << "Lenovo的内存条开始存储了!" << endl;
        }
};

2.5 电脑随机组装

上面各模块都定义好后，就可以将各个厂商的CPU、显卡和内存条随机的组装了，因为各厂商的硬件设备都是继承于同一抽象类，所以后期调用随机组装都是兼容的，见下：

在这里插入图片描述
test01()代码为：

void test01()
{
    // 第一台电脑零件
    CPU * intelCpu = new IntelCPU;
    VideoCard * intelCard = new IntelVideoCard;
    Memory * intelMem = new IntelMemory;

    cout << "第一台电脑开始工作!" << endl;

    // 创建第一台电脑
    Computer * computer1 = new Computer(intelCpu,intelCard,intelMem);
    computer1->work();
    delete computer1;  // 从堆上释放

    cout << "-----------------------------" << endl;

    cout << "从第二台电脑开始工作!" << endl;
    // 第二台电脑组装
    Computer * computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
    computer2->work();
    delete computer2;

    cout << "--------------------------" << endl;
    cout << "第三台电脑开始工作!" << endl;
    // 第三台电脑组装
    Computer * computer3 = new Computer(new LenovoCPU,new IntelVideoCard,new IntelMemory);
    computer3->work();
    delete computer3;
}

2.6 完整代码

上面各个子模块组合完整代码见下：

#include<iostream>
using namespace std;
#include <ctime>

// 抽象不同零件类
// 抽象CPU类
class CPU
{
public:
        // 抽象的计算函数
        virtual void calculator() = 0;
};

// 抽象显卡类
class VideoCard
{
public:
    // 抽象的显示函数
    virtual void display() = 0;
};

// 抽象内存条类
class Memory
{
public:
        // 抽象的存储函数
        virtual void storage() = 0;
};

// 电脑类
class Computer
{
public:
        Computer(CPU * cpu,VideoCard * vc,Memory * mem)      // 用三个指针接收三个零件
        {
            m_cpu = cpu;
            m_vc = vc;
            m_mem = mem;
        }

        // 提供工作的函数
        void work()
        {
            // 让零件工作起来，调用接口
            m_cpu->calculator();      // 让三个零件工作起来
            m_vc->display();
            m_mem->storage();
        }
        // 提供析构函数，释放3个电脑零件
    ~Computer()
    {
        // 释放CPU零件
        if (m_cpu != NULL)
        {
            delete m_cpu;
            m_cpu = NULL;
        }
        // 释放CPU零件
        if (m_vc != NULL)
        {
            delete m_vc;
            m_vc = NULL;
        }
        // 释放CPU零件
        if (m_mem != NULL)
        {
            delete m_mem;
            m_mem = NULL;
        }
    }
private:
        CPU * m_cpu;        // CPU零件指针              // 都是父类的指针
        VideoCard * m_vc;   // 显卡零件指针
        Memory * m_mem;     // 内存条零件指针
};

// 具体厂商
// Intel厂商
class IntelCPU : public CPU
{
public:
        virtual void calculator()
        {
            cout << "Intel的CPU开始计算了!" << endl; 
        }
};

class IntelVideoCard : public VideoCard
{
public:
        virtual void display()
        {
            cout << "Intel的显卡开始显示了!" << endl;
        }
};

class IntelMemory : public Memory
{
public:
        virtual void storage()
        {
            cout << "Intel的内存条开始存储了!" << endl;
        }
};

// Lenove厂商
class LenovoCPU : public CPU
{
public:
        virtual void calculator()
        {
            cout << "Lenovo的CPU开始计算了!" << endl;
        }
};

class LenovoVideoCard : public VideoCard
{
public:
        virtual void display()
        {
            cout << "Lenovo的显卡开始显示了!" << endl;
        }
};

class LenovoMemory : public Memory
{
public:
        virtual void storage()
        {
            cout << "Lenovo的内存条开始存储了!" << endl;
        }
};

void test01()
{
    // 第一台电脑零件
    CPU * intelCpu = new IntelCPU;
    VideoCard * intelCard = new IntelVideoCard;
    Memory * intelMem = new IntelMemory;

    cout << "第一台电脑开始工作!" << endl;

    // 创建第一台电脑
    Computer * computer1 = new Computer(intelCpu,intelCard,intelMem);
    computer1->work();
    delete computer1;  // 从堆上释放

    cout << "-----------------------------" << endl;

    cout << "从第二台电脑开始工作!" << endl;
    // 第二台电脑组装
    Computer * computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
    computer2->work();
    delete computer2;

    cout << "--------------------------" << endl;
    cout << "第三台电脑开始工作!" << endl;
    // 第三台电脑组装
    Computer * computer3 = new Computer(new LenovoCPU,new IntelVideoCard,new IntelMemory);
    computer3->work();
    delete computer3;
}


int main()
{
    test01();

    system("pause");
    return 0;
    
}

2.7 输出

运行2.6中代码，输出见下：

在这里插入图片描述

三、总结

以上就是使用类、继承、多态、纯虚函数和纯析构函数实现电脑组装，希望能帮你理解。本人参考学习的是黑马程序员，仅作为笔记记录。

感谢您阅读到最后！😊总结不易，多多支持呀🌹 点赞👍收藏⭐评论✍️，您的三连是我持续更新的动力💖

关注下面「视觉研坊」，获取干货教程、实战案例、技术解答、行业资讯！

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

视觉研坊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值