【C/C++面向对象方法实践：园丁游戏】

cyycoish

开更老C的新作品：Practice With OO Method in C/C++: A Game Of Gardener（C/C++面向对象方法实践：园丁游戏）
作者：cyycoish。转载请注明作者出处，否则视为侵权。
这篇文章主要向大家介绍面向对象的实现方法。本文面向于那些对面向对象编程概念摸不着头脑的人们。接下来会使用C（注:C不是面向对象的语言），C++来加以说明。因为本人水平有限，如有错误之处欢迎指正批评共同进步。

第一篇：元始天尊

地球上生命的摇篮是大海，亿年前，蔚蓝的海水中出现的第一个生命的原型：细胞。
始祖鸟化石是人类已知最早的鸟类，虽然化石显示“始祖鸟”的牙齿还未完全退化，但是它已经拥有了羽毛。
面向对象的诞生同样充满了神话般的色彩，让我们通过C语言寻找面向对象诞生之初的影子。
下面来描述一下这个游戏：
A版本：
你现在是一个园丁，拥有一颗树苗。树苗生命值最大100。生命值为0则树苗死亡。
刚刚买回来，树苗生命值85，高度100cm。
以后每一天树苗因为生长生命值-15，而高度+10cm。
每天你可以执行4个操作其中的一个：
0.        退出游戏
1.        浇水
2.        修剪高度
3.        什么也不做
选择浇水，可以输入水量（以公升计算）。每浇水一升，树苗生命值+1 。如果生命值超过100，则进行倒扣（浇水过多植物寿命减少）。如果当天选择浇水，则树苗当天高度立即+6（树苗吸水增长）。
你的目标：使得树苗高度达到可以售卖的标准200cm。同时天数越短越好，树苗生命值越大越好。
注：超过200cm可以使用修剪功能减小树苗高度，但是剪切长度超过树苗高度，树苗即死亡。

以下是C语言描述：

1. //代码1-1
   
2. #include <stdio.h>
   
3. 
   
4. #define HEIGHT_STANDARD 200 //标准高度
   
5. 
   
6. void CutPlant(int* health, int* height, int iCuttOffHeightByCentiMeter) //剪切植物
   
7. {
   
8.         if (*height - iCuttOffHeightByCentiMeter >= 0) //若剪切后的高度大于0
   
9.                 *height -= iCuttOffHeightByCentiMeter; //剪切
   
10.         else
    
11.                 *health = 0; //被剪死了
    
12. }
    
13. 
    
14. void WaterPlant(int* health, int* height, int iWaterQuantityByLitery) //浇水
    
15. {
    
16.         int Orghealth = *health; //记录浇水前的生命值
    
17.         *health += iWaterQuantityByLitery; //生命值等于浇水水量
    
18.         *height += 6; //每次浇水高度+6
    
19.         if (*health > 100) //生命值大于100
    
20.                 *health = Orghealth + 100 - *health; //生命值倒扣
    
21.         if (*health < 0) //淹死了
    
22.                 *health = 0;
    
23.         printf("\thealth+ %d\n\tHeight+ 6\n", *health - Orghealth); //显示浇水后生命值以及高度的变化
    
24. }
    
25. 
    
26. int main(void)
    
27. {
    
28.         int iOption;
    
29.         int iWQ;
    
30.         int iCH;
    
31. 
    
32.         int Day = 0; //天数
    
33.         int Height = 100; //植物高度
    
34.         int Health = 85;  //植物生命值
    
35. 
    
36.         printf("Welcome!\nNow you have a sapling.\n");
    
37.         printf("Begin your career as a gardener, and enjoy the game.\n");
    
38. 
    
39.         while (Health > 0)
    
40.         {
    
41.                 Day++;
    
42.                 printf("Days %d\n", Day);
    
43.                 Health -= 15;
    
44.                 printf("\tHealth -15.\n");
    
45.                 if (Health > 20)
    
46.                 {
    
47.                         Height += 10;
    
48.                         printf("\tHeight +10.\n");
    
49.                 }
    
50.                 printf("Reports:\n\tHeight: %d/200\n\tHealth: %d/100\n", Height, Health);
    
51.                 if (Height == HEIGHT_STANDARD)
    
52.                         break;
    
53.                 if (Health <= 0)
    
54.                         break;
    
55.                 printf("[1]Water.[2]Cut.[0]Give it up.\n");
    
56.                 scanf("%d", &iOption);
    
57.                 switch (iOption)
    
58.                 {
    
59.                 case 1:
    
60.                         printf("\tInput water quantity:");
    
61.                         scanf("%d", &iWQ);
    
62.                         WaterPlant(&Health, &Height, iWQ);
    
63.                         break;
    
64.                 case 2:
    
65.                         printf("\tInput height to cut:");
    
66.                         scanf("%d", &iCH);
    
67.                         CutPlant(&Health, &Height, iCH);
    
68.                         break;
    
69.                 case 0:
    
70.                         goto Lbl_Exit;
    
71.                 default:
    
72.                         printf("You did nothing?\n");
    
73.                 }
    
74.         }
    
75. Lbl_Exit:
    
76.         if (Health <= 0)
    
77.                 printf("You bad gardener.The plant was die.\n");
    
78.         else if (Height == HEIGHT_STANDARD)
    
79.                 printf("%d Days,The plant was fit to sale for %d cm!\n", Day, HEIGHT_STANDARD);
    
80.         else
    
81.                 printf("Wont you keep going on it?\n");
    
82. 
    
83.         return 0;
    
84. }
    

复制代码

可以看见，为了满足面向过程程序设计的需要。以上代码将浇水和剪切两个动作从主过程中分离，抽象为两个函数。调用时以引用方式输入植物高度与生命值，分别判断修剪长度与浇水水量后，对高度及生命值做相应变化。
接下来对游戏规则进行修改：
B版本：
你现在是一个园丁，拥有两颗树苗。树苗生命值最大100。生命值为0则树苗死亡。
刚刚买回来，树苗生命值85，高度100cm。
以后每一天树苗因为生长生命值-15，而高度+10cm。
每天你可以对其中一棵树苗执行4个操作其中的一个：
0.        退出游戏
1.        浇水
2.        修剪高度
3.        什么也不做
选择浇水，可以输入水量（以公升计算）。每浇水一升，树苗生命值+1 。如果生命值超过100，则进行倒扣（浇水过多植物寿命减少）。如果当天选择浇水，则树苗当天高度立即+6（树苗吸水增长）。
你的目标：使得全部两颗树苗高度达到可以售卖的标准200cm。同时天数越短越好，树苗生命值越大越好。
注：超过200cm可以使用修剪功能减小树苗高度，但是剪切长度超过树苗高度，树苗即死亡。
其中一棵树苗高度达到200cm即可售卖。
分析：
先前针对A版本的游戏当中，树苗并未作为个体被抽象出来。因为只有一棵树苗，所以分别申请一个叫做Height的变量存放该树苗高度，Health变量存放生命值。现在树苗个数变为两个。我们是不是就应该这样子定义变量呢？int Height1;int Health1; int Height2;int Health2; 。那么如果是三颗树苗，4棵树苗，5棵树苗……。也许你可以这样子操作：int Height[N];int Health[N];。但是这样子不如将树苗作为“对象”抽象出来，定义一个结构体包含height与health属性来得方便些。于是我们有了结构体“Plant”其中有两个int类型变量：health和height。
此时，代码C语言描述如下：

1. //代码1-2
   
2. #include <stdio.h>
   
3. #define HEIGHT_STANDARD 200 //植物标准高度
   
4. 
   
5. struct Plant //结构体“植物”
   
6. {
   
7.         int height; //高度
   
8.         int health; //生命值
   
9. };
   
10. 
    
11. struct Plant MyPlant[2];
    
12. 
    
13. void InitAPlant(struct Plant* TargetPlant) //初始化函数
    
14. {
    
15.         TargetPlant->height = 100;
    
16.         TargetPlant->health = 85;
    
17. }
    
18. 
    
19. void CutPlant(int* health, int* height, int iCuttOffHeightByCentiMeter) //剪切植物
    
20. {
    
21.         if (*height - iCuttOffHeightByCentiMeter >= 0) //若剪切后的高度大于0
    
22.                 *height -= iCuttOffHeightByCentiMeter; //剪切
    
23.         else
    
24.                 *health = 0; //被剪死了
    
25. }
    
26. 
    
27. void WaterPlant(int* health, int* height, int iWaterQuantityByLitery) //浇水
    
28. {
    
29.         int Orghealth = *health; //记录浇水前的生命值
    
30.         *health += iWaterQuantityByLitery; //生命值等于浇水水量
    
31.         *height += 6; //每次浇水高度+6
    
32.         if (*health > 100) //生命值大于100
    
33.                 *health = Orghealth + 100 - *health; //生命值倒扣
    
34.         if (*health < 0) //淹死了
    
35.                 *health = 0;
    
36.         printf("\thealth+ %d\n\tHeight+ 6\n", *health - Orghealth); //显示浇水后生命值以及高度的变化
    
37. }
    
38. 
    
39. int main()
    
40. {
    
41.         int iOption; //操作选择
    
42.         int iWQ; //浇水水量
    
43.         int iCH; //修剪长度
    
44. 
    
45.         int Day = 0; //天数
    
46.         InitAPlant(&MyPlant[0]); //初始化植物
    
47.         InitAPlant(&MyPlant[1]); //初始化植物
    
48.         int PlantsCounter = 2; //待完成养殖的植物个数
    
49.         int CurrentPlantIndex; //当前被操作的植物索引
    
50. 
    
51.         printf("Welcome!\nNow you have two saplings.\n");
    
52.         printf("Begin your career as a gardener, and enjoy the game.\n");
    
53. 
    
54.         while (PlantsCounter) //如果待完成养殖的植物个数为0则表示养殖任务完毕
    
55.         {
    
56.                 Day++;
    
57.                 printf("Days %d\n", Day);
    
58.                 MyPlant[0].health -= 15;
    
59.                 MyPlant[1].health -= 15;
    
60.                 if (MyPlant[0].health > 20) //如果植物生命在20以上，那么正常生长。
    
61.                         MyPlant[0].height += 10;
    
62.                 if (MyPlant[1].health > 20)
    
63.                         MyPlant[1].height += 10;
    
64. 
    
65.                 printf("Reports for plant 1:\n\tHeight: %d/200\n\tHealth: %d/100\n", MyPlant[0].height, MyPlant[0].health);
    
66.                 printf("Reports for plant 2:\n\tHeight: %d/200\n\tHealth: %d/100\n", MyPlant[1].height, MyPlant[1].health);
    
67.                 if (MyPlant[0].health <= 0) //植物死了一颗，游戏失败
    
68.                         goto Lbl_Game_Over;
    
69.                 if (MyPlant[1].health <= 0)
    
70.                         goto Lbl_Game_Over;
    
71.                 if (MyPlant[0].height == HEIGHT_STANDARD) //养成一颗
    
72.                         PlantsCounter--; //待完成养殖的植物个数-1
    
73.                 if (MyPlant[1].height == HEIGHT_STANDARD)
    
74.                         PlantsCounter--;
    
75. 
    
76.                 printf("Choose a plant to operate.[1] for 1st plant.[2] for 2nd plant.[AnyInputing] to pass any operating.\n");
    
77.                 scanf("%d", &iOption); //选择一颗植物进行操作
    
78.                 if (iOption != 1 && iOption != 2 || MyPlant[iOption - 1].height == HEIGHT_STANDARD) //没有选择任何一颗未完成之植物。因为C语言编译器对逻辑表达式的“短路计算”，MyPlant[iOption - 1]并不会越界。
    
79.                         goto Lbl_Pass_Anyway;
    
80.                 CurrentPlantIndex = iOption - 1; //修改索引
    
81.                 printf("[1]Water.[2]Cut.[0]Give it up.\n");
    
82.                 scanf("%d", &iOption);
    
83.                 switch (iOption)
    
84.                 {
    
85.                 case 1:
    
86.                         printf("\tInput water quantity:");
    
87.                         scanf("%d", &iWQ);
    
88.                         WaterPlant(&MyPlant[CurrentPlantIndex].health, &MyPlant[CurrentPlantIndex].height, iWQ);
    
89.                         break;
    
90.                 case 2:
    
91.                         printf("\tInput height to cut:");
    
92.                         scanf("%d", &iCH);
    
93.                         CutPlant(&MyPlant[CurrentPlantIndex].health, &MyPlant[CurrentPlantIndex].height, iCH);
    
94.                         break;
    
95.                 case 3:
    
96.                         goto Lbl_Exit;
    
97.                 Lbl_Pass_Anyway:
    
98.                 default:
    
99.                         printf("You did nothing?\n");
    
100.                 }
     
101.         }
     
102. Lbl_Exit:
     
103.         if (MyPlant[0].health <= 0 || MyPlant[1].health <= 0)
     
104.                 printf("You bad gardener.The plant was die.\n");
     
105.         else if (MyPlant[0].height == HEIGHT_STANDARD && MyPlant[1].height == HEIGHT_STANDARD)
     
106.                 printf("%d Days,All plants were fit to sale for %d cm!\n", Day, HEIGHT_STANDARD);
     
107.         else
     
108.                 printf("Wont you keep going on it?\n");
     
109.         return 0;
     
110. Lbl_Game_Over:
     
111.         printf("One of your plants was die.");
     
112.         return 0;
     
113. }
     

复制代码

为了进一步说明声明结构体的重要性，我们来改进代码，使之支持达到“100”个植物！当然，随着植物数量增加，游戏难度随之增长。（那么因为时间关系，老C不在此代码上做可行性测试，以及详细的排bug处理，仅作为理论演示。）
改进后的C语言代码：

1. //代码1-3
   
2. #include <stdio.h>
   
3. #define HEIGHT_STANDARD 200 //植物标准高度
   
4. #define PLANTS 100 //100个植物
   
5. 
   
6. struct Plant //结构体“植物”
   
7. {
   
8.         int height; //高度
   
9.         int health; //生命值
   
10. };
    
11. 
    
12. struct Plant MyPlant[PLANTS];
    
13. 
    
14. void InitAPlant(struct Plant* TargetPlant) //初始化函数
    
15. {
    
16.         TargetPlant->height = 100;
    
17.         TargetPlant->health = 85;
    
18. }
    
19. 
    
20. void CutPlant(int* health, int* height, int iCuttOffHeightByCentiMeter) //剪切植物
    
21. {
    
22.         if (*height - iCuttOffHeightByCentiMeter >= 0) //若剪切后的高度大于0
    
23.                 *height -= iCuttOffHeightByCentiMeter; //剪切
    
24.         else
    
25.                 *health = 0; //被剪死了
    
26. }
    
27. 
    
28. void WaterPlant(int* health, int* height, int iWaterQuantityByLitery) //浇水
    
29. {
    
30.         int Orghealth = *health; //记录浇水前的生命值
    
31.         *health += iWaterQuantityByLitery; //生命值等于浇水水量
    
32.         *height += 6; //每次浇水高度+6
    
33.         if (*health > 100) //生命值大于100
    
34.                 *health = Orghealth + 100 - *health; //生命值倒扣
    
35.         if (*health < 0) //淹死了
    
36.                 *health = 0;
    
37.         printf("\thealth+ %d\n\tHeight+ 6\n", *health - Orghealth); //显示浇水后生命值以及高度的变化
    
38. }
    
39. 
    
40. int main()
    
41. {
    
42.         int i;
    
43.         int iOption; //操作选择
    
44.         int iWQ; //浇水水量
    
45.         int iCH; //修剪长度
    
46. 
    
47.         int Day = 0; //天数
    
48.         for (i = 0; i < PLANTS; i++, InitAPlant(&MyPlant[i])); //初始化植物
    
49.         int PlantsCounter = PLANTS; //待完成养殖的植物个数
    
50.         int CurrentPlantIndex; //当前被操作的植物索引
    
51.         int finishedIndex[PLANTS] = { 0 }; //记录完成索引
    
52. 
    
53.         printf("Welcome!\nNow you have &d saplings.\n", PLANTS);
    
54.         printf("Begin your career as a gardener, and enjoy the game.\n");
    
55. 
    
56.         while (PlantsCounter) //如果待完成养殖的植物个数为0则表示养殖任务完毕
    
57.         {
    
58.                 Day++;
    
59.                 printf("Days %d\n", Day);
    
60.                 for (i = 0; i < PLANTS; i++)
    
61.                 {
    
62.                         MyPlant[i].health -= 15; //每天因为
    
63.                         if (MyPlant[i].health > 20) //如果植物生命在20以上，那么正常生长。
    
64.                                 MyPlant[i].height += 10;
    
65.                         if (MyPlant[i].health <= 0) //植物死了一颗，游戏失败
    
66.                                 goto Lbl_Game_Over;
    
67.                         if (MyPlant[i].height == HEIGHT_STANDARD) //养成一颗
    
68.                         {
    
69.                                 PlantsCounter--; //待完成养殖的植物个数-1
    
70.                                 finishedIndex[i] = 1;
    
71.                         }
    
72.                 }
    
73.                 printf("Choose a plant to operate.Input a number range from 1 to %d\n", PLANTS);
    
74.                 printf("Here are unfinished plants which you can choose.:\n");
    
75.                 for (i = 0; i < PLANTS; i++, (!finishedIndex[i]) ? printf("%d ", i) : 1); //打印未完成养殖的植物
    
76.                 printf("\nIf your choice out of the above-mentioned, Current operating will be passed.PLEASE TREAT IT SERIOUSLY.\n");
    
77.                 scanf("%d", &iOption); //选择一颗植物进行操作
    
78.                 for (i = 0; i < PLANTS; i++, CurrentPlantIndex = (!finishedIndex[i]) && iOption - 1 == i ? i : -1); //选择一颗符合上述条件的植物
    
79.                 if (CurrentPlantIndex == -1)
    
80.                         goto Lbl_Pass_Anyway;
    
81.                 printf("[1]Water.[2]Cut.[0]Give it up.\n");
    
82.                 scanf("%d", &iOption);
    
83.                 switch (iOption)
    
84.                 {
    
85.                 case 1:
    
86.                         printf("\tInput water quantity:");
    
87.                         scanf("%d", &iWQ);
    
88.                         WaterPlant(&MyPlant[CurrentPlantIndex].health, &MyPlant[CurrentPlantIndex].height, iWQ);
    
89.                         break;
    
90.                 case 2:
    
91.                         printf("\tInput height to cut:");
    
92.                         scanf("%d", &iCH);
    
93.                         CutPlant(&MyPlant[CurrentPlantIndex].health, &MyPlant[CurrentPlantIndex].height, iCH);
    
94.                         break;
    
95.                 case 3:
    
96.                         goto Lbl_Exit;
    
97.                 Lbl_Pass_Anyway:
    
98.                 default:
    
99.                         printf("You did nothing?\n");
    
100.                 }
     
101.         }
     
102.         printf("%d Days,All plants were fit to sale for %d cm!\n", Day, HEIGHT_STANDARD);
     
103.         return 0;
     
104. Lbl_Exit:
     
105.         printf("Wont you keep going on it?\n");
     
106.         return 0;
     
107. Lbl_Game_Over:
     
108.         printf("One of your plants was die.");
     
109.         return 0;
     
110. }
     

复制代码

这时候大家有没有觉得瞬间，大量的物体被以一种更“集成化”的方式，简约地处理掉了。
至此我们已经知道类的雏形，是的，他就是：结构体（structure）

cyycoish

第二篇：海纳百川，包罗万象

有古训：有容乃大。一个集大成者的计算机语言必然可以使得使用它的人来描述任何东西。
不可否认，OOP（即面向对象编程）是计算机语言的革命。打赢这一场翻身仗OOP需要经过包罗万象的考验。
我们继续以“园丁游戏A版本”为蓝本修改游戏规则：
C版本：
你现在是一个园丁，拥有两颗树苗。一颗苹果树，一颗橘子树。树苗生命值最大100。生命值为0则树苗死亡。
刚刚买回来，树苗生命值85，高度100cm，都没有结果子。
以后每一天树苗因为生长生命值-15，而高度+10cm。
苹果树在生命值大于等于30的情况下，每天结一颗果子。
橘子树在生命值大于等于60的情况下，每天结一颗果子。
两颗果树每一颗果子每一天消耗生命值2
每天你可以执行4个操作其中的一个：
0.        退出游戏
1.        浇水
2.        修剪高度
3.        摘果子
4.        什么也不做
选择浇水，可以输入水量（以公升计算）。每浇水一升，树苗生命值+1 。如果生命值超过100，则进行倒扣（浇水过多植物寿命减少）。如果当天选择浇水，则树苗当天高度立即+6（树苗吸水增长）。
选择摘果子，可以输入摘果数量，该数量不能大于结果数。
你的目标：使得树苗高度达到可以售卖的标准200cm。同时天数越短越好。达到200cm后的果树：苹果与橘子单个售价均为$1, 卖果子所得的钱将作为你的额外收入。收入越多越好。
注：超过200cm可以使用修剪功能减小树苗高度，但是剪切长度超过树苗高度，树苗即死亡。
这是第一个版本并不完善的C代码：

1. //代码2-1
   
2. #include <stdio.h>
   
3. #define HEIGHT_STANDARD 200 //植物标准高度
   
4. 
   
5. struct Plant //结构体“植物”
   
6. {
   
7.         int height; //高度
   
8.         int health; //生命值
   
9.         int apple;  //苹果个数
   
10.         int orange; //橘子个数
    
11. };
    
12. 
    
13. struct Plant AppleTree;  //苹果树
    
14. struct Plant OrangeTree; //橘子树
    
15. 
    
16. void InitAPlant(struct Plant* TargetPlant) //初始化函数
    
17. {
    
18.         TargetPlant->height = 100;
    
19.         TargetPlant->health = 85;
    
20.         TargetPlant->apple = 0;
    
21.         TargetPlant->orange = 0;
    
22. }
    
23. 
    
24. void CutPlant(int* health, int* height, int iCuttOffHeightByCentiMeter) //剪切植物
    
25. {
    
26.         if (*height - iCuttOffHeightByCentiMeter >= 0) //若剪切后的高度大于0
    
27.                 *height -= iCuttOffHeightByCentiMeter; //剪切
    
28.         else
    
29.                 *health = 0; //被剪死了
    
30. }
    
31. 
    
32. void WaterPlant(int* health, int* height, int iWaterQuantityByLitery) //浇水
    
33. {
    
34.         int Orghealth = *health; //记录浇水前的生命值
    
35.         *health += iWaterQuantityByLitery; //生命值等于浇水水量
    
36.         *height += 6; //每次浇水高度+6
    
37.         if (*health > 100) //生命值大于100
    
38.                 *health = Orghealth + 100 - *health; //生命值倒扣
    
39.         if (*health < 0) //淹死了
    
40.                 *health = 0;
    
41.         printf("\thealth+ %d\n\tHeight+ 6\n", *health - Orghealth); //显示浇水后生命值以及高度的变化
    
42. }
    
43. 
    
44. void PickFruit(struct Plant* fruitTree, int howManyFruits)
    
45. {
    
46.         int Apple = fruitTree->apple;   //苹果数
    
47.         int Orange = fruitTree->orange; //橘子数
    
48.         //摘果
    
49.         if (Apple > 0 && Apple - howManyFruits >= 0)
    
50.                 fruitTree->apple -= howManyFruits;
    
51.         if (Orange > 0 && Orange - howManyFruits >= 0)
    
52.                 fruitTree->orange -= howManyFruits;
    
53. }
    
54. 
    
55. int main()
    
56. {
    
57.         int i;
    
58.         int iOption; //操作选择
    
59.         int iWQ; //浇水水量
    
60.         int iCH; //修剪长度
    
61.         int iFT; //摘果个数
    
62. 
    
63.         int Day = 0; //天数
    
64. 
    
65.         InitAPlant(&AppleTree);
    
66.         InitAPlant(&OrangeTree);
    
67. 
    
68.         struct Plant* TargetPlant;
    
69. 
    
70.         printf("Welcome!\nNow you have double saplings.\n");
    
71.         printf("Begin your career as a gardener, and enjoy the game.\n");
    
72. 
    
73.         while (1)
    
74.         {
    
75.                 Day++;
    
76.                 printf("Days %d\n", Day);
    
77.                 AppleTree.health -= 15 + AppleTree.apple * 2;
    
78.                 OrangeTree.health -= 15 + OrangeTree.orange * 2;
    
79.                 printf("\tHealth -15.\n");
    
80.                 if (AppleTree.health > 20)
    
81.                         AppleTree.height += 10;
    
82.                 if (OrangeTree.health > 20)
    
83.                         OrangeTree.height += 10;
    
84.                 if (AppleTree.health >= 30)
    
85.                         AppleTree.apple++;
    
86.                 if (OrangeTree.health >= 60)
    
87.                         OrangeTree.orange++;
    
88.                 printf("Reports for apple tree:\n\tHeight: %d/200\n\tHealth: %d/100\n\tFruits: %d\n", AppleTree.height, AppleTree.health, AppleTree.apple);
    
89.                 printf("Reports for orange tree:\n\tHeight: %d/200\n\tHealth: %d/100\n\tFruits: %d\n", OrangeTree.height, OrangeTree.health, OrangeTree.orange);
    
90. 
    
91.                 if (AppleTree.health <= 0 || OrangeTree.health <= 0)
    
92.                         goto Lbl_Game_Over;
    
93. 
    
94.                 printf("Choose a plant to operate.[0] for apple tree,[Any inputing] for orange tree.\n");
    
95.                 scanf("%d", &iOption);
    
96.                 if (!iOption && AppleTree.height != HEIGHT_STANDARD)
    
97.                         TargetPlant = &AppleTree;
    
98.                 else
    
99.                         TargetPlant = &OrangeTree;
    
100. 
     
101.                 printf("[1]Water.[2]Cut.[3]Pick Fruits.[0]Give it up.\n");
     
102.                 scanf("%d", &iOption);
     
103.                 switch (iOption)
     
104.                 {
     
105.                 case 1:
     
106.                         printf("\tInput water quantity:");
     
107.                         scanf("%d", &iWQ);
     
108.                         WaterPlant(&TargetPlant->health, &TargetPlant->height, iWQ);
     
109.                         break;
     
110.                 case 2:
     
111.                         printf("\tInput height to cut:");
     
112.                         scanf("%d", &iCH);
     
113.                         CutPlant(&TargetPlant->health, &TargetPlant->height, iCH);
     
114.                         break;
     
115.                 case 3:
     
116.                         printf("\tInput quantity to pick up:");
     
117.                         scanf("%d", &iFT);
     
118.                         PickFruit(TargetPlant, iFT);
     
119.                         break;
     
120.                 case 0:
     
121.                         goto Lbl_Exit;
     
122.                 Lbl_Pass_Anyway:
     
123.                 default:
     
124.                         printf("You did nothing?\n");
     
125.                 }
     
126.         }
     
127.         printf("%d Days,All plants were fit to sale! Any you got $%d for pocket money!\n", Day, AppleTree.apple + OrangeTree.orange);
     
128.         return 0;
     
129. Lbl_Exit:
     
130.         printf("Wont you keep going on it?\n");
     
131.         return 0;
     
132. Lbl_Game_Over:
     
133.         printf("One of your plants was die.");
     
134.         return 0;
     
135. }
     

复制代码

现在，我们要对以上代码进行重构，以便达到更好的封装，使代码能被充分“物尽其用”。将植物本身的特性尽可能地赋予植物内部。我们所做的第二步是要简化“上帝”的工作。尽量缩减主函数。

1. //代码2-2
   
2. #include <stdio.h>
   
3. #define HEIGHT_STANDARD 200 //植物标准高度
   
4. #define THIS TargetPlant
   
5. 
   
6. struct Plant //结构体“植物”
   
7. {
   
8.         int height; //高度
   
9.         int health; //生命值
   
10.         int apple;  //苹果个数
    
11.         int orange; //橘子个数
    
12.         void(*Cut)(struct Plant* TargetPlant, int iCuttOffHeightByMillimeter); //修剪植物
    
13.         void(*Water)(struct Plant* TargetPlant, int iWaterQuantityByLitery);   //浇水
    
14.         void(*PickFruits)(struct Plant* TargetPlant, int howManyFruits);       //摘果子
    
15. };
    
16. 
    
17. struct Plant AppleTree;  //苹果树
    
18. struct Plant OrangeTree; //橘子树
    
19. 
    
20. void CutPlant(struct Plant* TargetPlant, int iCuttOffHeightByCentiMeter) //剪切植物
    
21. {
    
22.         if (TargetPlant->height - iCuttOffHeightByCentiMeter >= 0) //若剪切后的高度大于0
    
23.                 TargetPlant->height -= iCuttOffHeightByCentiMeter; //剪切
    
24.         else
    
25.                 TargetPlant->health = 0; //被剪死了
    
26. }
    
27. 
    
28. void WaterPlant(struct Plant* TargetPlant, int iWaterQuantityByLitery) //浇水
    
29. {
    
30.         int Orghealth = TargetPlant->health; //记录浇水前的生命值
    
31.         TargetPlant->health += iWaterQuantityByLitery; //生命值等于浇水水量
    
32.         TargetPlant->health += 6; //每次浇水高度+6
    
33.         if (TargetPlant->health > 100) //生命值大于100
    
34.                 TargetPlant->health = Orghealth + 100 - TargetPlant->health; //生命值倒扣
    
35.         if (TargetPlant->health < 0) //淹死了
    
36.                 TargetPlant->health = 0;
    
37.         printf("\thealth+ %d\n\tHeight+ 6\n", TargetPlant->health - Orghealth); //显示浇水后生命值以及高度的变化
    
38. }
    
39. 
    
40. void PickFruit(struct Plant* fruitTree, int howManyFruits)
    
41. {
    
42.         int Apple = fruitTree->apple;   //苹果数
    
43.         int Orange = fruitTree->orange; //橘子数
    
44.         //摘果
    
45.         if (Apple > 0 && Apple - howManyFruits >= 0)
    
46.                 fruitTree->apple -= howManyFruits;
    
47.         if (Orange > 0 && Orange - howManyFruits >= 0)
    
48.                 fruitTree->orange -= howManyFruits;
    
49. }
    
50. 
    
51. void HangARealDay(void)
    
52. {
    
53.         AppleTree.health -= 15 + AppleTree.apple * 2;
    
54.         OrangeTree.health -= 15 + OrangeTree.orange * 2;
    
55.         printf("\tHealth -15.\n");
    
56.         if (AppleTree.health > 20)
    
57.                 AppleTree.height += 10;
    
58.         if (OrangeTree.health > 20)
    
59.                 OrangeTree.height += 10;
    
60.         if (AppleTree.health >= 30)
    
61.                 AppleTree.apple++;
    
62.         if (OrangeTree.health >= 60)
    
63.                 OrangeTree.orange++;
    
64.         printf("Reports for apple tree:\n\tHeight: %d/200\n\tHealth: %d/100\n\tFruits: %d\n", AppleTree.height, AppleTree.health, AppleTree.apple);
    
65.         printf("Reports for orange tree:\n\tHeight: %d/200\n\tHealth: %d/100\n\tFruits: %d\n", OrangeTree.height, OrangeTree.health, OrangeTree.orange);
    
66. }
    
67. 
    
68. void InitAPlant(struct Plant* TargetPlant) //初始化函数
    
69. {
    
70.         TargetPlant->height = 100;
    
71.         TargetPlant->health = 85;
    
72.         TargetPlant->apple = 0;
    
73.         TargetPlant->orange = 0;
    
74.         TargetPlant->Cut = CutPlant;
    
75.         TargetPlant->Water = WaterPlant;
    
76.         TargetPlant->PickFruits = PickFruit;
    
77. }
    
78. 
    
79. int main()
    
80. {
    
81.         int iOption; //操作选择
    
82.         int subOption;
    
83. 
    
84.         int Day = 0; //天数
    
85. 
    
86.         InitAPlant(&AppleTree);
    
87.         InitAPlant(&OrangeTree);
    
88. 
    
89.         struct Plant* TargetPlant;
    
90. 
    
91.         printf("Welcome!\nNow you have double saplings.\n");
    
92.         printf("Begin your career as a gardener, and enjoy the game.\n");
    
93. 
    
94.         while (1)
    
95.         {
    
96.                 Day++;
    
97.                 printf("Days %d\n", Day);
    
98.                 HangARealDay(); //Hang A Real Day is HARD.
    
99. 
    
100.                 if (AppleTree.health <= 0 || OrangeTree.health <= 0)
     
101.                         goto Lbl_Game_Over;
     
102. 
     
103.                 printf("Choose a plant to operate.[0] for apple tree,[1] for orange tree.\n");
     
104.                 scanf("%d", &iOption);
     
105.                 if (!iOption && AppleTree.height != HEIGHT_STANDARD)
     
106.                         TargetPlant = &AppleTree;
     
107.                 else if (iOption == 1 && OrangeTree.height != HEIGHT_STANDARD)
     
108.                         TargetPlant = &OrangeTree;
     
109.                 else
     
110.                         goto Lbl_Pass_Anyway;
     
111. 
     
112.                 printf("[1]Water.[2]Cut.[3]Pick Fruits.[0]Give it up.\n");
     
113.                 scanf("%d", &iOption);
     
114.                 switch (iOption)
     
115.                 {
     
116.                 case 1:
     
117.                         printf("\tInput water quantity:");
     
118.                         scanf("%d", &subOption);
     
119.                         TargetPlant->Water(THIS, subOption); //THIS就代表TargetPlant
     
120.                         break;
     
121.                 case 2:
     
122.                         printf("\tInput height to cut:");
     
123.                         scanf("%d", &subOption);
     
124.                         TargetPlant->Cut(THIS, subOption); //THIS就代表TargetPlant
     
125.                         break;
     
126.                 case 3:
     
127.                         printf("\tInput quantity to pick up:");
     
128.                         scanf("%d", &subOption);
     
129.                         TargetPlant->PickFruits(THIS, subOption); //THIS就代表TargetPlant
     
130.                         break;
     
131.                 case 0:
     
132.                         goto Lbl_Exit;
     
133.                 Lbl_Pass_Anyway:
     
134.                 default:
     
135.                         printf("You did nothing?\n");
     
136.                 }
     
137.         }
     
138.         printf("%d Days,All plants were fit to sale! Any you got $%d for pocket money!\n", Day, AppleTree.apple + OrangeTree.orange);
     
139.         return 0;
     
140. Lbl_Exit:
     
141.         printf("Wont you keep going on it?\n");
     
142.         return 0;
     
143. Lbl_Game_Over:
     
144.         printf("One of your plants was die.");
     
145.         return 0;
     
146. }
     

复制代码

消减后的主函数代码67行，比原先减少13行。当然，这是分离出HangARealDay函数带来的结果。但是在加入了THIS宏后，对植物进行的操作变成调用了植物结构体内的函数指针，使得代码可以被更好理解。当然，结构体内所有的成员（包括变量和指向函数的指针）都要在使用之前被InitAPlant函数初始化。
至此，我们发现，一个重大的转变就是将函数放在了结构体内，而不是HangARealDay函数缩减的仅有的13行代码。原先零散的函数瞬间被“收集”起来了。如果将结构体和其中函数指针指向的函数写入另外一个C文件，那么，只要提供函数调用说明，我们就可以随心所欲设置HangARealDay中的游戏规则。当然，修改植物本身的属性也变得极为方便——只要修改植物结构体中函数指针指向的函数内部内容即可。
结构体变得丰富起来了。不再是仅有的变量表示的事物属性，甚至是一个事物可以执行的动作，或者受外界刺激做出的反应。我们不仅仅可以用C语言计算一个“生物”局限的，微观的状态，我们可以造就模拟一整条“食物链”。

cyycoish

第三篇：革命日

夏末海边，天气闷热。
忽然间，铅色黑云，风高浪急。
岸边海鸟焦急地盘旋，一场暴风雨前不是宁静的。每一道闪电都点亮天空，随之而来的是雷声的呐喊：迎接秋日的到来吧！换季的时间到了，我们要革命！
解除软件开发人员的枷锁，C已无力胜任。革命家般的C++之父从头撤尾改造了C。
我们现在使用C++第一遍重写版本C的园丁游戏。
C++代码：

1. //代码3-1
   
2. #include <stdio.h>
   
3. const int HEIGHT_STANDARD = 200; //植物标准高度
   
4. 
   
5. class Plant//植物类
   
6. {
   
7. public: //公开类中所有成员
   
8.         int height = 100;
   
9.         int health = 85;
   
10.         int apple = 0;
    
11.         int orange = 0;
    
12.         void Cut(int iCuttOffHeightByCentiMeter);  //剪切植物
    
13.         void Water(int iWaterQuantityByLitery);    //浇水
    
14.         void PickFruit(int howManyFruits);         //摘果子
    
15. };
    
16. 
    
17. void Plant::Cut(int iCuttOffHeightByCentiMeter) //成员函数
    
18. {
    
19.         if (height - iCuttOffHeightByCentiMeter >= 0) //若剪切后的高度大于0
    
20.                 height -= iCuttOffHeightByCentiMeter; //剪切
    
21.         else
    
22.                 health = 0; //被剪死了
    
23. }
    
24. 
    
25. void Plant::Water(int iWaterQuantityByLitery) //成员函数
    
26. {
    
27.         int Orghealth = health; //记录浇水前的生命值
    
28.         health += iWaterQuantityByLitery; //生命值等于浇水水量
    
29.         health += 6; //每次浇水高度+6
    
30.         if (health > 100) //生命值大于100
    
31.                 health = Orghealth + 100 - health; //生命值倒扣
    
32.         if (health < 0) //淹死了
    
33.                 health = 0;
    
34.         printf("\thealth+ %d\n\tHeight+ 6\n", health - Orghealth); //显示浇水后生命值以及高度的变化
    
35. }
    
36. 
    
37. void Plant::PickFruit(int howManyFruits) //成员函数
    
38. {
    
39.         int Apple = apple;   //苹果数
    
40.         int Orange = orange; //橘子数
    
41.                                                  //摘果
    
42.         if (Apple > 0 && Apple - howManyFruits >= 0)
    
43.                 apple -= howManyFruits;
    
44.         if (Orange > 0 && Orange - howManyFruits >= 0)
    
45.                 orange -= howManyFruits;
    
46. }
    
47. 
    
48. void HangARealDay(Plant* AppleTree, Plant* OrangeTree) //全局函数
    
49. {
    
50.         AppleTree->health -= 15 + AppleTree->apple * 2;
    
51.         OrangeTree->health -= 15 + OrangeTree->orange * 2;
    
52.         printf("\tHealth -15\n");
    
53.         if (AppleTree->health > 20)
    
54.                 AppleTree->height += 10;
    
55.         if (OrangeTree->health > 20)
    
56.                 OrangeTree->height += 10;
    
57.         if (AppleTree->health >= 30)
    
58.                 AppleTree->apple++;
    
59.         if (OrangeTree->health >= 60)
    
60.                 OrangeTree->orange++;
    
61.         printf("Reports for apple tree:\n\tHeight: %d/200\n\tHealth: %d/100\n\tFruits: %d\n", AppleTree->height, AppleTree->health, AppleTree->apple);
    
62.         printf("Reports for orange tree:\n\tHeight: %d/200\n\tHealth: %d/100\n\tFruits: %d\n", OrangeTree->height, OrangeTree->health, OrangeTree->orange);
    
63. }
    
64. 
    
65. int main()
    
66. {
    
67.         int iOption; //操作选择
    
68.         int subOption;
    
69. 
    
70.         int Day = 0; //天数
    
71. 
    
72.         Plant* AppleTree = new Plant;  //以Plant为模板，建造一棵苹果树
    
73.         Plant* OrangeTree = new Plant; //以Plant为模板，建造一棵橘子树
    
74.         Plant* TargetPlant;
    
75. 
    
76.         printf("Welcome!\nNow you have double saplings.\n");
    
77.         printf("Begin your career as a gardener, and enjoy the game.\n");
    
78. 
    
79.         while (1)
    
80.         {
    
81.                 Day++;
    
82.                 printf("Days %d\n", Day);
    
83.                 HangARealDay(AppleTree, OrangeTree);
    
84. 
    
85.                 if (AppleTree->health <= 0 || OrangeTree->health <= 0)
    
86.                         goto Lbl_Game_Over;
    
87.                 printf("Choose a plant to operate.[0] for apple tree,[1] for orange tree.\n");
    
88.                 scanf("%d", &iOption);
    
89.                 if (!iOption && AppleTree->height != HEIGHT_STANDARD)
    
90.                         TargetPlant = AppleTree;
    
91.                 else if (iOption == 1 && OrangeTree->height != HEIGHT_STANDARD)
    
92.                         TargetPlant = OrangeTree;
    
93.                 else
    
94.                         goto Lbl_Pass_Anyway;
    
95. 
    
96.                 printf("[1]Water.[2]Cut.[3]Pick Fruits.[0]Give it up.\n");
    
97.                 scanf("%d", &iOption);
    
98.                 switch (iOption)
    
99.                 {
    
100.                 case 1:
     
101.                         printf("\tInput water quantity:");
     
102.                         scanf("%d", &subOption);
     
103.                         TargetPlant->Water(subOption); //省略THIS
     
104.                         break;
     
105.                 case 2:
     
106.                         printf("\tInput height to cut:");
     
107.                         scanf("%d", &subOption);
     
108.                         TargetPlant->Cut(subOption); //省略THIS
     
109.                         break;
     
110.                 case 3:
     
111.                         printf("\tInput quantity to pick up:");
     
112.                         scanf("%d", &subOption);
     
113.                         TargetPlant->PickFruit(subOption); //省略THIS
     
114.                         break;
     
115.                 case 0:
     
116.                         goto Lbl_Exit;
     
117.                 Lbl_Pass_Anyway:
     
118.                 default:
     
119.                         printf("You have done nothing?\n");
     
120.                 }
     
121.         }
     
122.         printf("%d Days,All plants were fit to sale! Any you got $%d for pocket money!\n", Day, AppleTree->apple + OrangeTree->orange);
     
123.         return 0;
     
124. Lbl_Exit:
     
125.         printf("Wont you keep going on it?\n");
     
126.         return 0;
     
127. Lbl_Game_Over:
     
128.         printf("One of your plants was die.");
     
129.         return 0;
     
130. }
     

复制代码

如果大家仔细阅读并且思考了本文上述全部C代码，不难看出：class Plant（植物类）其实是一个结构体，然而，这个结构体内的变量能被直接初始化。类中声明的函数，就是前面C结构体中的函数指针。具体的函数实现就是下面的成员函数。“::”符号是访问限定符，int Plant::XXX()表示int XXX函数属于类Plant。成员函数内部可以直接使用所在类内部的变量而无须使用“THIS”指针。
创建一个以这个类为数据类型的变量使用语句：ClassName* var = new ClassName;，或者ClassName var;。这个过程被称作为“类的实例化”。var就是该类实例化出来的一个对象。
接下来大家需要搞懂以下几个概念：内联成员函数、this指针、构造函数、析构函数。
内联成员函数：
在C的结构体中，函数指针要在结构体外部做实现，那么在C++中，可以在类中直接实现该函数。这个函数被称为“内联成员函数”请看：

1. //代码3-2
   
2. class Plant//植物类
   
3. {
   
4. public: //公开类中所有成员
   
5.         int height = 100;
   
6.         int health = 85;
   
7.         int apple = 0;
   
8.         int orange = 0;
   
9.         void Cut(int iCuttOffHeightByCentiMeter)       //剪切植物
   
10.         {
    
11.                 if (height - iCuttOffHeightByCentiMeter >= 0) //若剪切后的高度大于0
    
12.                         height -= iCuttOffHeightByCentiMeter; //剪切
    
13.                 else
    
14.                         health = 0; //被剪死了
    
15.         }
    
16.         inline void Water(int iWaterQuantityByLitery); //浇水
    
17.         void PickFruit(int howManyFruits);             //摘果子
    
18. };
    
19. 
    
20. void Plant::Water(int iWaterQuantityByLitery) //成员函数
    
21. {
    
22.         int Orghealth = health; //记录浇水前的生命值
    
23.         health += iWaterQuantityByLitery; //生命值等于浇水水量
    
24.         health += 6; //每次浇水高度+6
    
25.         if (health > 100) //生命值大于100
    
26.                 health = Orghealth + 100 - health; //生命值倒扣
    
27.         if (health < 0) //淹死了
    
28.                 health = 0;
    
29.         printf("\thealth+ %d\n\tHeight+ 6\n", health - Orghealth); //显示浇水后生命值以及高度的变化
    
30. }
    
31. 
    
32. void Plant::PickFruit(int howManyFruits) //成员函数
    
33. {
    
34.         int Apple = apple;   //苹果数
    
35.         int Orange = orange; //橘子数
    
36.                                                  //摘果
    
37.         if (Apple > 0 && Apple - howManyFruits >= 0)
    
38.                 apple -= howManyFruits;
    
39.         if (Orange > 0 && Orange - howManyFruits >= 0)
    
40.                 orange -= howManyFruits;
    
41. }
    

复制代码

那么在类Plant中，Cut函数为内联成员函数。而函数名称前加上inline关键字，函数实现在类以外，编译器也会自动视为“内联成员函数”。显然，函数PickFruit既没有加inline关键字在类中的声明之前，也没有在类中实现该函数。所以PickFruit不是“内联成员函数”。内联成员函数的出现是为了增加执行效率，其缺点是增加了类的体积。显然，将一些体积小的，执行次数多的函数内联是一个两全其美的好办法。
下面来说一说“this指针”：
还记得在C中我们如何定义Cut函数的吗？我找来了它的定义，在12页上面的代码：
void CutPlant(struct Plant* TargetPlant, int iCuttOffHeightByCentiMeter);
然后位于代码第三行处有一个THIS宏：#define THIS TargetPlant 。当我们使用Cut函数时是这样子调用的：TargetPlant->Cut(THIS, subOption); //THIS就代表TargetPlant 而在C++中我们调用Cut函数的时候：TargetPlant->Cut(subOption); //省略THIS 。
至此我们不难猜想得到，C++中，this指针用来访问“成员函数所在类中的成员变量”。这样说还不对！请看：

1. //代码3-3
   
2. #include <iostream>
   
3. using namespace std;
   
4. 
   
5. class MyClass
   
6. {
   
7. public:
   
8.         char word[100] = {"Hello nice to meet you!\n"};
   
9.         void SayHelloA()
   
10.         {
    
11.                 cout << "Hello glad to see you!" << endl;
    
12.         }
    
13.         void SayHelloB()
    
14.         {
    
15.                 cout << word;
    
16.         }
    
17. };
    
18. 
    
19. int main()
    
20. {
    
21.         MyClass* objHelloA = new MyClass;
    
22.         MyClass* objHelloB = NULL;
    
23.         objHelloA->SayHelloA();
    
24.         objHelloA->SayHelloB();
    
25. 
    
26.         objHelloB->SayHelloA(); //请将断点下于此处
    
27.         objHelloB->SayHelloB(); //运行出错
    
28. 
    
29.         return 0;
    
30. }
    

复制代码

在以上代码中objHelloA->SayHelloA();objHelloA->SayHelloB();能被正常执行并不会被觉得奇怪，但是大家有没有想过objHelloB->SayHelloA();为什么也能被执行？而objHelloB->SayHelloB();立即报错？解释是:类是一个结构体，其中的成员函数都是函数指针。objHelloB指向了一个空的内存地址，然而在申请“结构体”类时，内部所有函数指针已经被指向指定函数。所以，通过类的实例可以调用成员函数，却不能访问成员变量。

1. //代码3-4
   
2. #include <iostream>
   
3. using namespace std;
   
4. 
   
5. class MyClass
   
6. {
   
7. public:
   
8.         int counter = 0;
   
9.         void Increase();
   
10. };
    
11. 
    
12. void MyClass::Increase()
    
13. {
    
14.         this->counter++;
    
15. }
    
16. 
    
17. int main()
    
18. {
    
19.         MyClass* objA = new MyClass;
    
20.         MyClass* objB = new MyClass;
    
21.         objA->Increase();
    
22.         cout << objB->counter << endl;
    
23.         return 0;
    
24. }
    

复制代码

在以上代码中，如果this指针可以通知类这个“模子”本身的话，那么所有由这个模子构造出来的实例的counter变量值都应该+1，输出结果应为：
1
1
而实际上输出结果为：
1
0
所以this指针访问该实例构造出来的，属于该实例“自己”的那个类的内存中的成员变量counter。简而言之，objA在new的时候new出来一个：int counter = 0; 、一个void(*Increase)(void); ，objB在new的时候“又”new出来一个int counter = 0; 、一个void(*Increase)(void); 。如果再new一个objC，那么内存中再多一组int counter = 0; 、void(*Increase)(void); 。此时虽然三个obj都有counter，但是objC中的Increase函数只访问objC内存中的counter。
为了说明构造函数，我们需要改进“园丁游戏C版本”。我们叫改进过的C版本为“园丁游戏C-2”
C-2版本：
你现在是一个园丁，拥有两颗树苗。一颗苹果树，一颗橘子树。树苗生命值最大100。生命值为0则树苗死亡。
刚刚买回来，苹果树苗生命值85，高度100cm，没有结果子。
刚刚买回来，橘子树苗生命值90，高度105cm，没有结果子。
以后每一天树苗因为生长生命值-15，而高度+10cm。
苹果树在生命值大于等于30的情况下，每天结一颗果子。
橘子树在生命值大于等于60的情况下，每天结一颗果子。
两颗果树每一颗果子每一天消耗生命值2
每天你可以执行4个操作其中的一个：
0.        退出游戏
1.        浇水
2.        修剪高度
3.        摘果子
4.        什么也不做
选择浇水，可以输入水量（以公升计算）。每浇水一升，树苗生命值+1 。如果生命值超过100，则进行倒扣（浇水过多植物寿命减少）。如果当天选择浇水，则树苗当天高度立即+6（树苗吸水增长）。
选择摘果子，可以输入摘果数量，该数量不能大于结果数。
你的目标：使得树苗高度达到可以售卖的标准200cm。同时天数越短越好。达到200cm后的果树：苹果与橘子单个售价均为$1, 卖果子所得的钱将作为你的额外收入。收入越多越好。
注：超过200cm可以使用修剪功能减小树苗高度，但是剪切长度超过树苗高度，树苗即死亡。
我们来分析红色变动部分：
两棵树的初始高度和生命值现在都不一样了，显然，不能够在类中对高度和生命值进行统一初始化了，这里我们引入“构造函数”。请看代码：

1. //代码3-5
   
2. #include <stdio.h>
   
3. const int HEIGHT_STANDARD = 200; //植物标准高度
   
4. 
   
5. class Plant//植物类
   
6. {
   
7. public: //公开类中所有成员
   
8.         int height = 0;
   
9.         int health = 0;
   
10.         int apple = 0;
    
11.         int orange = 0;
    
12.         Plant(int vHealth, int vHeight);           //构造函数
    
13.         void Cut(int iCuttOffHeightByCentiMeter);  //剪切植物
    
14.         void Water(int iWaterQuantityByLitery);    //浇水
    
15.         void PickFruit(int howManyFruits);         //摘果子
    
16. };
    
17. 
    
18. Plant::Plant(int vHealth, int vHeight)
    
19. {
    
20.         health = vHealth;
    
21.         height = vHeight;
    
22. }
    
23. 
    
24. void Plant::Cut(int iCuttOffHeightByCentiMeter) //成员函数
    
25. {
    
26.         if (height - iCuttOffHeightByCentiMeter >= 0) //若剪切后的高度大于0
    
27.                 height -= iCuttOffHeightByCentiMeter; //剪切
    
28.         else
    
29.                 health = 0; //被剪死了
    
30. }
    
31. 
    
32. void Plant::Water(int iWaterQuantityByLitery) //成员函数
    
33. {
    
34.         int Orghealth = health; //记录浇水前的生命值
    
35.         health += iWaterQuantityByLitery; //生命值等于浇水水量
    
36.         health += 6; //每次浇水高度+6
    
37.         if (health > 100) //生命值大于100
    
38.                 health = Orghealth + 100 - health; //生命值倒扣
    
39.         if (health < 0) //淹死了
    
40.                 health = 0;
    
41.         printf("\thealth+ %d\n\tHeight+ 6\n", health - Orghealth); //显示浇水后生命值以及高度的变化
    
42. }
    
43. 
    
44. void Plant::PickFruit(int howManyFruits) //成员函数
    
45. {
    
46.         int Apple = apple;   //苹果数
    
47.         int Orange = orange; //橘子数
    
48.                                                  //摘果
    
49.         if (Apple > 0 && Apple - howManyFruits >= 0)
    
50.                 apple -= howManyFruits;
    
51.         if (Orange > 0 && Orange - howManyFruits >= 0)
    
52.                 orange -= howManyFruits;
    
53. }
    
54. 
    
55. void HangARealDay(Plant* AppleTree, Plant* OrangeTree) //全局函数
    
56. {
    
57.         AppleTree->health -= 15 + AppleTree->apple * 2;
    
58.         OrangeTree->health -= 15 + OrangeTree->orange * 2;
    
59.         printf("\tHealth -15\n");
    
60.         if (AppleTree->health > 20)
    
61.                 AppleTree->height += 10;
    
62.         if (OrangeTree->health > 20)
    
63.                 OrangeTree->height += 10;
    
64.         if (AppleTree->health >= 30)
    
65.                 AppleTree->apple++;
    
66.         if (OrangeTree->health >= 60)
    
67.                 OrangeTree->orange++;
    
68.         printf("Reports for apple tree:\n\tHeight: %d/200\n\tHealth: %d/100\n\tFruits: %d\n", AppleTree->height, AppleTree->health, AppleTree->apple);
    
69.         printf("Reports for orange tree:\n\tHeight: %d/200\n\tHealth: %d/100\n\tFruits: %d\n", OrangeTree->height, OrangeTree->health, OrangeTree->orange);
    
70. }
    
71. 
    
72. int main()
    
73. {
    
74.         int iOption; //操作选择
    
75.         int subOption;
    
76. 
    
77.         int Day = 0; //天数
    
78. 
    
79.         Plant* AppleTree = new Plant(100, 85);  //构建苹果树时使用类的构造函数，给参：生命值、高度
    
80.         Plant* OrangeTree = new Plant(90, 105); //构建橘子树时使用类的构造函数，给参：生命值、高度
    
81.         Plant* TargetPlant;
    
82. 
    
83.         printf("Welcome!\nNow you have double saplings.\n");
    
84.         printf("Begin your career as a gardener, and enjoy the game.\n");
    
85. 
    
86.         while (1)
    
87.         {
    
88.                 Day++;
    
89.                 printf("Days %d\n", Day);
    
90.                 HangARealDay(AppleTree, OrangeTree);
    
91. 
    
92.                 if (AppleTree->health <= 0 || OrangeTree->health <= 0)
    
93.                         goto Lbl_Game_Over;
    
94.                 printf("Choose a plant to operate.[0] for apple tree,[1] for orange tree.\n");
    
95.                 scanf("%d", &iOption);
    
96.                 if (!iOption && AppleTree->height != HEIGHT_STANDARD)
    
97.                         TargetPlant = AppleTree;
    
98.                 else if (iOption == 1 && OrangeTree->height != HEIGHT_STANDARD)
    
99.                         TargetPlant = OrangeTree;
    
100.                 else
     
101.                         goto Lbl_Pass_Anyway;
     
102. 
     
103.                 printf("[1]Water.[2]Cut.[3]Pick Fruits.[0]Give it up.\n");
     
104.                 scanf("%d", &iOption);
     
105.                 switch (iOption)
     
106.                 {
     
107.                 case 1:
     
108.                         printf("\tInput water quantity:");
     
109.                         scanf("%d", &subOption);
     
110.                         TargetPlant->Water(subOption); //省略THIS
     
111.                         break;
     
112.                 case 2:
     
113.                         printf("\tInput height to cut:");
     
114.                         scanf("%d", &subOption);
     
115.                         TargetPlant->Cut(subOption); //省略THIS
     
116.                         break;
     
117.                 case 3:
     
118.                         printf("\tInput quantity to pick up:");
     
119.                         scanf("%d", &subOption);
     
120.                         TargetPlant->PickFruit(subOption); //省略THIS
     
121.                         break;
     
122.                 case 0:
     
123.                         goto Lbl_Exit;
     
124.                 Lbl_Pass_Anyway:
     
125.                 default:
     
126.                         printf("You have done nothing?\n");
     
127.                 }
     
128.         }
     
129.         printf("%d Days,All plants were fit to sale! Any you got $%d for pocket money!\n", Day, AppleTree->apple + OrangeTree->orange);
     
130.         return 0;
     
131. Lbl_Exit:
     
132.         printf("Wont you keep going on it?\n");
     
133.         return 0;
     
134. Lbl_Game_Over:
     
135.         printf("One of your plants was die.");
     
136.         return 0;
     
137. }
     

复制代码

以上代码中，我们使用了构造函数来修改初始值。构造函数是和类同名的函数，而且构造函数的类中声明与类外实现不能加返回值说明。
然而“构造函数”不是浪得虚名，我们还可以这样创建Plant类的实例：
        Plant AppleTree(100, 85);
        Plant OrangeTree(90, 105);
在建造AppleTree和OrangeTree时，直接在对象名称后面带参的方式也是调用了构造函数，构造出了AppleTree与OrangeTree。
如果类中成员涉及到了动态内存管理。比如这样一个类：

1. //代码3-6
   
2. #include <iostream>
   
3. #include <string.h>
   
4. using namespace std;
   
5. 
   
6. class Str
   
7. {
   
8. public:
   
9.         char* ptrStr = NULL;
   
10.         Str(char* vStr);
    
11.         ~Str();
    
12. };
    
13. 
    
14. Str::Str(char* vStr)
    
15. {
    
16.         ptrStr = (char*)malloc(sizeof(char) * (strlen(vStr) + 1));
    
17.         strcpy(ptrStr, vStr);
    
18. }
    
19. 
    
20. Str::~Str()
    
21. {
    
22.         free(ptrStr);
    
23. }
    
24. 
    
25. int main()
    
26. {
    
27.         Str varString = "abcdefg";
    
28.         cout << varString.ptrStr << endl;
    
29.         return 0;
    
30. }
    

复制代码

如果我们不使用varString实例，而Str类中ptrStr指针又没有被释放，内存会逐渐堆积起来直到泄露。在与类名相同的函数前加上“~”符号的函数叫做“析构函数”。析构函数在类实例化出来的对象被销毁时自动调用。析构函数是用来“扫尾”的。举个骇人的例子：构造函数“接生”对象。析构函数“打理后事”，“安葬”对象，免得对象死后妨碍后人。
在C++之父的努力下，一个面向对象的C诞生了。它不仅支持C的全部属性用法，而且让C具备了更完善的描述世界的能力。

cyycoish

第四篇：人民内部问题

卜算子 OOP
面向过程边
踌躇止不前
已是信息爆炸世
重构来调校
造出结构类
包罗万象妙
待到革命完成时
却有问题闹。
我们来研究代码3-5里边的类：
将代码3-5的类单独拿出来：

1. class Plant//植物类
   
2. {
   
3. public: //公开类中所有成员
   
4.         int height = 0;
   
5.         int health = 0;
   
6.         int apple = 0;
   
7.         int orange = 0;
   
8.         Plant(int vHealth, int vHeight);           //构造函数
   
9.         void Cut(int iCuttOffHeightByCentiMeter);  //剪切植物
   
10.         void Water(int iWaterQuantityByLitery);    //浇水
    
11.         void PickFruit(int howManyFruits);         //摘果子
    
12. };
    

复制代码

我们可以看到，访问植物属性用的是什么办法呢？对了，直接读取公有属性height，health。这样做并不是很好的。因为如果误设了属性变量值，比如将health设置为负数。或者在if判断语句中不小心将==写成了=比如 if (MyPlant.height = 200) 然后导致了bug。怎么解决？将保存属性的变量与属性的读取设置过程分离开来，我们一起改造原先的类：

1. //代码4-1
   
2. class Plant//植物类
   
3. {
   
4. public:
   
5.         int height = 0;
   
6.         int health = 0;
   
7.         int apple = 0;
   
8.         int orange = 0;
   
9.         Plant(int vHealth, int vHeight);           //构造函数
   
10.         void Cut(int iCuttOffHeightByCentiMeter);  //剪切植物
    
11.         void Water(int iWaterQuantityByLitery);    //浇水
    
12.         void PickFruit(int howManyFruits);         //摘果子
    
13.         bool ReduceHeight(int Height);             //消减高度
    
14.         bool ReduceHealth(int Health);             //消减生命值
    
15.         bool IncreaseFruit(int FruitsNumber);      //结果子
    
16.         int GetHeight(void)                        //取得高度
    
17.         {
    
18.                 return height;
    
19.         }
    
20.         int GetHealth(void)                        //取得生命值
    
21.         {
    
22.                 return health;
    
23.         }
    
24.         int GetAppleFruit(void)                    //取得苹果数量
    
25.         {
    
26.                 return apple;
    
27.         }
    
28.         int GetOrangeFruit(void)                   //取得橘子数量
    
29.         {
    
30.                 return orange;
    
31.         }
    
32. };
    

复制代码

这样子修改以后我们可以调用GetXXX函数获取属性值，调用ReduceXXX函数消减高度和生命值，调用IncreaseFruit函数增加果子数量。
好了，问题来了。我们如何隐藏health，height，apple，orange属性避免其被误访问？办法是将其锁入private权限：

1. //代码4-2
   
2. #include <stdio.h>
   
3. const int HEIGHT_STANDARD = 200; //植物标准高度
   
4. 
   
5. class Plant//植物类
   
6. {
   
7. private:
   
8.         int height = 0;
   
9.         int health = 0;
   
10.         int apple = 0;
    
11.         int orange = 0;
    
12. public:
    
13.         Plant(int vHealth, int vHeight);           //构造函数
    
14.         void Cut(int iCuttOffHeightByCentiMeter);  //剪切植物
    
15.         void Water(int iWaterQuantityByLitery);    //浇水
    
16.         void PickFruit(int howManyFruits);         //摘果子
    
17.         bool ReduceHeight(int Height);             //消减高度
    
18.         bool ReduceHealth(int Health);             //消减生命值
    
19.         bool IncreaseFruit(int FruitsNumber);      //结果子
    
20.         int GetHeight(void)                        //取得高度
    
21.         {
    
22.                 return height;
    
23.         }
    
24.         int GetHealth(void)                        //取得生命值
    
25.         {
    
26.                 return health;
    
27.         }
    
28.         int GetAppleFruits(void)                    //取得苹果数量
    
29.         {
    
30.                 return apple;
    
31.         }
    
32.         int GetOrangeFruits(void)                   //取得橘子数量
    
33.         {
    
34.                 return orange;
    
35.         }
    
36. };
    
37. 
    
38. Plant::Plant(int vHealth, int vHeight)
    
39. {
    
40.         health = vHealth;
    
41.         height = vHeight;
    
42. }
    
43. 
    
44. void Plant::Cut(int iCuttOffHeightByCentiMeter) //成员函数
    
45. {
    
46.         if (height - iCuttOffHeightByCentiMeter >= 0) //若剪切后的高度大于0
    
47.                 height -= iCuttOffHeightByCentiMeter; //剪切
    
48.         else
    
49.                 health = 0; //被剪死了
    
50. }
    
51. 
    
52. void Plant::Water(int iWaterQuantityByLitery) //成员函数
    
53. {
    
54.         int Orghealth = health; //记录浇水前的生命值
    
55.         health += iWaterQuantityByLitery; //生命值等于浇水水量
    
56.         health += 6; //每次浇水高度+6
    
57.         if (health > 100) //生命值大于100
    
58.                 health = Orghealth + 100 - health; //生命值倒扣
    
59.         if (health < 0) //淹死了
    
60.                 health = 0;
    
61.         printf("\thealth+ %d\n\tHeight+ 6\n", health - Orghealth); //显示浇水后生命值以及高度的变化
    
62. }
    
63. 
    
64. void Plant::PickFruit(int howManyFruits) //成员函数
    
65. {
    
66.         int Apple = apple;   //苹果数
    
67.         int Orange = orange; //橘子数
    
68.                                                  //摘果
    
69.         if (Apple > 0 && Apple - howManyFruits >= 0)
    
70.                 apple -= howManyFruits;
    
71.         if (Orange > 0 && Orange - howManyFruits >= 0)
    
72.                 orange -= howManyFruits;
    
73. }
    
74. 
    
75. bool Plant::ReduceHeight(int Height)
    
76. {
    
77.         if (this->height - Height >= 0)
    
78.                 return false;
    
79.         else
    
80.                 this->height -= Height;
    
81.         return true;
    
82. }
    
83. 
    
84. bool Plant::ReduceHealth(int Health)
    
85. {
    
86.         if (this->health - Health >= 0)
    
87.                 return false;
    
88.         else
    
89.                 this->health -= Health;
    
90.         return true;
    
91. }
    
92. 
    
93. bool Plant::IncreaseFruit(int FruitsNumber)
    
94. {
    
95.         if (FruitsNumber >= 0)
    
96.         {
    
97.                 apple += FruitsNumber;
    
98.                 orange += FruitsNumber;
    
99.                 return true;
    
100.         }
     
101.         else
     
102.                 return false;
     
103. }
     
104. 
     
105. void HangARealDay(Plant* AppleTree, Plant* OrangeTree) //全局函数
     
106. {
     
107.         AppleTree->ReduceHealth(-(15 + AppleTree->GetAppleFruits() * 2));
     
108.         OrangeTree->ReduceHealth(-(15 + OrangeTree->GetOrangeFruits() * 2));
     
109.         printf("\t- Health\n");
     
110.         if (AppleTree->GetHeight() > 20)
     
111.                 AppleTree->ReduceHeight(-10);
     
112.         if (OrangeTree->GetHealth() > 20)
     
113.                 OrangeTree->ReduceHeight(-10);
     
114.         if (AppleTree->GetHealth() >= 30)
     
115.                 AppleTree->IncreaseFruit(1);
     
116.         if (OrangeTree->GetHealth() >= 60)
     
117.                 OrangeTree->IncreaseFruit(1);
     
118.         printf("Reports for apple tree:\n\tHeight: %d/200\n\tHealth: %d/100\n\tFruits: %d\n", AppleTree->GetHeight(), AppleTree->GetHealth(), AppleTree->GetAppleFruits());
     
119.         printf("Reports for orange tree:\n\tHeight: %d/200\n\tHealth: %d/100\n\tFruits: %d\n", OrangeTree->GetHeight(), OrangeTree->GetHealth(), OrangeTree->GetOrangeFruits());
     
120. }
     
121. 
     
122. int main()
     
123. {
     
124.         int iOption; //操作选择
     
125.         int subOption;
     
126. 
     
127.         int Day = 0; //天数
     
128. 
     
129.         Plant* AppleTree = new Plant(100, 85);  //构建苹果树时使用类的构造函数，给参：生命值、高度
     
130.         Plant* OrangeTree = new Plant(90, 105); //构建橘子树时使用类的构造函数，给参：生命值、高度
     
131.         Plant* TargetPlant;
     
132. 
     
133.         printf("Welcome!\nNow you have double saplings.\n");
     
134.         printf("Begin your career as a gardener, and enjoy the game.\n");
     
135. 
     
136.         while (1)
     
137.         {
     
138.                 Day++;
     
139.                 printf("Days %d\n", Day);
     
140.                 HangARealDay(AppleTree, OrangeTree);
     
141. 
     
142.                 if (AppleTree->GetHealth() <= 0 || OrangeTree->GetHealth() <= 0)
     
143.                         goto Lbl_Game_Over;
     
144.                 printf("Choose a plant to operate.[0] for apple tree,[1] for orange tree.\n");
     
145.                 scanf("%d", &iOption);
     
146.                 if (!iOption && AppleTree->GetHeight() != HEIGHT_STANDARD)
     
147.                         TargetPlant = AppleTree;
     
148.                 else if (iOption == 1 && OrangeTree->GetHeight() != HEIGHT_STANDARD)
     
149.                         TargetPlant = OrangeTree;
     
150.                 else
     
151.                         goto Lbl_Pass_Anyway;
     
152. 
     
153.                 printf("[1]Water.[2]Cut.[3]Pick Fruits.[0]Give it up.\n");
     
154.                 scanf("%d", &iOption);
     
155.                 switch (iOption)
     
156.                 {
     
157.                 case 1:
     
158.                         printf("\tInput water quantity:");
     
159.                         scanf("%d", &subOption);
     
160.                         TargetPlant->Water(subOption); //省略THIS
     
161.                         break;
     
162.                 case 2:
     
163.                         printf("\tInput height to cut:");
     
164.                         scanf("%d", &subOption);
     
165.                         TargetPlant->Cut(subOption); //省略THIS
     
166.                         break;
     
167.                 case 3:
     
168.                         printf("\tInput quantity to pick up:");
     
169.                         scanf("%d", &subOption);
     
170.                         TargetPlant->PickFruit(subOption); //省略THIS
     
171.                         break;
     
172.                 case 0:
     
173.                         goto Lbl_Exit;
     
174.                 Lbl_Pass_Anyway:
     
175.                 default:
     
176.                         printf("You have done nothing?\n");
     
177.                 }
     
178.         }
     
179.         printf("%d Days,All plants were fit to sale! Any you got $%d for pocket money!\n", Day, AppleTree->GetAppleFruits() + OrangeTree->GetOrangeFruits());
     
180.         return 0;
     
181. Lbl_Exit:
     
182.         printf("Wont you keep going on it?\n");
     
183.         return 0;
     
184. Lbl_Game_Over:
     
185.         printf("One of your plants was die.");
     
186.         return 0;
     
187. }
     

复制代码

同样，类内部有函数不想公开的话，也可以锁入private权限。
至此，我们解决的人们内部“资源所有”问题的一半，即“私有财产圣神不可侵犯”。现在我们要在类的众多实例当中实行共产。
请看问题：如果我要让所有的同一个类造出来的实例都能访问一个变量，该怎么做？可能大家会回答：这还不简单，在类外部定义变量即可。那么我要求在类内部定义呢？这时大家打脸：意义何在？回答：如果我有“动物类（class Animal）”和“植物类（class Plant）”我是上帝，定义在一年（365天）的春季初（3月，差不多一年开始第90天）动物发情植物授粉。现在我要把所有的“动物类”的实例动物全部搬到南半球，植物都在北半球。南半球的春天是北半球的冬天。差不多发情期在第270天左右。好了现在设置两个共有变量: int植物授粉期 = 90;int 动物发情期 = 90; 在main函数中改：动物发情期 = 270; XXX;XXX;。如此这般我还不如在两个类中都申明一个静态变量static int Estrus = 90; 然后呢我只要改Animal类的一个实例，比如Cat，Cat.Estrus = 270;这时候Animal的实例不管是老虎还是狼，它们的发情期都变成了270.
为了好理解，我简单写了一下代码：

1. //代码4-3
   
2. #include <iostream>
   
3. using namespace std;
   
4. 
   
5. class Animal
   
6. {
   
7. private:
   
8.         int health = 100;
   
9.         int XXX;
   
10. public:
    
11.         static int estrus;
    
12. 
    
13.         void Kill()
    
14.         {
    
15.                 health = 0;
    
16.         }
    
17. };
    
18. 
    
19. class Plant
    
20. {
    
21. private:
    
22.         int health = 100;
    
23.         int XXX;
    
24. public:
    
25.         static int estrus;
    
26. 
    
27.         void Kill()
    
28.         {
    
29.                 health = 0;
    
30.         }
    
31. };
    
32. 
    
33. int Animal::estrus = 90; //使用静态成员变量必须用这种方式进行静态成员变量的初始化
    
34. int Plant::estrus = 90;  //使用静态成员变量必须用这种方式进行静态成员变量的初始化
    
35. 
    
36. int main()
    
37. {
    
38.         Plant Tree;
    
39.         Plant Grass;
    
40.         Animal Cat;
    
41.         Animal Tiger;
    
42.         Animal Wolf;
    
43.         Animal Dog;
    
44.        
    
45.         cout << "Cat: " << Cat.estrus << endl;
    
46.         cout << "Dog: " << Dog.estrus << endl;
    
47.         cout << "Cat: " << Wolf.estrus << endl;
    
48.         Dog.estrus = 270;
    
49.         cout << "Cat: " << Cat.estrus << endl;
    
50.         cout << "Dog: " << Dog.estrus << endl;
    
51.         cout << "Cat: " << Wolf.estrus << endl;
    
52.         return 0;
    
53. }
    

复制代码

为啥要对静态成员变量进行初始化呢？
静态成员变量在实例化的时候并不是每实例化一次就为其分配一次内存。其实静态成员变量/函数就是全局的，只不过作用于这个类，受用于这个类的所有实例对象。
革命成功后随之而来的就是对政权的巩固，然而这个过程并不是一天两天，十年八年。甚至要维持到王朝结束的前一天。我们暂时解决的了人民的内部问题：分配了资产，个人的给个人，大家的大家共享。但是有一句话：One Problem Finished, Another Always Come.接下来的几章中，老C继续带大家探索实践发现“面向对象”。

7KY6

可以可以!!