黑马C++ 基于多态的职工管理系统

最新推荐文章于 2024-06-12 21:23:37 发布
最新推荐文章于 2024-06-12 21:23:37 发布
阅读量156 收藏 1
点赞数
文章标签： c++ 开发语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53002662/article/details/129264130
版权

管理系统需求

职工管理系统可以用来管理公司内所有员工的信息

本教程主要利用C++来实现一个基于多态的职工管理系统

公司中职工分为三类：普通员工、经理、老板，显示信息时，需要显示职工编号、职工姓名、职工岗位、以及职责

普通员工职责：完成经理交给的任务

经理职责：完成老板交给的任务，并下发任务给员工

老板职责：管理公司所有事务

管理系统中需要实现的功能如下：

  • 退出管理程序：退出当前管理系统

  • 增加职工信息：实现批量添加职工功能，将信息录入到文件中，职工信息为：职工编号、姓名、部门编号

  • 显示职工信息：显示公司内部所有职工的信息

  • 删除离职职工：按照编号删除指定的职工

  • 修改职工信息：按照编号修改职工个人信息

  • 查找职工信息：按照职工的编号或者职工的姓名进行查找相关的人员信息

  • 按照编号排序：按照职工编号，进行排序，排序规则由用户指定

  • 清空所有文档：清空文件中记录的所有职工信息 （清空前需要再次确认，防止误删）

创建项目

#include <iostream> 
using  namespace std;
#include "workerManager.h"

int main()
{
    WorkerManager wm;

    int choice = 0; //用来存储用户的选项

    while (true)
    {
        //调用展示菜单成员函数
        wm.Show_Menu();

        cout << "请输入您的选择： " << endl;
        cin >> choice; // 接受用户的选项

        switch (choice)
        {
        case 0:  //退出系统
            break;
        case 1:  //增加职工
            break;
        case 2:  //显示职工
            break;
        case 3:  //删除职工
            break;
        case 4:  //修改职工
            break;
        case 5:  //查找职工
            break;
        case 6:  //排序职工
            break;
        case 7:  //清空文档
            break;
        default:
            system("cls"); //清屏
            break;
        }

    }

    system("pause");

    return 0;
}

创建管理类

头文件实现

在workerManager.h中设计管理类

代码如下：

#pragma once
#include<iostream>
using namespace std;
​
​
classWorkerManager
{
public:
​
    //构造函数
    WorkerManager();
​
    //析构函数
    ~WorkerManager();
​
};

源文件实现

在workerManager.cpp中将构造和析构函数空实现补全

#include "workerManager.h"
​
WorkerManager::WorkerManager()
{
}
​
WorkerManager::~WorkerManager()
{
}

至此职工管理类以创建完毕

菜单功能

功能描述：与用户的沟通界面

添加成员函数

在管理类workerManager.h中添加成员函数 void Show_Menu();

#pragma once
#include<iostream>
using namespace std;
​
​
classWorkerManager
{
public:
​
    //构造函数
    WorkerManager();

    //显示与用户的沟通界面
     void Show_Menu();
​
    //析构函数
    ~WorkerManager();
​
};

菜单功能实现

在管理类workerManager.cpp中实现 Show_Menu()函数

voidWorkerManager::Show_Menu()
{
    cout<<"********************************************"<<endl;
    cout<<"*********  欢迎使用职工管理系统！ **********"<<endl;
    cout<<"*************  0.退出管理程序  *************"<<endl;
    cout<<"*************  1.增加职工信息  *************"<<endl;
    cout<<"*************  2.显示职工信息  *************"<<endl;
    cout<<"*************  3.删除离职职工  *************"<<endl;
    cout<<"*************  4.修改职工信息  *************"<<endl;
    cout<<"*************  5.查找职工信息  *************"<<endl;
    cout<<"*************  6.按照编号排序  *************"<<endl;
    cout<<"*************  7.清空所有文档  *************"<<endl;
    cout<<"********************************************"<<endl;
    cout<<endl;
}

退出功能

提供功能接口

在main函数中提供分支选择，提供每个功能接口

    WorkerManager wm;

    int choice = 0; //用来存储用户的选项

    while (true)
    {
        //调用展示菜单成员函数
        wm.Show_Menu();

        cout << "请输入您的选择： " << endl;
        cin >> choice; // 接受用户的选项

        switch (choice)
        {
        case 0:  //退出系统
            wm.ExitSystem();
            break;
        case 1:  //增加职工
            break;
        case 2:  //显示职工
            break;
        case 3:  //删除职工
            break;
        case 4:  //修改职工
            break;
        case 5:  //查找职工
            break;
        case 6:  //排序职工
            break;
        case 7:  //清空文档
            break;
        default:
            system("cls"); //清屏
            break;
        }

实现退出功能

在workerManager.h中提供退出系统的成员函数 void exitSystem();

在workerManager.cpp中提供具体的功能实现

voidWorkerManager::exitSystem()
{
    cout<<"欢迎下次使用"<<endl;
    system("pause");
    exit(0);
}

使用exit()函数退出程序

关于exit(0),exit(1)和return退出程序的区别：

return是语言级别的，它表示了调用堆栈的返回；return是返回函数调用，如果返回的是main函数，则为退出程序 。

而exit是系统调用级别的，它表示了一个进程的结束。exit是在调用处强行退出程序，运行一次程序就结束。

exit(1)表示异常退出.这个1是返回给操作系统的。

创建职工类

创建职工抽象类

职工的分类为：普通员工、经理、老板

将三种职工抽象到一个类（worker）中,利用多态管理不同职工种类

职工的属性为：职工编号、职工姓名、职工所在部门编号

职工的行为为：岗位职责信息描述，获取岗位名称

虚函数与纯虚函数

首先：强调一个概念

定义一个函数为虚函数，不代表函数为不被实现的函数。

定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。

定义一个函数为纯虚函数，才代表函数没有被实现。

定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。

头文件文件夹下 创建文件worker.h 文件并且添加如下代码：

#pragma once
#include <iostream>
using namespace std;
#include <string>

//职工抽象类
class Worker
{
public:

    //显示个人信息
    virtual void showInfo() = 0;

    //获取岗位名称
    virtual string getDeptName() = 0;

    //职工编号
    int m_Id;
    //职工姓名
    string m_Name;
    //部门编号
    int m_DeptId;
};

创建普通员工类

普通员工类继承职工抽象类，并重写父类中纯虚函数

在头文件和源文件的文件夹下分别创建employee.h 和 employee.cpp文件

employee.h中代码如下：

//普通员工文件
#pragma once
#include <iostream>
using namespace std;
#include "worker.h"

class Employee :public Worker
{
public:

    //构造函数
    Employee(int id, string name, int dId);

    //显示个人信息
    virtual void showInfo();

    //获取岗位名称
    virtual string getDeptName();

};

employee.cpp中代码如下：

#include "employee.h"

//构造函数
Employee::Employee(int id, string name, int dId)
{
    this->m_Id = id;
    this->m_Name = name;
    this->m_DeptId = dId;
}

//显示个人信息
void Employee::showInfo()
{
    cout << "职工编号：" << this->m_Id
        << "\t职工姓名：" << this->m_Name
        << "\t岗位：" << this->getDeptName()
        << "\t岗位职责： 完成经理交给的任务" << endl;
}

//获取岗位名称
string Employee::getDeptName()
{
    return  string("员工");
}

创建经理类

经理类继承职工抽象类，并重写父类中纯虚函数，和普通员工类似

在头文件和源文件的文件夹下分别创建manager.h 和 manager.cpp文件

manager.h中代码如下：

#pragma once
#include <iostream>
using namespace std;
#include "worker.h"

//经理类
class Manager :public Worker
{
public:

    //构造函数
    Manager(int id, string name, int dId);

    //显示个人信息
    virtual void showInfo();

    //获取岗位名称
    virtual string getDeptName();

};

manager.cpp中代码如下：

#include "manager.h"

//构造函数
Manager::Manager(int id, string name, int dId)
{
    this->m_Id = id;
    this->m_Name = name;
    this->m_DeptId = dId;
}

//显示个人信息
void Manager::showInfo()
{
    cout << "\t职工编号：" << this->m_Id << "\t职工姓名：" 
    << this->m_Name<< "\t岗位：" << this->getDeptName()
    << "\t岗位职责： 完成老板交给的任务，并下发任务给员工" << endl;
}

//获取岗位名称
string Manager::getDeptName()
{
    return  string("经理");
}

创建老板类

老板类继承职工抽象类，并重写父类中纯虚函数，和普通员工类似

在头文件和源文件的文件夹下分别创建boss.h 和 boss.cpp文件

boss.h中代码如下：

#pragma once
#include <iostream>
using namespace std;
#include "worker.h"

//老板类
class Boss :public Worker
{
public:

    //构造函数
    Boss(int id, string name, int dId);

    //显示个人信息
    virtual void showInfo();

    //获取岗位名称
    virtual string getDeptName();

};

boss.cpp中代码如下：

#include "boss.h"

//构造函数
Boss::Boss(int id, string name, int dId)
{
    this->m_Id = id;
    this->m_Name = name;
    this->m_DeptId = dId;
}

//显示个人信息
void Boss::showInfo()
{
    cout << "职工编号：" << this->m_Id
        << "\t职工姓名：" << this->m_Name
        << "\t岗位：" << this->getDeptName()
        << "\t岗位职责： 管理公司所有事务" << endl;
}

//获取岗位名称
string Boss::getDeptName()
{
    return  string("总裁");
}

添加职工

功能描述：批量添加职工，并且保存到文件中

功能分析

分析：

用户在批量创建时，可能会创建不同种类的职工

如果想将所有不同种类的员工都放入到一个数组中，可以将所有员工的指针维护到一个数组里

如果想在程序中维护这个不定长度的数组，可以将数组创建到堆区，并利用Worker **的指针维护

功能实现

在WokerManager.h头文件中添加成员属性 代码：

    //记录文件中的人数个数
    int m_EmpNum;
​
    //员工数组的指针
    Worker** m_EmpArray;

在WorkerManager构造函数中初始化属性

WorkerManager::WorkerManager()
{
    //初始化人数
    this->m_EmpNum=0;
​
    //初始化数组指针
    this->m_EmpArray=NULL;
}

在workerManager.h中添加成员函数

    //增加职工
    void Add_Emp();

workerManager.cpp中实现该函数

Worker * worker = NULL;的目的是初始化，由于不确定创建的员工对象是（普通员工|| 经理 || 老板）中的那个类，初始化置空防止野指针。

//增加职工
void WorkerManager::Add_Emp()
{
    cout << "请输入增加职工数量： " << endl;

    //初始化需要添加的人数
    int addNum = 0;
    cin >> addNum;

    if (addNum > 0)
    {
        //计算新空间大小 文件中的人数 + 需要新增的人数
        int newSize = this->m_EmpNum + addNum;

        //开辟新空间
        Worker ** newSpace = new Worker*[newSize];

        //将原空间下内容存放到新空间下
        if (this->m_EmpArray != NULL)
        {
            for (int i = 0; i < this->m_EmpNum; i++)
            {
                //将原数组的数据传到新数组中
                newSpace[i] = this->m_EmpArray[i];
            }
        }
        //输入新数据
        for (int i = 0; i < addNum; i++)
        {
            int id;
            string name;
            int dSelect;

            cout << "请输入第 " << i + 1 << " 个新职工编号：" << endl;
            cin >> id;

            cout << "请输入第 " << i + 1 << " 个新职工姓名：" << endl;
            cin >> name;

            cout << "请选择该职工的岗位：" << endl;
            cout << "1、普通职工" << endl;
            cout << "2、经理" << endl;
            cout << "3、老板" << endl;
            cin >> dSelect;

            Worker * worker = NULL;
            switch (dSelect)
            {
            case 1: //普通员工
                worker = new Employee(id, name, 1);
                break;
            case 2: //经理
                worker = new Manager(id, name, 2);
                break;
            case 3:  //老板
                worker = new Boss(id, name, 3);
                break;
            default:
                break;
            }
            //将创建职工职责，保存到数组中
            newSpace[this->m_EmpNum + i] = worker;
        }

        //释放原有空间
        delete[] this->m_EmpArray;

        //更改新空间的指向
        this->m_EmpArray = newSpace;

        //更新新的个数
        this->m_EmpNum = newSize;

        //提示信息
        cout << "成功添加" << addNum << "名新职工！" << endl;
    }
    else
    {
        cout << "输入有误" << endl;
    }

    system("pause");
    system("cls");
}

在WorkerManager.cpp的析构函数中，释放堆区数据 

WorkerManager::~WorkerManager()
{
    if (this->m_EmpArray != NULL)
    {
        delete[] this->m_EmpArray;
    }
}

文件交互 - 写文件

功能描述：对文件进行读写

​在上一个添加功能中，我们只是将所有的数据添加到了内存中，一旦程序结束就无法保存了

​因此文件管理类中需要一个与文件进行交互的功能，对于文件进行读写操作

设定文件路径

首先我们将文件路径，在workerManager.h中添加宏常量,并且包含头文件 fstream（文件读写头文件）

#include <fstream>
#define  FILENAME "empFile.txt"

成员函数声明

在workerManager.h中类里添加成员函数void save()

//保存文件
void save();

保存文件功能实现

void WorkerManager::save()
{
    //创建流对象
    ofstream ofs;
    //指定打开方式
    ofs.open(FILENAME, ios::out);
    //利用for循环将内容写入数组
    for (int i = 0; i < this->m_EmpNum; i++)
    {
        ofs << this->m_EmpArray[i]->m_Id << " " 
            << this->m_EmpArray[i]->m_Name << " " 
            << this->m_EmpArray[i]->m_DeptId << endl;
    }
    //释放
    ofs.close();
}

文件交互 - 读文件

功能描述：将文件中的内容读取到程序中

虽然我们实现了添加职工后保存到文件的操作，但是每次开始运行程序，并没有将文件中数据读取到程序中

而我们的程序功能中还有清空文件的需求

因此构造函数初始化数据的情况分为三种

  1. 第一次使用，文件未创建

  1. 文件存在，但是数据被用户清空

  1. 文件存在，并且保存职工的所有数据

文件未创建

在workerManager.h中添加新的成员属性 m_FileIsEmpty标志文件是否为空

    //标志文件是否为空
    bool m_FileIsEmpty;

修改WorkerManager.cpp中构造函数代码

WorkerManager::WorkerManager()
{
    //创建流对象
    ifstream ifs;
    //指定打开方式
    ifs.open(FILENAME, ios::in);
    //文件不存在情况
    if (!ifs.is_open())
    {
        cout<<"文件不存在"<<endl; //测试输出
        this->m_EmpNum=0;  //初始化人数
        this->m_FileIsEmpty=true; //初始化文件为空标志
        this->m_EmpArray=NULL; //初始化数组
        ifs.close(); //关闭文件
        return;
    }
}

删除文件后，测试文件不存在时初始化数据功能

文件存在且数据为空

在workerManager.cpp中的构造函数追加代码：

    //1、文件不存在

    ifstream ifs;
    ifs.open(FILENAME, ios::in); // 读文件

    if (!ifs.is_open())
    {
        //cout << "文件不存在" << endl;
        //初始化属性
        //初始化记录人数
        this->m_EmpNum = 0;
        //初始化数组指针 
        this->m_EmpArray = NULL;
        //初始化文件是否为空
        this->m_FileIsEmpty = true;
        ifs.close();
        return;
    }

    //2、文件存在 数据为空
    char ch;
    ifs >> ch;
    if (ifs.eof())
    {
        //文件为空
        //cout << "文件为空！" << endl;
        //初始化记录人数
        this->m_EmpNum = 0;
        //初始化数组指针 
        this->m_EmpArray = NULL;
        //初始化文件是否为空
        this->m_FileIsEmpty = true;
        ifs.close();
        return;
    }

文件存在且保存职工数据

获取记录的职工人数

在workerManager.h中添加成员函数 int get_EmpNum();

    //统计人数
    int get_EmpNum();

workerManager.cpp中实现

int WorkerManager::get_EmpNum()
{
    ifstream ifs;
    ifs.open(FILENAME, ios::in);
​
    int id;
    string name;
    int dId;
​
    int num=0;
​
    while (ifs >> id&&ifs >> name&&ifs >> dId)
    {
        //记录人数
        num++;
    }
    ifs.close();
​
    return num;
}

在workerManager.cpp构造函数中继续追加代码：

    //3、文件存在，并且记录数据
    int num = this->get_EmpNum();
    //cout << "职工人数为： " << num << endl;
    this->m_EmpNum = num;

    //开辟空间
    this->m_EmpArray = new Worker * [this->m_EmpNum];
    //将文件中的数据 ，存到数组中
    this->init_Emp();

初始化数组

根据职工的数据以及职工数据，初始化workerManager中的Worker ** m_EmpArray 指针

在WorkerManager.h中添加成员函数 void init_Emp();

    //初始化员工
    void init_Emp();

在WorkerManager.cpp中实现

//初始化员工
void WorkerManager::init_Emp()
{
    ifstream ifs;
    ifs.open(FILENAME, ios::in);

    int id;
    string name;
    int dId;

    int index = 0;
    while (ifs >> id && ifs >> name && ifs >> dId)
    {
        Worker* worker = NULL;

        if (dId == 1) //普通职工
        {
            worker = new Employee(id, name, dId);
        }
        else if (dId == 2) //经理
        {
            worker = new Manager(id, name, dId);
        }
        else  //老板
        {
            worker = new Boss(id, name, dId);
        }
        this->m_EmpArray[index] = worker;
        index++;
    }

    //关闭文件
    ifs.close();
}

在workerManager.cpp构造函数中追加代码

    //根据职工数创建数组
    this->m_EmpArray = new Worker *[this->m_EmpNum];
    //初始化职工
    init_Emp();

显示职工

功能描述：显示当前所有职工信息

显示职工函数声明

在workerManager.h中添加成员函数 void Show_Emp();

    //显示职工
    voidShow_Emp();

显示职工函数实现

在workerManager.cpp中实现成员函数 void Show_Emp();

//显示职工
void WorkerManager::Show_Emp()
{
    //判断文件是否为空 
    if (this->m_FileIsEmpty)
    {
        cout << "文件不存在或记录为空!" << endl;
    }
    else
    {
        for (int i = 0; i < m_EmpNum; i++)
        {
            //利用多态调用程序接口
            this->m_EmpArray[i]->showInfo();
        }
    }
    //按任意键后清屏
    system("pause");
    system("cls");
}

删除职工

功能描述：按照职工的编号进行删除职工操作

删除职工函数声明

在workerManager.h中添加成员函数 void Del_Emp();

    //删除职工
    void Del_Emp();
职工是否存在函数声明

很多功能都需要用到根据职工是否存在来进行操作如：删除职工、修改职工、查找职工

因此添加该公告函数，以便后续调用

在workerManager.h中添加成员函数 int IsExist(int id);

    //按照职工编号判断职工是否存在,若存在返回职工在数组中位置，不存在返回-1
    int IsExist(intid);
职工是否存在函数实现

在workerManager.cpp中实现成员函数 int IsExist(int id);

int WorkerManager::IsExist(int id)
{
    int index=-1;
​
    for (inti=0; i < this->m_EmpNum; i++)
    {
        if (this->m_EmpArray[i]->m_Id == id)
        {
            index=i;
​
            break;
        }
    }
​
    return index;
}

删除职工函数实现

在workerManager.cpp中实现成员函数 void Del_Emp();

//删除职工
void WorkerManager::Del_Emp()
{
    if (this->m_FileIsEmpty)
    {
        cout<<"文件不存在或记录为空！"<<endl;
    }
    else
    {
        //按职工编号删除
        cout<<"请输入想要删除的职工号："<<endl;
        int id=0;
        cin>>id;
​
        int index=this->IsExist(id);
​
        if (index!=-1)  //说明index上位置数据需要删除
        {
            for (int i=index; i < this->m_EmpNum-1; i++)
            {
                this->m_EmpArray[i] =this->m_EmpArray[i+1];
            }
            this->m_EmpNum--;
​
            this->save(); //删除后数据同步到文件中
            cout<<"删除成功！"<<endl;
        }
        else
        {
            cout<<"删除失败，未找到该职工"<<endl;
        }
    }
    
    system("pause");
    system("cls");
}

修改职工

功能描述：能够按照职工的编号对职工信息进行修改并保存

修改职工函数声明

在workerManager.h中添加成员函数 void Mod_Emp();

//修改职工

voidMod_Emp();

修改职工函数实现

在workerManager.cpp中实现成员函数 void Mod_Emp();

​

//修改职工
void WorkerManager::Mod_Emp()
{
    if (this->m_FileIsEmpty)
    {
        cout<<"文件不存在或记录为空！"<<endl;
    }
    else
    {
        cout<<"请输入修改职工的编号："<<endl;
        int id;
        cin>>id;
​
        int ret=this->IsExist(id);
        if (ret!=-1)
        { 
            //查找到编号的职工
​
            delete this->m_EmpArray[ret];
            
            int newId=0;
            string newName="";
            int dSelect=0;
​
            cout<<"查到： "<<id<<"号职工，请输入新职工号： "<<endl;
            cin>>newId;
​
            cout<<"请输入新姓名： "<<endl;
            cin>>newName;
​
            cout<<"请输入岗位： "<<endl;
            cout<<"1、普通职工"<<endl;
            cout<<"2、经理"<<endl;
            cout<<"3、老板"<<endl;
            cin>>dSelect;
​
            Worker*worker=NULL;
            switch (dSelect)
            {
            case1:
                worker=new Employee(newId, newName, dSelect);
                break;
            case2:
                worker=new Manager(newId, newName, dSelect);
                break;
            case3:
                worker=new Boss(newId, newName, dSelect);
                break;
            default:
                break;
            }
​
            //更改数据 到数组中
            this->m_EmpArray[ret]=worker;
            
            cout<<"修改成功！"<<endl;
​
            //保存到文件中
            this->save();
        }
        else
        {
            cout<<"修改失败，查无此人"<<endl;
        }
    }
​
    //按任意键 清屏
    system("pause");
    system("cls");
}

查找职工

功能描述：提供两种查找职工方式，一种按照职工编号，一种按照职工姓名

查找职工函数声明

在workerManager.h中添加成员函数 void Find_Emp();

    //查找职工
    voidFind_Emp();
查找职工函数实现

在workerManager.cpp中实现成员函数 void Find_Emp();

//查找职工
void WorkerManager::Find_Emp()
{
    if (this->m_FileIsEmpty)
    {
        cout<<"文件不存在或记录为空！"<<endl;
    }
    else
    {
        cout<<"请输入查找的方式："<<endl;
        cout<<"1、按职工编号查找"<<endl;
        cout<<"2、按姓名查找"<<endl;
​
        int select=0;
        cin>>select;
​
​
        if (select==1) //按职工号查找
        {
            int id;
            cout<<"请输入查找的职工编号："<<endl;
            cin>>id;
​
            intret=IsExist(id);
            if (ret!=-1)
            {
                cout<<"查找成功！该职工信息如下："<<endl;
                this->m_EmpArray[ret]->showInfo();
            }
            else
            {
                cout<<"查找失败，查无此人"<<endl;
            }
        }
        elseif(select==2) //按姓名查找
        {
            string name;
            cout<<"请输入查找的姓名："<<endl;
            cin>>name;
​
            bool flag=false;  //查找到的标志
            for (inti=0; i<m_EmpNum; i++)
            {
                if (m_EmpArray[i]->m_Name==name)
                {
                    cout<<"查找成功,职工编号为："
                           <<m_EmpArray[i]->m_Id
                           <<" 号的信息如下："<<endl;
                    
                    flag=true;
​
                    this->m_EmpArray[i]->showInfo();
                }
            }
            if (flag==false)
            {
                //查无此人
                cout<<"查找失败，查无此人"<<endl;
            }
        }
        else
        {
            cout<<"输入选项有误"<<endl;
        }
    }
​
​
    system("pause");
    system("cls");
}

排序

功能描述：按照职工编号进行排序，排序的顺序由用户指定

14.1 排序函数声明

在workerManager.h中添加成员函数 void Sort_Emp();

    //排序职工
    void Sort_Emp();
14.2 排序函数实现

在workerManager.cpp中实现成员函数 void Sort_Emp();

//排序职工
void WorkerManager::Sort_Emp()
{
    if (this->m_FileIsEmpty)
    {
        cout<<"文件不存在或记录为空！"<<endl;
        system("pause");
        system("cls");
    }
    else
    {
        cout<<"请选择排序方式： "<<endl;
        cout<<"1、按职工号进行升序"<<endl;
        cout<<"2、按职工号进行降序"<<endl;
​
        int select=0;
        cin>>select;
​
​
        for (int i=0; i<m_EmpNum; i++)
        {
            int minOrMax=i;
            for (int j=i+1; j<m_EmpNum; j++)
            {
                if (select==1) //升序
                {
                    if (m_EmpArray[minOrMax]->m_Id>m_EmpArray[j]->m_Id)
                    {
                        minOrMax=j;
                    }
                }
                else  //降序
                {
                    if (m_EmpArray[minOrMax]->m_Id<m_EmpArray[j]->m_Id)
                    {
                        minOrMax=j;
                    }
                }
            }
​
            if (i!=minOrMax)
            {
                Worker*temp=m_EmpArray[i];
                m_EmpArray[i] =m_EmpArray[minOrMax];
                m_EmpArray[minOrMax] =temp;
            }
​
        }
​
        cout<<"排序成功,排序后结果为："<<endl;
        this->save();
        this->Show_Emp();
    }
​
}

清空文件

功能描述：将文件中记录数据清空

15.1 清空函数声明

在workerManager.h中添加成员函数 void Clean_File();

    //清空文件
    void Clean_File();
15.2 清空函数实现

在workerManager.cpp中实现员函数 void Clean_File();

//清空文件
void WorkerManager::Clean_File()
{
    cout<<"确认清空？"<<endl;
    cout<<"1、确认"<<endl;
    cout<<"2、返回"<<endl;
​
    int select=0;
    cin>>select;
​
    if (select==1)
    {
        //打开模式 ios::trunc 如果存在删除文件并重新创建
        ofstream ofs(FILENAME, ios::trunc);
        ofs.close();
​
        if (this->m_EmpArray!=NULL)
        {
            for (int i=0; i<this->m_EmpNum; i++)
            {
                if (this->m_EmpArray[i] !=NULL)
                {
                    delete this->m_EmpArray[i];
                }
            }
            this->m_EmpNum=0;
            delete[] this->m_EmpArray;
            this->m_EmpArray=NULL;
            this->m_FileIsEmpty=true;
        }
        cout<<"清空成功！"<<endl;
    }
​
    system("pause");
    system("cls");
}

完整代码

worker.h

#pragma once
#include <iostream>
using namespace std;
#include <string>

//职工抽象类
class Worker
{
public:

    //显示个人信息
    virtual void showInfo() = 0;

    //获取岗位名称
    virtual string getDeptName() = 0;

    //职工编号
    int m_Id;
    //职工姓名
    string m_Name;
    //部门编号
    int m_DeptId;
};

boss.h

#pragma once
#include <iostream>
using namespace std;
#include "worker.h"

//老板类
class Boss :public Worker
{
public:

    //构造函数
    Boss(int id, string name, int dId);

    //显示个人信息
    virtual void showInfo();

    //获取岗位名称
    virtual string getDeptName();

};

boss.cpp

#include "boss.h"

//构造函数
Boss::Boss(int id, string name, int dId)
{
    this->m_Id = id;
    this->m_Name = name;
    this->m_DeptId = dId;
}

//显示个人信息
void Boss::showInfo()
{
    cout << "职工编号：" << this->m_Id
        << "\t职工姓名：" << this->m_Name
        << "\t岗位：" << this->getDeptName()
        << "\t岗位职责： 管理公司所有事务" << endl;
}

//获取岗位名称
string Boss::getDeptName()
{
    return  string("总裁");
}

employee.h

//普通员工文件
#pragma once
#include <iostream>
using namespace std;
#include "worker.h"

class Employee :public Worker
{
public:

    //构造函数
    Employee(int id, string name, int dId);

    //显示个人信息
    virtual void showInfo();

    //获取岗位名称
    virtual string getDeptName();

};

employee.cpp

#include "employee.h"

//构造函数
Employee::Employee(int id, string name, int dId)
{
    this->m_Id = id;
    this->m_Name = name;
    this->m_DeptId = dId;
}

//显示个人信息
void Employee::showInfo()
{
    cout << "职工编号：" << this->m_Id
        << "\t职工姓名：" << this->m_Name
        << "\t岗位：" << this->getDeptName()
        << "\t岗位职责： 完成经理交给的任务" << endl;
}

//获取岗位名称
string Employee::getDeptName()
{
    return  string("员工");
}

manager.h

#pragma once
#include <iostream>
using namespace std;
#include "worker.h"

//经理类
class Manager :public Worker
{
public:

    //构造函数
    Manager(int id, string name, int dId);

    //显示个人信息
    virtual void showInfo();

    //获取岗位名称
    virtual string getDeptName();

};

manager.cpp

#include "manager.h"

//构造函数
Manager::Manager(int id, string name, int dId)
{
    this->m_Id = id;
    this->m_Name = name;
    this->m_DeptId = dId;
}

//显示个人信息
void Manager::showInfo()
{
    cout << "\t职工编号：" << this->m_Id <<
 "\t职工姓名：" << this->m_Name<< "\t岗位：" <<
 this->getDeptName()<< "\t岗位职责： 完成老板交给的任务，并下发任务给员工" << endl;
}

//获取岗位名称
string Manager::getDeptName()
{
    return  string("经理");
}

workerManager.h

#pragma once // 防止头文件重复包含
#include <iostream>  //包含输入输出流头文件
using namespace std; //使用标准命名空间
#include "worker.h"
#include "employee.h"
#include "manager.h"
#include "boss.h"

#include <fstream>
#define FILENAME "empFile.txt"




class WorkerManager
{
public:

    //构造函数
    WorkerManager();

    //展示菜单
    void Show_Menu();

    //退出系统
    void ExitSystem();


    //记录职工人数
    int m_EmpNum;

    //职工数组指针
    Worker** m_EmpArray;

    //添加职工
    void Add_Emp();

    //保存文件
    void save();

    //判断文件是否为空 标志
    bool m_FileIsEmpty;

    //统计文件中人数
    int get_EmpNum();

    //初始化员工
    void init_Emp();

    //显示职工
    void Show_Emp();

    //删除职工
    void Del_Emp();

    //判断职工是否存在  如果存在返回职工所在数组中的位置，不存在返回-1
    int IsExist(int id);

    //修改职工
    void Mod_Emp();

    //查找职工
    void Find_Emp();

    //按照编号排序
    void Sort_Emp();

    //清空文件
    void Clean_File();

    //析构函数
    ~WorkerManager();

};

workerManager.cpp

#include "workerManager.h"

WorkerManager::WorkerManager()
{

    //1、文件不存在

    ifstream ifs;
    ifs.open(FILENAME, ios::in); // 读文件

    if (!ifs.is_open())
    {
        //cout << "文件不存在" << endl;
        //初始化属性
        //初始化记录人数
        this->m_EmpNum = 0;
        //初始化数组指针 
        this->m_EmpArray = NULL;
        //初始化文件是否为空
        this->m_FileIsEmpty = true;
        ifs.close();
        return;
    }

    //2、文件存在 数据为空
    char ch;
    ifs >> ch;
    if (ifs.eof())
    {
        //文件为空
        //cout << "文件为空！" << endl;
        //初始化记录人数
        this->m_EmpNum = 0;
        //初始化数组指针 
        this->m_EmpArray = NULL;
        //初始化文件是否为空
        this->m_FileIsEmpty = true;
        ifs.close();
        return;
    }

    //3、文件存在，并且记录数据
    int num = this->get_EmpNum();
    //cout << "职工人数为： " << num << endl;
    this->m_EmpNum = num;

    //开辟空间
    this->m_EmpArray = new Worker * [this->m_EmpNum];
    //将文件中的数据 ，存到数组中
    this->init_Emp();

    //测试代码
    //for (int i = 0; i < this->m_EmpNum; i++)
    //{
    //    cout << "职工编号： " << this->m_EmpArray[i]->m_Id
    //        << " 姓名： " << this->m_EmpArray[i]->m_Name
    //        << " 部门编号： " << this->m_EmpArray[i]->m_DeptId << endl;
    //}
}

//展示菜单
void WorkerManager::Show_Menu()
{
    cout << "********************************************" << endl;
    cout << "*********  欢迎使用职工管理系统！ **********" << endl;
    cout << "*************  0.退出管理程序  *************" << endl;
    cout << "*************  1.增加职工信息  *************" << endl;
    cout << "*************  2.显示职工信息  *************" << endl;
    cout << "*************  3.删除离职职工  *************" << endl;
    cout << "*************  4.修改职工信息  *************" << endl;
    cout << "*************  5.查找职工信息  *************" << endl;
    cout << "*************  6.按照编号排序  *************" << endl;
    cout << "*************  7.清空所有文档  *************" << endl;
    cout << "********************************************" << endl;
    cout << endl;
}

//退出系统
void WorkerManager::ExitSystem()
{
    cout << "欢迎下次使用" << endl;
    system("pause");
    exit(0); // 退出程序
}

//添加职工
void WorkerManager::Add_Emp()
{
    cout << "请输入添加职工数量： " << endl;

    int addNum = 0; //保存用户的输入数量
    cin >> addNum;

    if (addNum > 0)
    {
        //添加
        //计算添加新空间大小
        int newSize = this->m_EmpNum + addNum; // 新空间人数 = 原来记录人数 + 新增人数

        //开辟新空间
        Worker** newSpace = new Worker * [newSize];

        //将原来空间下数据，拷贝到新空间下
        if (this->m_EmpArray != NULL)
        {
            for (int i = 0; i < this->m_EmpNum; i++)
            {
                newSpace[i] = this->m_EmpArray[i];
            }
        }

        //批量添加新数据
        for (int i = 0; i < addNum; i++)
        {
            int id; //职工编号
            string name; //职工姓名
            int dSelect; // 部门选择

            cout << "请输入第 " << i + 1 << " 个新职工编号： " << endl;
            cin >> id;

            cout << "请输入第 " << i + 1 << " 个新职工姓名： " << endl;
            cin >> name;

            cout << "请选择该职工岗位： " << endl;
            cout << "1、普通职工" << endl;
            cout << "2、经理" << endl;
            cout << "3、老板" << endl;
            cin >> dSelect;

            Worker* worker = NULL;
            switch (dSelect)
            {
            case 1:
                worker = new Employee(id, name, 1);
                break;
            case 2:
                worker = new Manager(id, name, 2);
                break;
            case 3:
                worker = new Boss(id, name, 3);
                break;
            default:
                break;
            }
            //将创建职工职责 ，保存到数组中
            newSpace[this->m_EmpNum + i] = worker;

        }

        //释放原有空间
        delete[] this->m_EmpArray;

        //更改新空间的指向
        this->m_EmpArray = newSpace;

        //更新新的职工人数
        this->m_EmpNum = newSize;

        //更新职工不为空标志
        this->m_FileIsEmpty = false;

        //提示添加成功
        cout << "成功添加" << addNum << "名新职工!" << endl;

        //保存数据到文件中
        this->save();

    }
    else
    {
        cout << "输入数据有误" << endl;
    }

    //按任意键后 清屏回到上级目录
    system("pause");
    system("cls");
}

//保存文件
void WorkerManager::save()
{
    ofstream ofs;
    ofs.open(FILENAME, ios::out); // 用输出的方式打开文件  -- 写文件

    //将每个人数据写入到文件中
    for (int i = 0; i < this->m_EmpNum; i++)
    {
        ofs << this->m_EmpArray[i]->m_Id << " "
            << this->m_EmpArray[i]->m_Name << " "
            << this->m_EmpArray[i]->m_DeptId << endl;
    }

    //关闭文件
    ofs.close();

}


//统计文件中人数
int WorkerManager::get_EmpNum()
{
    ifstream ifs;
    ifs.open(FILENAME, ios::in); //打开文件  读

    int id;
    string name;
    int dId;

    int num = 0;

    while (ifs >> id && ifs >> name && ifs >> dId)
    {
        //统计人数变量
        num++;
    }

    return num;

}

//初始化员工
void WorkerManager::init_Emp()
{
    ifstream ifs;
    ifs.open(FILENAME, ios::in);

    int id;
    string name;
    int dId;

    int index = 0;
    while (ifs >> id && ifs >> name && ifs >> dId)
    {
        Worker* worker = NULL;

        if (dId == 1) //普通职工
        {
            worker = new Employee(id, name, dId);
        }
        else if (dId == 2) //经理
        {
            worker = new Manager(id, name, dId);
        }
        else  //老板
        {
            worker = new Boss(id, name, dId);
        }
        this->m_EmpArray[index] = worker;
        index++;
    }

    //关闭文件
    ifs.close();
}

//显示职工
void WorkerManager::Show_Emp()
{
    //判断文件是否为空 
    if (this->m_FileIsEmpty)
    {
        cout << "文件不存在或记录为空!" << endl;
    }
    else
    {
        for (int i = 0; i < m_EmpNum; i++)
        {
            //利用多态调用程序接口
            this->m_EmpArray[i]->showInfo();
        }
    }
    //按任意键后清屏
    system("pause");
    system("cls");
}

//删除职工
void WorkerManager::Del_Emp()
{
    if (this->m_FileIsEmpty)
    {
        cout << "文件不存在或记录为空！" << endl;
    }
    else
    {
        //按照职工编号删除
        cout << "请输入想要删除职工编号：" << endl;
        int id = 0;
        cin >> id;

        int index = this->IsExist(id);

        if (index != -1) //说明职工存在，并且要删除掉index位置上的职工
        {

            for (int i = index; i < this->m_EmpNum - 1; i++)
            {
                //数据前移
                this->m_EmpArray[i] = this->m_EmpArray[i + 1];
            }
            this->m_EmpNum--; //更新数组中记录人员个数
            //数据同步更新到文件中
            this->save();

            cout << "删除成功！" << endl;
        }
        else
        {
            cout << "删除失败，未找到该职工" << endl;
        }
    }

    //按任意键 清屏
    system("pause");
    system("cls");
}

//判断职工是否存在  如果存在返回职工所在数组中的位置，不存在返回-1
int WorkerManager::IsExist(int id)
{
    int index = -1;

    for (int i = 0; i < this->m_EmpNum; i++)
    {
        if (this->m_EmpArray[i]->m_Id == id)
        {
            //找到职工
            index = i;

            break;
        }
    }

    return index;
}

//修改职工
void WorkerManager::Mod_Emp()
{
    if (this->m_FileIsEmpty)
    {
        cout << "文件不存在或记录为空！" << endl;
    }
    else
    {
        cout << "请输入修改职工的编号：" << endl;
        int id;
        cin >> id;

        int ret = this->IsExist(id);
        if (ret != -1)
        {
            //查找到编号的职工

            delete this->m_EmpArray[ret];

            int newId = 0;
            string newName = "";
            int dSelect = 0;

            cout << "查到： " << id << "号职工，请输入新职工号： " << endl;
            cin >> newId;

            cout << "请输入新姓名： " << endl;
            cin >> newName;

            cout << "请输入岗位： " << endl;
            cout << "1、普通职工" << endl;
            cout << "2、经理" << endl;
            cout << "3、老板" << endl;
            cin >> dSelect;

            Worker* worker = NULL;
            switch (dSelect)
            {
            case1:
                worker = new Employee(newId, newName, dSelect);
                break;
            case2:
                worker = new Manager(newId, newName, dSelect);
                break;
            case 3:
                worker = new Boss(newId, newName, dSelect);
                break;
            default:
                break;
            }

            //更改数据 到数组中
            this->m_EmpArray[ret] = worker;

            cout << "修改成功！" << this->m_EmpArray[ret]->m_DeptId << endl;

            //保存到文件中
            this->save();
        }
        else
        {
            cout << "修改失败，查无此人" << endl;
        }
    }

    //按任意键 清屏
    system("pause");
    system("cls");
}


//查找职工
void WorkerManager::Find_Emp()
{
    if (this->m_FileIsEmpty)
    {
        cout << "文件不存在或记录为空！" << endl;
    }
    else
    {
        cout << "请输入查找的方式：" << endl;
        cout << "1、按职工编号查找 " << endl;
        cout << "2、按职工姓名查找 " << endl;

        int select = 0;
        cin >> select;

        if (select == 1)
        {
            //按照编号查
            int id;
            cout << "请输入查找的职工编号： " << endl;
            cin >> id;

            int ret = IsExist(id);
            if (ret != -1)
            {
                //找到职工
                cout << "查找成功！该职工信息如下：" << endl;
                this->m_EmpArray[ret]->showInfo();
            }
            else
            {
                cout << "查找失败，查无此人" << endl;
            }
        }
        else if (select == 2)
        {
            //按照姓名查
            string name;
            cout << "请输入查找的姓名：" << endl;
            cin >> name;

            //加入判断是否查到的标志
            bool flag = false; //默认未找到职工

            for (int i = 0; i < m_EmpNum; i++)
            {
                if (this->m_EmpArray[i]->m_Name == name)
                {
                    cout << "查找成功，职工编号为： "
                        << this->m_EmpArray[i]->m_Id
                        << "号职工信息如下：" << endl;

                    flag = true;

                    //调用显示信息接口
                    this->m_EmpArray[i]->showInfo();
                }
            }
            if (flag == false)
            {
                cout << "查找失败，查无此人！" << endl;
            }
        }
        else
        {
            cout << "输入选项有误！" << endl;
        }
    }

    //按任意键清屏
    system("pause");
    system("cls");
}

//按照编号排序
void WorkerManager::Sort_Emp()
{
    if (this->m_FileIsEmpty)
    {
        cout << "文件不存在或记录为空！" << endl;
        system("pause");
        system("cls");
    }
    else
    {
        cout << "请选择排序方式：" << endl;
        cout << "1、按职工号进行升序" << endl;
        cout << "2、按职工号进行降序" << endl;

        int select = 0;
        cin >> select;
        for (int i = 0; i < m_EmpNum; i++)
        {
            int minOrMax = i; //声明最小值 或 最大值下标
            for (int j = i + 1; j < this->m_EmpNum; j++)
            {
                if (select == 1) //升序
                {
                    if (this->m_EmpArray[minOrMax]->m_Id > this->m_EmpArray[j]->m_Id)
                    {
                        minOrMax = j;
                    }
                }
                else  //降序
                {
                    if (this->m_EmpArray[minOrMax]->m_Id < this->m_EmpArray[j]->m_Id)
                    {
                        minOrMax = j;
                    }
                }
            }

            //判断一开始认定 最小值或最大值 是不是 计算的最小值或最大值，如果不是 交换数据
            if (i != minOrMax)
            {
                Worker* temp = this->m_EmpArray[i];
                this->m_EmpArray[i] = this->m_EmpArray[minOrMax];
                this->m_EmpArray[minOrMax] = temp;
            }

        }

        cout << "排序成功！排序后的结果为： " << endl;
        this->save(); //排序后结果保存到文件中
        this->Show_Emp();//展示所有职工
    }

}


//清空文件
void WorkerManager::Clean_File()
{
    cout << "确定清空？" << endl;
    cout << "1、确定" << endl;
    cout << "2、返回" << endl;

    int select = 0;
    cin >> select;

    if (select == 1)
    {
        //清空文件
        ofstream ofs(FILENAME, ios::trunc); // 删除文件后重新创建
        ofs.close();

        if (this->m_EmpArray != NULL)
        {
            //删除堆区的每个职工对象
            for (int i = 0; i < this->m_EmpNum; i++)
            {
                delete this->m_EmpArray[i];
                this->m_EmpArray[i] = NULL;
            }

            //删除堆区数组指针
            delete[] this->m_EmpArray;
            this->m_EmpArray = NULL;
            this->m_EmpNum = 0;
            this->m_FileIsEmpty = true;
        }

        cout << "清空成功！" << endl;
    }

    system("pause");
    system("cls");
}




WorkerManager::~WorkerManager()
{
    if (this->m_EmpArray != NULL)
    {
        for (int i = 0; i < this->m_EmpNum; i++)
        {
            if (this->m_EmpArray[i] != NULL)
            {
                delete this->m_EmpArray[i];
            }
        }

        delete[] this->m_EmpArray;
        this->m_EmpArray = NULL;
    }
}

职工管理系统.cpp

#include <iostream> 
using  namespace std;
#include "workerManager.h"

//#include "worker.h"
//#include "employee.h"
//#include "manager.h"
//#include "boss.h"

int main()
{
    测试代码：
    //Worker * worker = NULL;
    //worker = new Employee(1, "张三", 1);
    //worker->showInfo();
    //delete worker;

    //worker = new Manager(2, "李四", 2);
    //worker->showInfo();
    //delete worker;

    //worker = new Boss(3, "王五", 3);
    //worker->showInfo();
    //delete worker;

    //实例化管理者对象
    WorkerManager wm;

    int choice = 0; //用来存储用户的选项

    while (true)
    {
        //调用展示菜单成员函数
        wm.Show_Menu();

        cout << "请输入您的选择： " << endl;
        cin >> choice; // 接受用户的选项

        switch (choice)
        {
        case 0:  //退出系统
            wm.ExitSystem();
            break;
        case 1:  //增加职工
            wm.Add_Emp();
            break;
        case 2:  //显示职工
            wm.Show_Emp();
            break;
        case 3:  //删除职工
            wm.Del_Emp();
            break;
        case 4:  //修改职工
            wm.Mod_Emp();
            break;
        case 5:  //查找职工
            wm.Find_Emp();
            break;
        case 6:  //排序职工
            wm.Sort_Emp();
            break;
        case 7:  //清空文档
            wm.Clean_File();
            break;
        default:
            system("cls"); //清屏
            break;
        }

    }

    system("pause");

    return 0;
}

全篇结束

垃圾堆里的程序员
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++基于多态的职工管理系统
01-26
基于面向对象多态的思想，实现一个简单的职工管理系统
黑马程序员C++实战(二)——基于多态的职工管理系统完整代码
weixin_44159487的博客
03-10 1496
本文转载自：https://github.com/AnkerLeng/Cpp-0-1-Resource.git 视频见：https://www.bilibili.com/video/av41559729?p=31 workerManager.h #pragma once // 防止头文件重复包含 #include<iostream> // 包含输入输出流头文件 using n......
基于多态的职工管理系统（C++）
晨的博客
07-30 445
#1、案列 ##2、心得 通过这个案列，让我对C++的面向对象特性有了更深的理解，对一切皆对象也有了一定的了解，对多态的优点也有了一定的认识，同时复习了基本的循环、判断和顺序结构。在这个案列中对工程文件的组织结构有了一定的了解。 ###3、代码 1、boss类头文件 #pragma once #include<iostream> using namespace std; #include"worker.h" //老板类 class Boss :public Worker { public:
C++开发基于多态的职工管理系统源码.zip
05-31
C++开发基于多态的职工管理系统源码C++开发基于多态的职工管理系统源码C++开发基于多态的职工管理系统源码C++开发基于多态的职工管理系统源码C++开发基于多态的职工管理系统源码C++开发基于多态的职工管理系统源码...
基于多态的职工管理系统
04-24
功能包括： ...可改写为其他系统，如学生管理、成绩管理等。 可从中学习到的内容为： 1.多态的使用 2.抽象类的使用 3.文件读写 4.二重指针数组 5.虚函数的使用 6.动态多态的应用 7.继承与面向对象的使用
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1010
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 146
BCSP-X 11题 C++代码详解
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 753
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 324
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 292
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
【C++】 基础复习 ｜ 数据类型，输入，输出流 scanf printf
专注于人工智能的算法与应用
06-11 827
是 C 语言中两个非常重要的标准输入输出函数，它们分别用于从标准输入（通常是键盘）读取数据和向标准输出（通常是屏幕）打印数据。在这种情况下如果想控制输出，即满足一定格式输出，比如保留几位小数什么的，就要用manipulator了。需要变量的地址 ，即前面需要加一个&。函数用于从标准输入读取数据，并根据格式字符串解析这些数据。存储内存地址的变量。用户定义的复合数据类型，用于将不同类型的数据组合在一起。称做流式输入输出，
C语言：详解gcc驱动程序完成编译、汇编、链接的过程
前进，才知道自己的渺小
06-06 1564
gcc是一个命令，严格意义上说，它只是一个驱动程序，而不是一个编译器。gcc负责调用GNU工具链中的预处理器、编译器、汇编器、链接器等工具，通过传递不同的选项给gcc命令，可以让其只完成某些步骤，比如下面的命令，用于只对源文件进行预处理。
c++【入门】买文具2
LYK_0910的博客
06-11 134
花花去文具店买了1支笔和1块橡皮，已知笔x元/支，橡皮y元/块，花花付给了老板n元，请问老板应该找给花花多少钱？三个整数x、y、n，分别代表了笔的单价、橡皮的单价和花花付给老板的钱（已知花花付给老板的钱n>=x+y）。一个整数，代表老板应该找给花花的钱。内存限制 : 128 MB。时间限制 : 1 秒。
深度搜索算法3（c++）
mmz1207的博客
06-08 387
农夫约翰总是想要一个农场的地图，所以他拍摄了一张N行M列的卫星照片。一部分的照片看起来像这样： 他认为每个联通块都是一个谷仓或一头奶牛。农夫约翰认为一个联通块是谷仓，当且仅当它是一个完整的矩形，否则该联通块是一头奶牛。在下面的照片中，有三个谷仓（大小分别为2x1,2x5和1x1）和两头奶牛。计算他的卫星照片中谷仓和奶牛的数量。行2..N + 1：行i + 1表示照片的行i包含M个字 符（且不含空格）。行1：两个空格分隔的整数：N和M。行1：照片中的谷仓数量。行2：照片中的奶牛数量。
C语言，struct 结构体、union共用体的使用
sinat_30943509的博客
06-12 517
/状态字节，根据数据定义几个标志，标志位依据联合体内部结构体进行变量定义。//目的，节省内存空间，省去特定字节。
C++回溯算法
Yigeputongren的博客
06-11 98
【代码】C++回溯算法。
ARM 汇编 C语言 for循环
最新发布
haojie
06-12 645
在使用 Keil 编译基于 STM32F103 的 C 语言程序时，生成的汇编代码会有一些不同。使用 Keil 编译器（如 ARMCC 或 ARMCLANG）编译上述代码，生成的汇编代码可能类似于以下内容。注意，这只是一个近似的手写示例，实际生成的代码可能会有所不同。使用 Keil 编译器时，可以通过查看生成的 .lst 或 .asm 文件来查看编译后的汇编代码。实际生成的汇编代码可能会根据具体的编译器优化选项和编写的 C 代码有所不同。同时可以看下这篇文章。
C++ Easyx案例实战：Cookie Maker工作室1.0V
快乐星空Maker的博客
06-09 723
有彩蛋！
C++ opengl 纹理映射
sss_brs的博客
06-12 107
老样子，改出来的，问GPT。
黑马C++基于多态的
10-06
基于多态的C++黑马编程是指通过使用基类的指针或引用来调用派生类的成员函数，从而实现运行时的多态性。在黑马C中，可以通过继承和虚函数来实现多态。继承是指一个类从另一个类派生出来，被派生的类称为子类或派生类，而继承的类称为父类或基类。虚函数是在基类中声明的，当派生类通过继承来拥有这个函数时，派生类可以对虚函数进行重写，并且在运行时根据对象的实际类型来调用相应的函数。 在黑马C中使用基于多态的编程可以实现以下效果： 1. 实现代码的灵活扩展和维护。通过基类的指针或引用调用派生类的函数，可以在不修改基类代码的情况下，通过添加新的派生类来扩展功能。 2. 实现代码的高内聚和低耦合。通过将相关的类组织在一起，可以减少代码之间的依赖性，提高代码的可读性和可维护性。 3. 实现代码的多样化功能。不同的派生类可以根据自身特点实现不同的功能，通过基类的指针或引用来统一处理，提高代码的复用性和可扩展性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值