本帖最后由 群发软件 于 2017-6-15 16:04 编辑
到一位同学发布的博文，模拟了掷骰子。很好的题目，初学编程，就可以这样，找到一个很小，很好玩的需求去完成，这是未来做大项目的“引子”。
他用代码实现了需求，这是最重要的。
我也按捺不住，给一个新的版本。目前，同学们习惯了面向过程的思维，只管着让程序按照流程做完事即可，对面向对象程序的结构还没有感觉。类的封装，该如何体现？函数的接口，怎样才算简洁？这些问题，用讲的方式起个头可以，更重要的是，在用的过程中得到领悟。
学生的程序是：
[cpp] view plain copy
print?
- #include <iostream>
- #include <cstdlib>
- #include <ctime>
- using namespace std;
- class shaizi
- {
- public:
- void yaodian();
- private:
- int a;
- };
- int main()
- {
- cout << "摇出的点数" << endl;
- shaizi s1;
- s1.yaodian();
- return 0;
- }
- void shaizi::yaodian()
- {
- int x;
- srand(time(0));
- x=rand()%5+1;
- a=x;
- cout<<a;
- }
我改写的程序是：
[cpp] view plain copy
print?
- #include <iostream>
- #include <cstdlib>
- #include <ctime>
- using namespace std;
- class shaizi
- {
- public:
- int getdian();
- private:
- int dian;
- };
- int main()
- {
- shaizi s1;
- cout << "摇出的点数" <<s1.getdian()<<endl;
- return 0;
- }
- int shaizi::getdian()
- {
- srand(time(0));
- dian=rand()%6+1;
- return dian;
- }
这个程序的结构要好一些。输出的工作交给main，对象s1只管提供数就行了。
一个很简单的要求，输入输出尽可能交给测试函数，类只做围绕数据的处理工作。除非实在必要，不要在成员函数中用cin和cout。
学习了后面的构造函数，这个简单程序还可以别的改造。
再写了一个好玩的，希望用常量定下局数后，能够多轮决输赢。例如，下面的程序，想9局5胜。
[cpp] view plain copy
print?
- #include <iostream>
- #include <cstdlib>
- #include <ctime>
- using namespace std;
- class shaizi
- {
- public:
- void setdian();
- int getdian();
- private:
- int dian;
- };
- const int round=9; //round必须置一个奇数
- int main()
- {
- shaizi s1,s2;
- int i=1,n1=0,n2=0;
- while(i<=round)
- {
- s1.setdian();
- s2.setdian();
- cout<<"第"<<i<<"轮: 甲 "<<s1.getdian()<<"，乙: "<<s2.getdian();
- if(s1.getdian()>s2.getdian())
- n1++;
- else if (s2.getdian()>s1.getdian())
- n2++;
- else
- {
- cout<<"，平局重掷 ";
- continue;
- }
- i++;
- cout<<endl;
- if(n1==(round/2+1)||n2==(round/2+1))
- break;
- }
- cout << "甲赢 "<<n1<<" 轮，乙赢 "<<n2<<" 轮";
- if(n1>n2)
- cout<<"，甲胜"<<endl;
- else if(n2>n1)
- cout<<"，乙胜"<<endl;
- return 0;
- }
- int shaizi::getdian()
- {
- return dian;
- }
- void shaizi::setdian()
- {
- srand(time(0));
- dian=rand()%6+1;
- }
程序中用了类的“标配”,set和get成员函数都有，这个结构更好。在main函数中多设了些道道，能够9局5胜，且平局不算。
但是，程序运行是死循环！
在屏幕上的数字快速滚动中，猜测问题的原因是，每次都平局，都continue了。把28-32行的处理平局的代码去掉运行，果然如此。见图：
为什么会这样？还得说随机数的原理。用rand()得到的随机数，并不是完全随机，是“伪随机”，随机数序列取决于“种子数”，种子数由srand(long)设置。也就是说，当种子数相同时，得到的随机序列就是完全相同的。为此，常取系统时间（time(0)返回的是从1970年1月1日午夜起到现在的秒数）作种子数，这是个可以让每次运行时种子数都不同的办法。
然而 在这个程序中，调用s1和s2两个对象的setdian成员函数时，间隔的时间太短了，现在再慢的计算机，也不会让再次调用间隔超过1秒，甚至在这1秒末，那一秒初的那一瞬间的可能性都没有。每次都平局，不可避免。
好不容易想到个好玩的简单游戏，就此罢休？想到的一个解决方案，让两次“投掷”停顿一下（这在专业中叫做“延时”），可以做到能够得出不同的种子数。
程序如下：
[cpp] view plain copy
print?
- #include <iostream>
- #include <cstdlib>
- #include <ctime>
- #include <windows.h>
- using namespace std;
- class shaizi
- {
- public:
- void setdian();
- int getdian();
- private:
- int dian;
- };
- const int round=9; //round必须置一个奇数
- int main()
- {
- shaizi s1,s2;
- int i=1,n1=0,n2=0;
- while(i<=round)
- {
- s1.setdian();
- Sleep(1000); //延时1000毫秒，即1秒
- s2.setdian();
- cout<<"第"<<i<<"轮: 甲 "<<s1.getdian()<<"，乙: "<<s2.getdian();
- if(s1.getdian()>s2.getdian())
- n1++;
- else if (s2.getdian()>s1.getdian())
- n2++;
- else
- {
- cout<<"，平局重掷 "<<endl;
- continue;
- }
- i++;
- cout<<endl;
- if(n1==(round/2+1)||n2==(round/2+1))
- break;
- }
- cout << "甲赢 "<<n1<<" 轮，乙赢 "<<n2<<" 轮";
- if(n1>n2)
- cout<<"，甲胜"<<endl;
- else if(n2>n1)
- cout<<"，乙胜"<<endl;
- return 0;
- }
- int shaizi::getdian()
- {
- return dian;
- }
- void shaizi::setdian()
- {
- srand(time(0)); //设置种子数，由于有了间隔，能够保证种子数不同
- dian=rand()%6+1; //实际每次取出的是，种子数确定的随机序列中的第一个
- }
加入的Sleep(1000)是延迟1000毫秒，为了调用此函数，需要#include<window.h>。
由于延时，结果每隔1秒出来一行，倒也好看。见图：
下面再给一种方案，种子数不再每次获得随机数前置，而是在main函数开始时设置，也能得到好的效果。见程序：
[cpp] view plain copy
print?
- #include <iostream>
- #include <cstdlib>
- #include <ctime>
- using namespace std;
- class shaizi
- {
- public:
- void setdian();
- int getdian();
- private:
- int dian;
- };
- const int round=9; //round必须置一个奇数
- int main()
- {
- shaizi s1,s2;
- int i=1,n1=0,n2=0;
- srand(time(0)); //设置一次种子数，决定整个程序中用到的随机序列
- while(i<=round)
- {
- s1.setdian();
- s2.setdian();
- cout<<"第"<<i<<"轮: 甲 "<<s1.getdian()<<"，乙: "<<s2.getdian();
- if(s1.getdian()>s2.getdian())
- n1++;
- else if (s2.getdian()>s1.getdian())
- n2++;
- else
- {
- cout<<"，平局重掷 "<<endl;
- continue;
- }
- i++;
- cout<<endl;
- if(n1==(round/2+1)||n2==(round/2+1))
- break;
- }
- cout << "甲赢 "<<n1<<" 轮，乙赢 "<<n2<<" 轮";
- if(n1>n2)
- cout<<"，甲胜"<<endl;
- else if(n2>n1)
- cout<<"，乙胜"<<endl;
- return 0;
- }
- int shaizi::getdian()
- {
- return dian;
- }
- void shaizi::setdian()
- {
- dian=rand()%6+1;
- }
该还有别的方案，评论中接龙。
下面介绍一个非常简单的C++程序，了解C++程序的组成。现在读者不需要输入代码，只是了解一下建立程序的过程。这里也不详细介绍所有的细节，因为这些内容将在后面的章节中探讨。见图1-2。
图 1-2
图1-2中所示的程序会显示如下消息：
The best place to start is at the beginning
该程序包含一个函数main()，该函数的第一行语句是：
int main()
函数是代码的一个自包含块，用一个名称表示，在本例中是main。程序中还可以有许多其他代码，但每个C++程序至少要包含函数main()，且只能有一个main()函数。C++程序的执行总是从main()中的第一条语句开始。
函数main()包含两个可执行语句：
cout <<" The best place to start is at the beginning";
return 0;
这些语句会按顺序执行，先执行第一句。通常情况下，函数中的语句总是按顺序执行，除非有一个语句改变了执行顺序。第4章将介绍什么类型的语句可以改变执行顺序。
在C++中，输入和输出是使用流来执行的。如果要输出消息，可以把该消息放在输出流中，如果要输入消息，则把它放在输入流中。在C++中，标准的输出流和输入流称为cout和cin，它们分别使用计算机屏幕和键盘。
上面的代码利用插入运算符<<把字符串“The best place to start is at the beginning”放在输出流中，从而把它输出到屏幕上。在编写涉及到输入的程序时，应使用提取运算符>>。
名称cout在头文件iostream中定义。这是一个标准的头文件，它提供了在C++中使用标准输入和输出功能所需要的定义。如果程序不包含下面的代码行：
#include <iostream>
那么就不会编译，因为iostream头文件包含了cout的定义，没有它，编译器就不知道cout是什么。
提示：
在尖括号和标准头文件名之间没有空格。在许多编译器中，两个尖括号<和>之间的空格是很重要的，如果在这里插入了空格，程序就可能不编译。
函数体中的第二个语句，也是最后一个语句：
return 0;
结束了该程序，把控制权返回给操作系统。它还把值0返回给操作系统。也可以返回其他值，来表示程序的不同结束条件，操作系统还可以利用该值来判断程序是否执行成功。但是，程序是否能够执行取决于操作系统
本教程第一个C++程序，输出一行字符： “This is a C++ program.”。程序如下:
- #include <iostream> //包含头文件iostream
- using namespace std; //使用命名空间std
- int main( )
- {
- cout<<"This is a C++ program.";
- return 0;
- }
在运行时会在屏幕上输出以下一行信息：
This is a C++ program.
用main代表“主函数”的名字。每一个C++程序都必须有一个 main 函数。main前面的int的作用是声明函数的类型为整型。程序第6行的作用是向操作系统返回一个零值。如果程序不能正常执行，则会自动向操作系统返回一个非零值，一般为-1。
函数体是由大括号{ }括起来的。本例中主函数内只有一个以cout开头的语句。注意C++所有语句最后都应当有一个分号。
再看程序的第1行“#include <iostream>”，这不是C++的语句，而是C++的一个预处理命令，它以“#”开头以与C++语句相区别，行的末尾没有分号。#include <iostream>是一个“包含命令”，它的作用是将文件iostream的内容包含到该命令所在的程序文件中，代替该命令行。文件iostream的作用是向程序提供输入或输出时所需要的一些信息。iostream是i-o-stream 3个词的组合，从它的形式就可以知道它代表“输入输出流”的意思，由于这类文件都放在程序单元的开头，所以称为“头文件”(head file)。在程序进行编译时，先对所有的预处理命令进行处理，将头文件的具体内容代替 #include命令行，然后再对该程序单元进行整体编译。
程序的第2行“using namespace std; ” 的意思是“使用命名空间std”。C++标准库中的类和函数是在命名空间std中声明的，因此程序中如果需要用到C++标准库（此时就需要用#include命令行），就需要用“using namespace std; ”作声明，表示要用到命名空间std中的内容。
在初学C++时，对本程序中的第1, 2行可以不必深究，只需知道：如果程序有输入或输出时，必须使用“#include <iostream>”命令以提供必要的信息，同时要用“using namespace std;” ，使程序能够使用这些信息，否则程序编译时将出错。
【例1.2】求a和b两个数之和。可以写出以下程序：
- // 求两数之和 (本行是注释行)
- #include <iostream> //预处理命令
- using namespace std; //使用命名空间std
- int main( ) //主函数首部
- { //函数体开始
- int a, b, sum; //定义变量
- cin>>a>>b; //输入语句
- sum=a+b; //赋值语句
- cout<<"a+b="<<sum<<endl; //输出语句
- return 0; //如程序正常结束，向操作系统返回一个零值
- } //函数结束
本程序的作用是求两个整数a和b之和sum。第1行“//求两数之和”是一个注释行，C++规定在一行中如果出现“//”，则从它开始到本行末尾之间的全部内容都作为注释。
如果在运行时从键盘输入
123 456↙
则输出为
a+b=579
【例1.3】给两个数x和y，求两数中的大者。在本例中包含两个函数。
- #include <iostream> //预处理命令
- using namespace std;
- int max(int x,int y) //定义max函数,函数值为整型,形式参数x,y为整型
- { //max函数体开始
- int z; //变量声明,定义本函数中用到的变量z为整型
- if(x>y)
- z=x; //if语句,如果x>y,则将x的值赋给z
- else z=y; //否则,将y的值赋给z
- return(z); //将z的值返回,通过max带回调用处
- } //max函数结束
- int main( ) //主函数
- { //主函数体开始
- int a,b,m; //变量声明
- cin>>a>>b; //输入变量a和b的值
- m=max(a,b); //调用max函数,将得到的值赋给m
- cout<<"max="<<m<<'\n'; //输出大数m的值
- return 0; //如程序正常结束,向操作系统返回一个零值
- } //主函数结束
本程序包括两个函数：主函数main和被调用的函数max。程序运行情况如下：
18 25 ↙ （输入18和25给a和b）
max=25 （输出m的值）
注意输入的两个数据间用一个或多个空格间隔，不能以逗号或其他符号间隔。
在上面的程序中，max函数出现在main函数之前，因此在main函数中调用max函数时，编译系统能识别max是已定义的函数名。如果把两个函数的位置对换一下，即先写main函数，后写max函数，这时在编译main函数遇到max时，编译系统无法知道max代表什么含义，因而无法编译，按出错处理。
为了解决这个问题，在主函数中需要对被调用函数作声明。上面的程序可以改写如下：
- #include <iostream>
- using namespace std;
- int main( )
- {
- int max(int x,int y); //对max函数作声明
- int a,b,c;
- cin>>a>>b;
- c=max(a,b); //调用max函数
- cout<<"max="<<c<<endl;
- return 0;
- }
- int max(int x,int y) //定义max函数
- {
- int z;
- if(x>y) z=x;
- else z=y;
- return(z);
- }
只要在被调用函数的首部的末尾加一个分号，就成为对该函数的函数声明。函数声明的位置应当在函数调用之前。
下面举一个包含类(class)和对象(object)的C++程序，目的是使读者初步了解C++是怎样体现面向对象程序设计方法的。
【例1.4】包含类的C++程序。
- #include <iostream>// 预处理命令
- using namespace std;
- class Student// 声明一个类,类名为Student
- {
- private: // 以下为类中的私有部分
- int num; // 私有变量num
- int score; // 私有变量score
- public: // 以下为类中的公用部分
- void setdata( ) // 定义公用函数setdata
- {
- cin>>num; // 输入num的值
- cin>>score; // 输入score的值
- }
- void display( ) // 定义公用函数display
- {
- cout<<"num="<<num<<endl; // 输出num的值
- cout<<"score="<<score<<endl;//输出score的值
- };
- }; // 类的声明结束
- Student stud1,stud2; //定义stud1和stud2为Student类的变量,称为对象
- int main( )// 主函数首部
- {
- stud1.setdata( ); // 调用对象stud1的setdata函数
- stud2.setdata( ); // 调用对象stud2的setdata函数
- stud1.display( ); // 调用对象stud1的display函数
- stud2.display( ); // 调用对象stud2的display函数
- return 0;
- }
在一个类中包含两种成员：数据和函数，分别称为数据成员和成员函数。在C++中把一组数据和有权调用这些数据的函数封装在一起，组成一种称为“类(class)”的数据结构。在上面的程序中，数据成员num，score和成员函数setdata，display组成了一个名为Student的“类”类型。成员函数是用来对数据成员进行操作的。也就是说，一个类是由一批数据以及对其操作的函数组成的。
类可以体现数据的封装性和信息隐蔽。在上面的程序中，在声明Student类时，把类中的数据和函数分为两大类：private(私有的)和public(公用的)。把全部数据(num，score)指定为私有的，把全部函数(setdata，display)指定为公用的。在大多数情况下，会把所有数据指定为私有，以实现信息隐蔽。
具有“类”类型特征的变量称为“对象”(object)。
程序中第18~24行是主函数。
程序运行情况如下:
1001 98.5 ↙ (输入学生1的学号和成绩)
1002 76.5 ↙ (输入学生2的学号和成绩)
num=1001 (输出学生1的学号)
score=98.5 (输出学生1的成绩)
num=1002 (输出学生2的学号)
score=76.5 (输出学生2的成绩)
|( 京ICP备09078825号 )
发表于 2017-6-15 15:59:39
收藏
