C++语言程序设计

五只小猪称体重(在一个数组中找到最大值)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include<iostream>
using namespace std;
int main()
{
    int arr[5]={300,350,200,400,250}
//算法：认定MAX为最大值，访问数组中每个元素，如果这个元素比我认定的最大值大，则更新最大值
    int MAX=0;
    for(int i=0;i<5;i++)
    {
        if(arr[i]>MAX)
        {
            MAX=arr[i];
        }
    }
    //打印最大值
    cout<<"最重的小猪体重为:"<<MAX<<endl;
    return 0；
}

数组元素逆置(如原数组元素为1，2，3，4，5逆置后输出结果为5，4，3，2，1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include<iostream>
using namespace std;
int main()
{
    int start=0;//起始元素的下标
    int end=sizeof(arr)/sizeof(arr[0]-1);//末尾元素下标
    while(start<end)
    {
      //start和end下标元素进行互换(创建临时变量)
      int temp=arr[start];
      arr[start]=arr[end];
      arr[end]=temp;
      atart++;
      end--;
    }
    cout<<"数组元素更新后："<<endl;
    for(int i=0;i<5;i++)
    {
        cout<<arr[i]<<endl;
    }
    system("pause");
    return 0;
}

结构体案例

案例1：学校正在做毕设项目，每名老师带领5个学生，总共有三名老师，需求如下
设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员，学生的成员有姓名，考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值，最终打印出老师数据以及老师所带的学生数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include<iosteam>
using namespace std;
#include<string>
#include<Ctime>

//学生的结构体定义
struct Student;
{
    //姓名
    string sName;
    //分数
    int score;
}
//老师的结构体定义
struct Teacher
{
    //姓名
    string tName;
    //学生数组
    struct Student sArray[5];
}
//给老师和学生赋值的函数
void allocateSpace(struct Teacher tArray[],int len)
{
    string nameSeed="ABCDE";
    for(int i=0;i<len;i++)//外侧for循环给老师进行赋值
    {
        //先赋值老师姓名
        tArray[i].tName="Teacher_";
        tArray[i].tName+=nameSeed[i];//相当于追加一个字母
        //通过内循环给每个老师带的学生赋值
        for(int j=0;j<5;j++)
        {
            tArray[i].sArray[j].sName="Student_";
            tArray[i].sArray[j].sname+=nameSeed[j];
            
            //给分数是一个随机值
            int random=rand()%61+40;  //0+40~60+40
            tArray[i].sArray[j].score=random;
        }
    }
}
//打印所有信息的函数
void printinfo(struct Teacher tArray[],int len)
{
    //遍历老师
    for(int i=0;i<len;i++)
    {
        cout<<"老师姓名:"<<tArray[i].tName<<endl;
        for(int j=0;j<5;j++)
        {
            cout<<"\t学生姓名:"<<tArray[i].sArray[j].sName<<" 考试分数:"<<tArray[i].sArray[j].score<<endl;  //\t空格效果更明显
        }
    }
}
int main()
{
    //随机数种子
    srand((unsigned int)time(NULL))
    //创建3名老师的数组
    struct Teacher tArray[3];
    //通过函数给3名老师的信息赋值，并给老师带的学生信息赋值
    int len=sizeof(tArray)/sizeof(tArray[0]);
    allocateSpace(tArray,len);
    //打印所有老师及所带的学生信息
    printInfo();
}
案例2：设计一个英雄的结构体，包括成员姓名，年龄，性别；创建结构体数组，数组中存放5名英雄，通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。

五名英雄信息如下：

1
2
3
4
5
{"刘备",23,"男"}
{"关羽",22,"男"}
{"张飞",20,"男"}
{"赵云",21,"男"}
{"貂蝉",19,"女"}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#include<iostream>
using namespace std;
#include<string>

//英雄的结构体定义
struct Hero
{
    //姓名
    string name;
    //年龄
    int age;
    //性别
    string sex;
};
//冒泡排序，实现年龄升序排列的函数
void bubbleSort(struct Hero heroArray[],int len)
{
    for(int i=0;i<len-1;i++)
    {
        for(int j=0;j<len-i-1;j++)
        {
            if(heroArray[j].age>heroArray[j+1],age)
            {
                struct Hero temp=heroArray[j];  //定义temp的数据类型要为struct Hero
                heroArray[j]=heroArray[j+1];
                heroArray[j+1]=temp;
            }
        }
    }
}
//打印函数
void printHero(struct Hero heroArray[],int len)
{
    for(int i=0;i<len;i++)
    {
         cout<<"排序后排序:"<<"姓名:"<<heroArray[i].name<<"年龄:"<<heroArray[i].age<<"性别:"<<heroArray[i].sex<<endl
    }
}
int main()
{
    //1.设计英雄结构体
    //2.创建数组存放5名英雄
    struct Hero heroArray[5]=
    {
        {"刘备",23,"男"},
        {"关羽",22,"男"},
        {"张飞",20,"男"},
        {"赵云",21,"男"},
        {"貂蝉",19,"女"},
    }
    int len=sizeof(heroArray)/sizeof(heroArray[0]);
   //排序前打印
    for(i=0;i<len;i++)
    {
        cout<<"姓名:"<<heroArray[i].name<<"年龄:"<<heroArray[i].age<<"性别:"<<heroArray[i].sex<<endl
    }
    //3.对数组进行排序，按照年龄进行升序排序
    bubbleSort(heroArray,len);
    //4.将排序后的结果排序输出
    printHero(HeroArray,len);
}

通讯录管理系统

  • 添加联系人：向通讯录中添加新人，信息包括（姓名，性别，年龄，联系电话，家庭住址）最多纪录1000人
  • 显示联系人：显示通讯录中所有联系人信息
  • 删除联系人：按照姓名进行删除指定联系人
  • 查找联系人：按照姓名查看指定联系人信息
  • 修改联系人：按照姓名重新修改指定联系人
  • 清空联系人：清空通讯录里全部信息
  • 退出通讯录：退出当前使用的通讯录
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
//菜单功能 1.封装函数显示界面  2.在main函数中调用封装好的函数
#include<iostream>
using namespace std;
//菜单界面
void showMenu()
{
    cout<<"************************"<<endl;
    cout<<"*****  1,添加联系人  *****"<<endl;
    cout<<"*****  2,显示联系人  *****"<<endl;
    cout<<"*****  3,删除联系人  *****"<<endl;
    cout<<"*****  4,查找联系人  *****"<<endl;
    cout<<"*****  5,修改联系人  *****"<<endl;
    cout<<"*****  6,清空联系人  *****"<<endl;
    cout<<"*****  0,退出通讯录  *****"<<endl;
    cout<<"************************"<<endl;
}
//主函数
int main()
{
    
    //创建通讯录结构体变量
    struct Addressbooks abs;
    //初始化通讯录中当前人员个数
    abs.m_Size=0;
    
    
    int select=0;  //创建用户选择输入的变量
    
while(true)
{
    //展示菜单调用
    showMenu();
    
    cin>>select;
    
    //退出功能
    switch(switch_on)
    {
        case 1:  //添加联系人
            addPerson(&abs);//利用地址传递可以在形参中修改实参
            break;
        case 2:  //显示联系人
            break;
        case 3:  //删除联系人
            deletePerson(&abs);
            break;
        case 4:  //查找联系人
            findPerson(&abs);
            break;
        case 5:  //修改联系人 
            modifyPerson(&abs);
            break;
        case 6:  //清空联系人
            break;
        case 0:  //退出通讯录
            cout<<"欢迎下次使用"<<endl;
            system("pause"); //按下任意键退出
            return 0;
            break;
    }
}
   
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
//一，添加联系人功能
1.设计联系人结构体：姓名，性别，年龄，联系电话，家庭住址
2.设计通讯录结构体
3.main函数中创建通讯录
4.封装添加联系人函数
5.测试添加联系人功能

#include<iostream>
#include<string>
using namespace std;
#define MAX 1000//最大人数
//设计联系人结构体
struct Person
{
    //姓名
    string m_name;
    //性别  1.男 2.女
    int m_Sex;
    //年龄
    int mPhone;
    //住址
    string m_Addr;
};

//设计通讯录结构体
struct Addressbooks
{
    //通讯录中保存的联系人数组
    struct Person personArrray[MAX];
    //通讯录中当前记录的联系人个数
    int m_Size;
}


//添加联系人
void addPerson(struct Addressbooks * abs)
{
    //判读通讯录是否已满，如果满了就不在添加
    if(abs->m_Size==MAX)
    {
        cout<<"通讯录已满，无法添加！"<<endl;
        return;
    }
    else
    {
        //添加具体联系人
        //姓名
        string name;
        cout<<"请输入联系人:"<<endl;
        cin>>name;
        abs->personArray[abs->m_Size].m_Name=name;
        //性别
        cout<<"请输入性别:"<<endl;
        cout<<"1----男"<<endl;
        cout<<"2----女"<<endl;
        int sex=0;
        if(sex==1||sex==2)
        {
            abs->personArray[abs->m_Size].m_Sex=sex;
            break;
        }
        //年龄
        cout<<"请输入年龄:"<<endl;
        int age=0;
        cin>>age;
        abs->personArray[abs->m_Size].m_Age=age;
        //电话
        cout<<"请输入联系电话:"<<endl;
        string Phone;
        cin>>phone;
        abs->persomArray[abs->m_Size].m_Phone=phone;
        //住址
        cout<<"请输入家庭住址:"<<endl;
        string address;
        cin>>address;
        abs->personArray[abs->m_Size].m_Addr=address;
        
        //更新通讯录人数
        abs->m_Size++;
        cout<<"添加成功"<<endl;
        
        system("pause");//请按任意键继续
        system("cls");//清屏操作        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//二，显示联系人，判断如果当前通讯录中没有人员，就提示记录为空，人数大于0，显示通讯录中信息
void showPerson(Addressbooks * abs)
{
    //判断通讯录中人数是否为0，如果为0，提示记录为空
    //如果不为0，显示记录的联系人信息
    if(abs->m_Size==0)
    {
        cout<<"当前记录为空"<<endl;
    }
    else
    {
        for(int i=0;i<abs->m_Size;i++)
        {
            cout<<"姓名："<<abs->personArray[i].m_Name<<"\t"; //水平制表符，其中8个空格
            cout<<"性别："<<(abs->personArray[i].m_Sex==1?"男":"女")<<"\t";  //男女改变显示效果
            cout<<"年龄："<<abs->personArray[i].m_Age<<"\t";
            cout<<"电话："<<abs->personArray[i].m_Phone<<"\t";
            cout<<"住址："<<abs->personArray[i].m_Addr<<endl;
        }
    }
    system("pause");//按任意键继续
    system("cls");//清除屏幕
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
//三，删除联系人
//封装检测联系人是否存在的函数，先判断用户输入的联系人是否存在，如果存在删除，不存在提示用户没有要删除的联系人，因此可以把检测联系人是否存在封装成一个函数中，如果存在，返回联系人在通讯录的位置，不存在返回-1
int isExist(Addressbooks *abs,string name)//参数一 通讯录，参数二 对比姓名
{
    for(int i=0;i<abs->m_Size;i++)
    {
        if(abs->personArray[i].m_Name==name)
        {
            return i;//找到了，返回这个人在数组中的下标编号
        }
    }
    return -1;//如果遍历结束都没有找到，返回-1
}

void deletePerson(Addressbooks * abs)
{
    cout<<"请输入您要删除的联系人"<<endl;
    string name;
    cin>>name;
    
    //ret==-1  未查到
    //ret!=-1  查到了
    int ret=isExist(abs,name);
    
    if(ret!-1)
    {
        //查到此人进行删除操作
        //需要知道要删除的人在数组中对应的下标，将他之后的数据向前移动，并且让通讯录里人员个数进行一个减一的操作
        for(int i=ret;i<abs->m_Size;i++)
        {
            //数据前移动操作
            abs->personArray[i]=abs->personArray[i+1];
        }
        abs->personArray[i]=abs->personArray[i+1];
        cout<<"删除成功"<<endl;
    }
    else
    {
        cout<<"未查到此人"<<endl;
    }
    system("pause");
    system("cls");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//四，查找联系人
//判断用户指定联系人是否存在，如果显示
void findPerson(Addressbooks * abs)
{
    cout<<"请输入您要查找的联系人"<<endl;
    string name;
    cin>>name;
    //判断指定的联系人是否存在通讯录中
    int ret=isExist(abs,name);
    if(ret!=-1)//找到联系人
    {
        cout<<"姓名:"<<abs->personArray[ret].m_Name<<"\t";
        cout<<"性别:"<<abs->personArray[ret].m_Sex<<"\t";
        cout<<"年龄:"<<abs->personArray[ret].m_Age<<"\t";
        cout<<"姓名:"<<abs->personArray[ret].m_Phone<<"\t";
        cout<<"姓名:"<<abs->personArray[ret].m_Addr<<"\t";
    }
    else//未找到联系人
    {
        cout<<"查无此人"<<endl;
    }
    
    //任意键按下后  清屏
    system("pause");
    system("cls");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//五，修改联系人
void modifyPerson(Addressbooks * abs)
{
    cout<<"请您输入要修改的联系人"<<endl;
    string name;
    cin>>name;
    int ret=isExist(abs,name);
    if(ret!=-1)//找到指定联系人
    {
        //姓名
        string name;
        cout<<"请输入姓名："<<endl;
        cin>>name;
        abs->personArray[ret].m_Name=name;
        //性别
        cout<<"请输入性别："<<endl;
        cout<<"1---男"<<endl;
        cout<<"2---女"<<endl;
        int sex=0;
    while(true)
      {
          cin>>sex;
          if(sex==1||sex==2)
          {
              //输入正确退出循环输入
            abs->personArray[ret].m_Sex=sex;
              break;
          }
            cout<<"输入有误，请重新输入"<<endl;
      }
        //年龄
        cout<<"请输入年龄："<<endl;
        int age=0;
        cin>>age;
        abs->personArray[ret].m_Age=age;
        //电话
        cout<<"请输入联系电话："<<endl;
        string phone;
        cin>>phone;
        abs->personArray[ret].m_Phone=phone;
        //住址
        cout<<"请输入家庭住址："<<endl;
        string address;
        cin>>address;
        abs->personArray[ret].m_Adde=address;
        
        cout<<"修改成功!"<<endl;
    }
    else//未找到
    {
        cout<<"查无此人"<<endl;
    }
   
}
1
2
3
4
5
6
7
8
9
//六，清空联系人
//只需要将通讯录中记录的联系人数量为0，做逻辑清空即可
void cleanPerson(Addressbooks * abs)
{
    abs->m_Size=0;//将当前记录联系人数量置为0，做逻辑清空操作
    cout<<"通讯录已经清空"<<endl;
    system("pause");
    system("cls");
}

设计立方体类

(求出立方体的面积和体积，分别用全局函数和成员函数判断两个立方体是否相等)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
//创建立方体的类
//设计属性和行为
//设计行为 获取立方体的面积和体积
//分别利用全局函数和成员函数 判断两个立方体是否相等

class Cube
{
    private:
    int m_L;
    int m_W;
    int m_H;
    public:
    //设置接口
    //设置宽
    void setW(int w)
    {
        m_L=w;
    }
    
    //获取宽
    int getW()
    {
        return m_W;
    }
    //设置长
    void setL(int l)
    {
        m_L=l;
    }
    
    //获取长
    int getL()
    {
        return m_L;
    }
    
    //设置高
    void setL(int h)
    {
        m_H=h;
    }
    //获取高
    int getL()
    {
        return m_H;
    }
    
    //获取立方体的面积
    int caculateS()
    {
        return 2*m_L*m_W+2*m_W*m_H+2*m_L*m_H;
    }
    //获取立方体的体积
    int calculateV()
    {
        return m_L*m_W*m_H;
    }
    
    //利用成员函数判断两个立方体是否相等
    bool isSameByClass(Cube &c)
    {
        if(m_L==c.getL()m_W==c.getW()&&m_H==c.getH())
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}



//利用全局函数判断 两个立方体是否相等
bool isSame(Cube &c1,Cube &c2)
{
    if(c1.getL()==c2.getL()&&c1.getW()==c2.getW()&&c1.getH()==c2.getH())
    {
        return true;
    }
    else
    {
        return false;
    }
}



int main()
{
    //创建立方体的对象
    Cube c1;
    c1.setL(10);
    c1.setW(10);
    c1.steH(10);
    cout<<"c1的面积为:"<<c1.calculateS()<<endl;
    cout<<"c1的体积为:"<<c1.calculateV()<<endl;
    
    //创建第二个立方体
    Cube c2;
    c2.setL(10);
    c2.setW(10);
    c2.steH(15);
    //利用全局函数判断
    bool ret=isSame(c1,c2);
    if(ret)
    {
        cout<<"c1和c2是相等的"<<endl;
    }
    else
    {
        cout<<"c1和c2不相等"<<endl;
    }
    //利用成员函数判断
    bool ret=isSame(c1,c2);
    if(ret)
    {
        cout<<"成员函数判断 c1和c2是相等的"<<endl;
    }
    else
    {
        cout<<"成员函数判断 c1和c2不相等"<<endl;
    }
    
}

设计点和圆的关系

1
//判断点到圆心的距离和半径进行比较

多态案例-----计算器类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
//分别利用普通或者多态的技术实现计算器
//普通写法
class Calculator
{
public:
    int getResult(string oper)
    {
        if(oper=="+")
            return m_Num1+m_Num2;
        if(oper=="-")
            return m_Num1-m_Num2;
        if(oper=="*")
            return m_Num1*m_Num2;
        //如果想扩展新的功能，需要修改源码
        //在真实开发中 提倡 开闭原则：对扩展进行开放，对修改进行关闭
    }
    int m_Num1;
    int m_Num2;
};
void text01
{
    Calculator c;
    c.m_Num1=10;
    c.m_Num2=10;
    
    cout<<c.m_Num1<<"+"<<c.m_Num2<<"="<<c.getResult("+")<<endl;
    cout<<c.m_Num1<<"-"<<c.m_Num2<<"="<<c.getResult("-")<<endl;
    cout<<c.m_Num1<<"*"<<c.m_Num2<<"="<<c.getResult("*")<<endl;
}
main()
{
    text01();
}
//多态写法实现计算器
//多态好处：
/*1.组织结构清晰
  2.可读性强
  3.对于后期扩展和维护性高，不需要对源码更正
*/


//计算器的抽象类
class AbstractCalculator
{
 public:
    virtual int getResult()
    {
        return 0;
    }
    int m_Num1;
    int m_Num2;
};

//设计加法计算器类
class AddCalculator:public AbstractCalculator
{
public:
    int getResult()
    {
        return m_Num1+m_Num2;
    }
};
//设计减法计算器类
class SubCalculator:public AbstractCalculator
{
public:
    int getResult()
    {
        return m_Num1-m_Num2;
    }
};
//设计乘法计算器类
class MulCalculator:public AbstractCalculator
{
public:
    int getResult()
    {
        return m_Num1*m_Num2;
    }
};
void text02()
{
    //父类的指针或引用指向子类对象
    //加法运算
    AbstractCalculator *abc=new AddCalculator;//new AddCalculator相当于创建了一个子类对象
    abc->m_Num1=10;
    abc->m_Num2=10;
    cout<<abc->m_Num1<<"+"<<abc->m_Num2<<"="<<abc->getResult()<<endl;
    //用完后记得销毁
    delete abc;  //把堆区数据释放，但指针类型没有变
    
    //减法运算
    abc=new SubCalculator;  //现在还相当于父类指针指向子类对象
    abc->m_Num1=100;
    abc->m_Num2=100;
    cout<<abc->m_Num1<<"-"<<abc->m_Num2<<"="<<abc->getResult()<<endl;
    delete abc;
    
    //乘法运算
    abc=new SubCalculator;  
    abc->m_Num1=100;
    abc->m_Num2=100;
    cout<<abc->m_Num1<<"*"<<abc->m_Num2<<"="<<abc->getResult()<<endl;
    delete abc;
}
main()
{
    text01();
    text02();
}

多态案例-----制作饮品

大致流程：煮水 - 冲泡 - 倒入杯中 - 加入辅料

提供抽象制作饮品类，提供子类制作咖啡和茶叶
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
class AbstractDrinking
{
public:
    //煮水
    virtual void Boil()=0;
    
    //冲泡
    virtual void Brew()=0;
    
    //倒入杯中
    virtual void PourInCup()=0;
    
    //加入辅料
    virtual void PutSomething()=0;
    
    //制作饮品
    void makeDrink();
    {
        Boil();
        Brew();
        PourInCup();
        PutSomething();
    }
};
//制作咖啡
class Coffee:public AbstractDrinking
{
public:
    //煮水
    virtual void Boil()
    {
        cout<<"煮农夫山泉"<<endl;
    }
    
    //冲泡
    virtual void Brew()
    {
        cout<<"冲泡咖啡"<<endl;
    }
    
    //倒入杯中
    virtual void PourInCup()
    {
        cout<<"倒入杯中"<<endl;
    }
    
    //加入辅料
    virtual void PutSomething()
    {
        cout<<"加入糖和牛奶"<<endl;
    }
};
//制作茶水
class Tea:public AbstractDrinking
{
public:
    //煮水
    virtual void Boil()
    {
        cout<<"煮矿泉水"<<endl;
    }
    
    //冲泡
    virtual void Brew()
    {
        cout<<"冲泡茶叶"<<endl;
    }
    
    //倒入杯中
    virtual void PourInCup()
    {
        cout<<"倒入杯中"<<endl;
    }
    
    //加入辅料
    virtual void PutSomething()
    {
        cout<<"加入枸杞"<<endl;
    }  
};

void dowork(AbstractDrinking *abs)//AbstractDrinking *abs=new Coffee 
{
    abs->makeDrink();
    delete abs;
}

void text01()
{
    //制作咖啡
    dowork(new Coffee);
    
    cout<<"----------------------"<<endl;
    
    //制作茶叶
    dowork(new Tea);
}

main()
{
    text01();
}

new创建对象是否调用构造函数和析构函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include<iostream>
using namespace std;
class Point
{
public:
    static int number;
public:
    point(){number++;}
    ~point(){number--;}
};
int point::number=0;
void main()
{
    point *ptr; //指针不会调用构造函数和析构函数，只是定义了一个指针，没有申请内存
    point A,B;//调用构造函数
    {
        point *ptr_point=new point[3]; //调用三次构造函数  使用new创建对象时，申请分配内存调用构造函数
        ptr=ptr_point;
    }
    point C;
    delete[]ptr;  //调用析构函数释放内存，3次，因为ptr数组有三个元素
    cout<<point::number<<endl;  //3
}

多态案例-----电脑组装

案例描述：

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
//抽象不同零件类
//抽象CPU类
class CPU
{
public:
    //抽象的计算函数
    virtual void calculate()=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->calculate;
        
        m_vc->display;
        
        m_mem->storage;
    }
    //提供一个析构函数来释放电脑零件
    ~Computer()
    {
        //释放CPU零件
        if(m_cpu!=NULL)
        {
            delete m_cpu;
            m_cpu=NULL;
        }
        //释放显卡零件
        if(m_vc!=NULL)
        {
            delete m_vc;
            m_vc=NULL;
        }
        //释放内存条零件
        if(m_mem!=NULL)
        {
            delete m_mem;
            m_mem=NULL;
        }
    }
    
private:
    CPU *m_cpu;//cpu零件指针
    VideoCard *m_vc;
    Memory *m_mem;
};

//实现具体厂商封装
//Inter厂商
class InterCPU:public CPU
{
public:    
    virtual void calculate()
    {
        cout<<"Inter的CPU开始计算了"<<endl;
    }
};

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

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

//Lenovo厂商
class LenovoCPU:public CPU
{
public:    
    virtual void calculate()
    {
        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 text01()
{
    //第一台电脑零件
    CPU *interCpu=new InterCPU;//父类指针指向子类对象
    VideoCard *interCard=new InterVideoCard;
    Memory *interMem=new InterMemory;
    
    cout<<"第一台电脑开始工作"<<endl;
    //创建第一台电脑
    Computer *computer1=new Computer(interCpu,interCard,interMem);
    computer1->work();
    delete computer1;
    
    cout<<"第二台电脑开始工作"<<endl;
    //创建第二台电脑
    Computer *computer2=new Computer(new LenovoCPU,new LenovoVideoCard,new Lenovomemory);
    computer2->work(); 
    delete computer2;
    
    cout<<"第三台电脑开始工作"<<endl;
    //创建第二台电脑
    Computer *computer3=new Computer(new LenovoCPU,new InterVideoCard,new Lenovomemory);
    computer3->work();
    delete computer3;
}

int main()
{
    text01();
}
屏幕截图_20230421_163057

定义一个描述矩形的类Rectangle，包括的数据成员有宽（width）和长（length）：计算矩形周长；计算矩形面积；改变矩形大小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <iostream>
using namespace std;
class Rectangle
    {
      public:
         Rectangle(int a,int b)
         {  width=a; length=b; }
         int Area()
         {  return width*length;  }
         int Periment()
		 {  return 2*(width+length);  }
         void Changesize(int a,int b)
		 {  width=a;  length=b;  }
         void Print();
       private:
         int width,length;
    };
    void Rectangle::Print()
    {
        cout<<"AREA="<<Area()<<endl;
		cout<<"PERIMENT="<<Periment()<<endl;
    }

 int main()
    {
        Rectangle r(5,8);
        r.Print();
		r.Changesize(3,9);
		r.Print();
		return 0 ;
}

判断10~30内的质数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include<cmath>
#include<iomanip>
#include<iostream>
using namespace std;
//该循环体被用来判断10~30中的质数有哪些  11 13 17 19 23 29
bool fun(long n);
int main()
{
	long a = 10, b = 30, l = 0;
	if (a % 2 == 0)
		a++;
	for (long m = a; m <= b;)
		if(fun(m))
	{
			if (l++ % 10 == 0)
				cout << endl;
			cout << setw(5) << m;
	}
	return 0;
}
bool fun(long n)
{
	int sqrtm = (int)sqrt(n);
	for (int i = 2; i <= sqrtm; i++)
		if (n % i == 0)
			return false;
	return true;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//编写程序输入1到100内所有的素数
#include<iostream>
#include<math.h>
using namespace std;
int main()
{
    int i=1,j=1,k.flag=1;
    k=sqrt(i);
    for(int i=1;i<=100;i++)
    {
        for(in j=1;j<=k;j++)
        {
            if(i%j==0)
            {
                flag=0;
                break;      //一定要加break跳出内循环，要么在这个if后面加上else {flag=1;}
            }
            if(flag)
            {
                cout<<i<<"为素数"<<endl;
            }
        }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//编写一个判断素数的函数，并输出100-300之间的全部素数之和
#include <iostream.h>
bool prime(int n); 
void main()
{   int sum=0;
    for(int i=100;i<300;i++)
     if(prime(i)) sum+=i;
    cout<<"Sum="<<sum<<endl;
}

bool prime(int n)
{
for(int i=2;i<n;i++)
    {
       if (n%i == 0)
        {
        return false;
         }
     }
         return TRUE;
}

输出所有的“水仙花数”，所谓“水仙花数”是指一个3位数，其各位数字的立方和等于该数字本身。例如：153是一个“水仙花数”，因为：153=13+53+33

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream.h>
void main()
{
int i,j,k,n;
for(n=100;n<1000;n++)
 {
  i=n/100;  //这里的i为百位数
  j=(n-i*100)/10;  //这里的j为十位数  或者可以写成n%100/10
  k=n%10;    //这里的k为个位数
  if(n==i*i*i+j*j*j+k*k*k) cout<<n<<endl;
 }
}

编写一个计算n!的函数，并在主程序中调用该函数，计算1-10的阶乘之和（即S=1！+2！+3！+…+10!）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
using namespace std;
long fac(int n)
{
	long f;
	if (n<0) cout<<"n<0,data error!"<<endl;
	else if (n==0) f=1;
	else f=fac(n-1)*n;  //用嵌套的方法求出每个数字的阶乘
	return(f);
}

void main()
{int s=0;
for(int i=1;i<=10;i++)
s+=fac(i);   //把每个数字的阶乘相加
cout<<”s=”<<s<<endl;
}

从键盘输入10个正整数，输出它们中的最大值、最小值和平均值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
using namespace std;
void main()
{
int x,max,min,s=0;
cout<<"please input 10 number:";
cin>>x;
max=min=x;   //这里把最大值或者最小值都看成第一个数字
for(int n=1;n<10;n++)
{   cin>>x;
    if (x>max) max=x;
	if (x<min) min=x;
	s+=x;
}
s=s/10;
cout<<"max="<<max<<endl;
cout<<"min="<<min<<endl;
cout<<"s="<<s<<endl;
}

设计一个立方体类Box，它能计算并输出立方体的体积和表面积

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/*
   Box类包含三个私有数据成员a(立方体边长)、volume(体积)和area(表面积)，另有两个构造函数以及seta()(设置立方体边长)、getvolume()(计算体积)、getarea()(计算表面积)和disp()(输出结果)。
本题程序如下：
*/
#include<iostream.h>
class Box
{
    float a;
    float volume;
    float area;
    public:
        Box(){}
        Box(float r){a=r;}
        void seta(float r){a=r;}
        void getvolume(){volume=a*a*a;}
        void getarea(){area=6*a*a;}
        void disp()
        {
            cout<<"体积："<<volume<<",表面积："<<area<<endl;
        }
};

void main()
{
    Box obj1(4.5),obj2;
    obj2.seta(6.4);
    obj1.getvolume();
    obj1.getarea();
    cout<<"obj1=>";
    obj1.disp();
    obj2.getvolume();
    obj2.getarea();
    cout<<"obj2=>";
    obj2.disp();
}

编写一个程序，设计一个点类Point，求两个点之间的距离

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include<iostream>
#include<math.h>
#using namespace std;
class point
{
private:
    int x,y;
public:
    Point(int i,int j){x=i;y=j;}
    int getx(int x)
    {
        return x;
    }
    int gety(int y)
    {
        return y;
    }
    float distance(Point &x,Point &y)  //对象引用作为参数
    {
        float d;
        d=sqrt((p1.getx()-p2.getx())*(p1.getx()-p2.getx())+(p1.gety()-p2.gety())*(p1.gety()-p2.gety()));
        return d;
    }
};
void main()
{
    Point p1(2,2),p2(5,5);
    p1.disp(); cout<<"与"; p2.disp();
    cout<<"之间距离="<<distance(p1,p2)<<endl;
}

编写一个简单程序，要求：

1用循环实现从键盘上输入20个整数并放入数组

2.求出数组元素的最大值及数组的平均值并输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include<iostream.h>
int sum(int p[]);								//声明求和函数
int max(int p[]);								//声明求极大值函数
void main()
{
   int a[20],i=0;									//声明数组
   while(i<20)						//通过循环从键盘给数组元素赋值
	   {  cout<<"a["<<i<<"]=";
          cin>>a[i];
          i++;
		}
   cout<<"sum ： "<<sum(a)<<endl;			//调用求和函数并输出结果
   cout<<"max ： "<<max(a)<<endl;       //求极大值函数并输出结果
}

/*求和函数的实现，形参用数组 */
int sum(int p[])
{
   int s=0;
   for(int i=0;i<20;i++)	
	   s+=p[i];
   return s;
}

/*求极大值函数的实现，形参用数组 */
int max(int p[])
{
   int maxv=p[0];
   for(int i=0;i<20;i++)	
	   if(p[i]>maxv)
           maxv=p[i];
   return maxv;
}

编写两个函数，分别求两个数的最大公约数和最小公倍数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;
int GCD (int u, int v)  //求最小公倍数
{
 while (u % v) {
  int t= u % v;
  u = v;
  v = t;
 }
 return v;
}
int LCM (int u, int v)  //求最大公倍数
{
 int gcd = GCD (u, v);
 return u * v / gcd;
}
void main()
{ int x,y;
cin>>x>>y;
cout<<”最大公约数为：”<<GCD(x,y)<<endl;
cout<<”最小公倍数为：”<<LCM(x,y)<<endl;
}

编写一个函数，实现用“冒泡法”对输入的10个整数按由小到大顺序排列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <iostream>
#include <iomanip>
using namespace std;
void sort(int num[])
{
	int temp;
	for(int i=0;i<9;i++)
	{
		for(int j=0;j<9-i;j++)
		{
			if(num[j]>num[j+1])
			{
				temp=num[j];
				num[j]=num[j+1];
				num[j+1]=temp;
			}
		}
	}
	return;
}
int main()
{
	int num[10];
	cout<<"请输入10个整数：";
	for(int i=0;i<10;i++)
		cin>>num[i];
	cout<<"排序前：";
	for(int i=0;i<10;i++)
		cout<<setw(5)<<num[i];
	cout<<endl;
	sort(num);
	cout<<"排序后：";
	for(int i=0;i<10;i++)
		cout<<setw(5)<<num[i];
	cout<<endl;
	return 0;
}