2023年面向对象程序设计实验报告.doc

教 案

2023 ~ 2023 学年 第 一 学期

学 院、 系 室 计算机科学系
课 程 名 称 面向对象程序设计
专业、年级、班级 12计算机嵌入式系统 、网络和信息安全班
主 讲 教 师 蒋琳琼

梧州学院

面向对象程序设计教案
课时分派：理论课39学时，实验课12学时，共51学时

第1章 C++初步知识
一、教学目的：
熟悉如何编缉、编译、连接和运营一个C++程序，了解在面向过程程序设计中C++对C功能的扩充与增强，并善于在编写程序过程中应用这些新的功能。
学时分派：9学时
二、教学重点：
了解软件设计、开发思想的演变，面向对象程序设计语言的发展；理解面向对象程序设计的基本思想；熟悉如何编缉、编译、连接和运营一个C++程序，熟悉C++程序的结构和编程方法。
三、教学难点：
善于在编写程序过程中应用这些新的C++对C功能的扩充与增强功能
四、教学方法：
课题讲授及面向对象程序设计实例演示
五、教学过程设计：（9学时）
1. C++语言的发展，最简朴的C++程序
1－1程序设计方法的发展和演变
大多数系统软件和许多应用软件都是用C语言编写的｡
但是随着软件规模的增大,用C语言编写程序渐渐显得有些吃力了｡
C++是由AT&T Bell(贝尔)实验室的Bjarne Stroustrup博士及其同事于20世纪80年代初在C语言的基础上开发成功的｡C++保存了C语言原有的所有优点,增长了面向对象的机制｡
C++是由C发展而来的,与C兼容｡用C语言写的程序基本上可以不加修改地用于C++｡从C++的名字可以看出它是C的超集｡C++既可用于面向过程的结构化程序设计,又可用于面向对象的程序设计,是一种功能强大的混合型的程序设计语言｡
C++对C的“增强”,表现在两个方面:
(1) 在本来面向过程的机制基础上,对C语言的功能做了不少扩充｡
(2) 增长了面向对象的机制｡
当前用得较为广泛的C++有：VC++ （Visual C Plus Plus）、 BC++（Borland C Plus Plus）、GCC、AT&T C++等。
• 假如选择了<win32-release>项,就会在工程所在的目录下产生一个新的目录’release’,在’release’目录下生成的可执行程序代码规模小,执行效率高,是我们最后的产品.
• 至此,即已生成了一个完整的程序.但要说明一点,我们现在VC++所编制的程序是运营于Windows中的DOS仿真环境下,至于编制真正的Windows程序尚有很长的一段路要走.

1－2面向对象程序设计的基本思想
下面举一个包含类(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;
}

1－3最简朴的C++程序
最简朴的C++程序
例1.1 输出一行字符: “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.
例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; //如程序正常结束,向操作系统返回一个零值
} //函数结束
例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; //如程序正常结束,向操作系统返回一个零值
} //主函数结束
• 例1.4是一个包含类的(class)和对象(object)的简朴程序,目的是初步了解C++是如何体现面向对象程序设计方法的.由于尚未系统介绍面向对象程序设计的概念,对程序理解不深,有一个初步的印象.下章具体介绍.

2. C++对C的扩充
上机暴露的问题：
1.语句cin>>a>>b>>endl;有什么问题?
2.关系运算符将表达式连接起来称为关系表达式。其值非真即假。在C++语言中，用非0代表真，用0表达假。关系表达式的结果只有两个，真为1，假为0。
3.语句cout<<a<<b,c<<“A”; 有什么问题?
4、C++控制结构。
2－1 C++的输入输出——I/O流控制
• 1. 用cout进行输出
• 2. 用cin进行输入
2－2用const定义常变量
• 一般把程序中不允许改变值的变量定义为常变量.
• C中
• #define PI 3.14159
• 实际只是在预编译时进行字符置换,PI不是变量,没有类型,不占用存储单元,并且容易犯错.
• C++
• Const float PI=3.14159
• 常变量PI具有变量的属性,有数据类型,占用存储单元,有地址,可用指针指向它.
• 举例: Int a=1;b=2;
• #define PI 3.14159
• #define R a+b
• Cout<<PI*R*R<<endl;
• 输出的并不是3.14159 *(a+b)*(a+b),而是3.14159 *a+b*a+b,
2－3函数——原型声明、重载、模板及默认参数函数、内联函数
• 在C++中,假如函数调用的位置在函数定义之前,则规定在函数调用之前必须对调用的函数作函数原型声明(强制性).
• 下面两种写法等价
• Int max(int x,int y);
• Int max(int ,int );//编译时只检查参数类型,不检查参数名.
•
• 函数的重载(一个函数名多用)是指C++允许在同一作用域(例如同一个文献模块)中用同一函数名定义多个函数,这些函数的参数个数和参数类型可以都不相同,也可实现功能不同.
• 例1.6 求3个数中的最大的数(分别考虑整数\实数\长整数的情况)
• 例1.7用一个函数求2个整数或3个整数中的最大者.
• 注意: 重载函数的参数个数或类型必须至少有其中之一不同,函数返回值类型可以相同也可以不同.但不允许参数个数和类型都相同而只有返回值不同,由于系统无法从函数的调用形式上判断哪一个函数与之匹配.
• 重载函数的参数个数或类型必须至少有其中之一不同,函数返回值类型可以相同也可以不同.但不允许参数个数和类型都相同而只有返回值不同,由于系统无法从函数的调用形式上判断哪一个函数与之匹配.
• #include <iostream>
• using namespace std;
• int max(int a,int b,int c) //求3个整数中的最大者
• { if (b>a) a=b;
• if (c>a) a=c;
• return a;
• }
• float max(float a,float b, float c) //求3个实数中的最大者
• {if (b>a) a=b;
• if (c>a) a=c;
• return a;
• }
• long max(long a,long b,long c) //求3个长整数中的最大者
• {if (b>a) a=b;
• if (c>a) a=c;
• return a;
• }
• int main( )
• {int a,b,c; float d,e,f; long g,h,i;
• cin>>a>>b>>c;
• cin>>d>>e>>f;
• cin>>g>>h>>i;
• int m;
• m= max(a,b,c); //函数值为整型
• cout <<"max_i="<<m<<endl;
• float n;
• n=max(d,e,f); //函数值为实型
• cout<<"max_f="<<n<<endl;
• long int p;
• p=max(g,h,i); //函数值为长整型
• cout<<"max_l="<<p<<endl;
• return 0;
• }
例1.8 将例1.6中的程序改为通过函数模板来实现.
• #include <iostream>
• using namespace std;
• template <typename T>
• T max(T a,T b,T c) //模板声明,其中T为类型参数
• {if(b>a) a=b; //定义一个通用函数,用T用虚拟的类型名
• if(c>a) a=c;
• return a;
• }
• int main()
• {int i1=8,i2=5,i3=6,i;
• double d1=56.9,d2=90.765,d3=43.1,d;
• long g1=67843,g2=-456,g3=78123,g;
• i=max(i1,i2,i3); //调用模板函数,此时T被int取代
• d=max(d1,d2,d3); //调用模板函数,此时T被double取代
• g=max(g1,g2,g3); //调用模板函数,此时T被long取代
• cout<<"i_max="<<i<<endl;
• cout<<"d_max="<<d<<endl;
• cout<<"g_max="<<g<<endl;
• return 0;
• }
1.3.6有默认参数的函数
• #include <iostream> //例1.7此程序为采用不带默认参数的函数
• using namespace std;
• int max(int a,int b,int c) //求3个整数中的最大者
• {if (b>a) a=b;
• if (c>a) a=c;
• return a;
• }
• int max(int a, int b) //求两个整数中的最大者
• {if (a>b) return a;
• else return b;
• }
• int main( )
• {int a=7,b=-4,c=9;
• cout<<max(a,b,c)<<endl; //输出3个整数中的最大者
• cout<<max(a,b)<<endl; //输出两个整数中的最大者
• return 0;
• }
• #include <iostream>//习题1.11,此程序为采用带默认参数的函数
• using namespace std;
• int main()
• {int max(int a,int b,int c=0);
• int a,b,c;
• cin>>a>>b>>c;
• cout<<"max(a,b,c)="<<max(a,b,c)<<endl;
• cout<<"max(a,b)="<<max(a,b)<<endl;
• return 0;
• }
• int max(int a,int b,int c)
• {if(b>a) a=b;
• if(c>a) a=c;
• return a;
• }
注意:
• 实参与形参的结合是从左至右进行的,指定默认值的参数必须放在形参表列中的最右端.
• 最佳在函数声明时指定默认值.(必须在函数调用之前将默认值的信息告知编译系统)
• 一个函数不能既作为重载函数,又作为有默认参数的函数.(二义性)
2－4变量的引用、作用域运算符和字符串变量
1.3.7变量的引用(别名)
• 1. 引用的概念
• 变量的”引用”就是变量的别名,对一个变量的”引用”的所有操作,事实上都是对其所代表的(本来的)变量的操作.
• Int a;
• Int &b=a;//声明b是一个整型变量的引用变量,它被初始化为a
• 注意:在上述声明中&是”引用声明符”,此时它并不代表地址.
• 对变量声明一个引用,并不另开辟内存单元,b和a都代表同一变量单元.在声明一个引用时,必须同时使之初始化,即声明它代表哪一个变量.
2. 引用的简朴使用
• #include <iostream>
• using namespace std;
• int main( )
• {int a=10;
• int &b=a; //声明b是a的引用
• a=a*a; //a的值变化了，b的值也应一起变化
• cout<<a<<" "<<b<<endl;
• b=b/5; //b的值变化了，a的值也应一起变化
• cout<<b<<" "<<a<<endl;
• return 0;
• }
3. 关于引用的简朴说明
• 当&a的前面有类型符时(如int &a),它必然是对引用的声明,假如前面没有类型符(如p=&a),此时的&是取地址运算符.
4. 将引用作为函数参数
• 1.将变量名作为实参.
• #include <iostream>//例1.10无法实现两个变量的值互换的程序
• using namespace std;
• void swap(int a,int b)
• {int temp;
• temp=a;
• a=b;
• b=temp; //实现a和b的值互换
• }
• int main( )
• {int i=3,j=5;
• swap(i,j);
• cout<<i<<","<<j<<endl; //i和j的值未互换
• return 0;
• }
• 2 传递变量的指针
• //例1.11使用指针变量作形参,实现两个变量的值互换
• #include <iostream>
• using namespace std;
• void swap(int *p1,int *p2)
• {int temp;
• temp=*p1;
• *p1= *p2;
• *p2=temp;
• }
• int main( )
• {int i=3,j=5;
• swap(&i,&j);
• cout<<i<<","<<j<<endl;
• return 0;
• }
•
2.传送变量的别名
• 例1.12运用”引用形参”实现两个变量的值互换.
• #include <iostream>
• using namespace std;
• void swap(int &a,int &b)
• {int temp;
• temp=a;
• a=b;
• b=temp;
• }
• int main( )
• {int i=3,j=5;
• swap(i,j);
• cout<<"i="<<i<<" "<<"j="<<j<<endl;
• return 0;
• }
C++调用函数时有两种传递数据的方式
• 1、传值方式调用
• 2、引用方式调用
• 对比例1.12与例1.11,分析使用引用和使用指针变量用函数形参有什么不同?
• C++提供的引用机制是非常有用的,特别用作函数参数时,比用指针简朴,易于理解,并且可以减少犯错机会,提高程序的执行效率,在许多情况下能代替指针.
5. 对引用的进一步说明
1.3.8内置函数
• 调用函数需要一定的时间,假如有的函数需要频繁使用,则累计所用时间会很长,从而减少程序的执行效率.C++提供一种提高效率的方法,在编译时将所调用函数的代码嵌入到主函数中.
• 例1.13
• #include <iostream>
• using namespace std;
• inline int max(int a,int b,int c) //这是一个内置函数，求3个整数中的最大者
• {if (b>a) a=b;
• if (c>a) a=c;
• return a;
• }
• int main( )
• {int i=7,j=10,k=25,m;
• m=max(i,j,k);
• cout<<"max="<<m<<endl;
• return 0;
• }
• 使用内置函数可以节省运营时间,但却增长了目的程序的长度.因此只用于规模很小而使用频繁的函数.
1.3.9作用域运算符
• 每一个变量都有其有效的作用域,只能在变量的作用域内使用该变量,不能直接使用其它作用域中的变量.
• 例子1.16 局部变量和全局变量同名
• #include <iostream>
• using namespace std;
• float a=13.5;
• int main( )
• {int a=5;
• cout<<a<<endl;//输出局部变量a的值
• cout<<::a<<endl;//输出全局变量a的值
• return 0;
• } //::a表达全局作用域中的变量,不能用::访问函数中的局部变量
1.3.10字符串变量
• 1. 定义字符串变量
• String string1;
• String string2=“China”;
• 将头文献”string”头文献包含进来
• 2. 对字符串变量的赋值
• String1=“’Camada”;
• String2=string1;
• 在定义字符串变量时不需指定长度,它的长度随其中的字符串长度而改变.
• 3. 字符串变量的输入输出
• Cin>>string1;
• Cout>>string2;
4. 字符串变量的运算
• 在用字符组存放字符串时,字符串的运算要用字符串函数.如strcat(存放),strcmp(比较),strcpy(复制),而对string类对象,可以不用这些函数,直接用简朴的运算符.
5. 字符串数组
• String name[5];//定义一字符串数组,它包含5个字符串元素
• String name[5]={“Zhang”,”Li”,”Fun”,”Wang”,”Tan”}//定义一个字符串数组并初始化
• 编译系统为每一个字符串变量分派固定的字节数,在这个存储单元中,并不是直接存放字符串自身,而是存放字符串的地址.
例子1.17 输入3个字符串,规定按字母由小到大顺序输出
• #include <iostream>
• #include <string>
• using namespace std;
• int main()
• {string string1,string2,string3,temp;
• cout<<"please input three strings:"; //这是对用户输入的提醒
• cin>>string1>>string2>>string3; //输入3个字符串
• if(string2>string3) {temp=string2;string2=string3;string3=temp;} //使串2≤串3
• if(string1<=string2) cout<<string1<<" "<<string2<<" "<<string3<<endl;
• //假如串1≤串2，则串1≤串2≤串3
• else if(string1<=string3) cout<<string2<<" "<<string1<<" "<<string3<<endl;
• //假如串1＞串2，且串1≤串3，则串2＜串1≤串3
• else cout<<string2<<" "<<string3<<" "<<string1<<endl;
• //假如串1＞串2，且串1＞串3，则串2≤串3＜串3
• return 0;
• }

2－5动态内存分派/撤消——new和delete运算符
1.3.11动态分派/撤消内存的运算符new和delete
• New int;//开辟一个存放整数的空间,返回一个指向整型数据的指针
• New int(100);//开辟一个存放整数的空间,并指定该整数的初值为100
• New char[10];//开辟一个存放字符数组的空间,该数组有10个元素,返回一个指向字符数组的指针
• New int[5][4];//开辟一个存放二维整型数组的空间,该数组大小为5*4,
• Float *p=new float(3.14159)//开辟一个存放实数的空间,并指定该实数的初值为3.14159,将返回的指向实型数据的指针赋给指针变量p
例子1.18 开辟空间以存放一个结构体变量.
• #include <iostream>
• #include <string.h>
• using namespace std;
• struct Student
• {char name [10];
• int num;
• char sex;
• };
• int main ( )
• {Student *p;
• p=new Student;
• strcpy(p->name,"Wang Fun");
• p->num=10123;
• p->sex='M';
• cout<<p->name<<" "<<p->num<<" "<<p->sex<<endl;
• delete p;
• return 0;
• }
• 假如由于内存局限性等因素而无法正常分派空间,则new会返回一个空指针NULL,用户可以根据该指针的值判断分派空间是否成功.
• 注意, new和delete是运算符,不是函数,因此执行效率高. new和delete配合使用,不要混合使用.

3.C++程序的编写和实现
在课中通过截图和示意图来演示。

六、作业

第2章 类和对象
一、教学目的：
掌握声明类的方法，类和类的成员的概念以及定义对象的方法；初步掌握用类和对象编制基于对象的程序；学习检查和调试基于对象的程序。
学时分派：9学时
二、教学重点：
初步掌握用类和对象编制基于对象的程序
三、教学难点：
初步掌握用类和对象编制基于对象的程序，学习检查和调试基于对象的程序。
四、教学方法：
课题讲授及实例演示，采用多媒体教学方法，运用Powerpoint将本节课的关键内容归类，并通过Internet收集相关的资料融入教学内容中。
五、教学过程设计：（9学时）
1.面向对象程序设计方法概述
2.1 面向对象程序设计方法概述
• 当程序规模较大时,编程者直接编写出一个面向过程的程序就会力不从心,C++就是为了解决编写大程序过程中的困难而产生的。
2.1.1 什么是面向对象程序设计
• 面向对象程序设计的思绪和人们平常生活中解决问题的思绪是相似的。
• 在自然界和社会生活中,一个复杂的事物总是由许多部分组成的,各部分之间有一定的联系,协调发挥功用。

相关概念
• 1.对象
• 客观世界中任何一个事物都可以当作一个对象(object)。或者说,客观世界是由千千万万个对象组成的。
• 对象是构成系统的基本单位。
• 班级对象：
• 班级的静态特性，所属的系和专业、班级的人数，所在的教室等。这种静态特性称为属性；
• 班级的动态特性，如学习、开会、体育比赛等，这种动态特性称为行为。
• 假如想从外部控制班级中学生的活动，可以从外界向班级发一个信息（如听到打铃就下课等），一般称它为消息。
• 任何一个对象都应当具有这两个要素，一是属性(attribute)；二是行为(behavior)，它能根据外界给的信息进行相应的操作。对象是由一组属性和一组行为构成的。
• 面向对象的程序设计采用了以上人们所熟悉的这种思绪。使用面向对象的程序设计方法设计一个复杂的软件系统时，首要的问题是拟定该系统是由哪些对象组成的，并且设计这些对象。在C++中，每个对象都是由数据和函数(即操作代码)这两部分组成的。 调用对象中的函数就是向该对象传送一个消息(message)，规定该对象实现某一行为（功能）。
• 2、封装与信息隐蔽
• 我们可以对一个对象进行封装解决，把它的一部分属性和功能对外界屏蔽，也就是说从外界是看不到的、甚至是不可知的。
• 使用对象的人完全可以不必知道对象内部的具体细节，只需了解其外部功能即可自如地操作对象。
• 把对象的内部实现和外部行为分隔开来。
• 数据封装将对象内部的信息进行屏蔽，人们只能通过对象界面上的允许操作对对象进行动作，改变对象的属性及状态。
• 信息隐蔽是指对象中的某些部分对外隐蔽，即隐蔽其内部细节，只留下少量接口，以便与外界联系，接受外界消息。它尚有助于数据安全，防止无关的人了解和修改数据。
• C++的对象中的函数名就是对象对外接口。
3、抽象
• 抽象的过程是将有关事物的共性归纳、集中的过程。
• 抽象的作用是表达同一类事物的本质。
• 对象是具体存在的。类是对象的抽象，而对象则是类的实例，或者说是类的具体表现形式。
类
• 类是一组具有相同数据结构和相同操作的对象的集合。
• 类的定义涉及一组数据属性和在数据上的一组合法操作。
• 类定义可以视为一个具有类似特性与共同行为的对象的模板，可用来产生对象。
对象实例
• 在一个类中，每个对象都是类的实例 (Instance)，它们都可使用类中提供的函数。
• 对象的状态则包含在它的实例变量，即实例的属性中。
4、继承与重用
面向对象的程序组成：
对象 = 算法 ＋ 数据结构
程序=(对象+对象+对象+……)+ 消息
消息的作用就是对对象的控制。
程序设计的关键是设计好每一个对象以及拟定向这些对象发出的命令，使各对象完毕相应的操作。
1－1什么是面向对象程序设计及特点
1－2类和对象的作用
2.类和对象
2－1类的定义
类的声明格式：
class 类名
{ private :
成员数据;
成员函数；
public :
成员数据;
成员函数；
protected:
成员数据;
成员函数；
};
用关键字private限定的成员称为私有成员，对私有成员限定在该类的内部使用，即只允许该类中的成员函数使用私有的成员数据，对于私有的成员函数，只能被该类内的成员函数调用；类就相称于私有成员的作用域。
而用关键字protected所限定的成员称为受保护成员，只允许在类内及该类的派生类中使用受保护的数据或函数。即受保护成员的作用域是该类及该类的派生类。
用关键字public限定的成员称为公用成员，公用成员的数据或函数不受类的限制，可以在类内或类外自由使用；对类而言是透明的。
每一个限制词(private等)在类体中可使用多次，即一个类体中可以包含多个private和public部分。一旦使用了限制词，该限制词一直有效，直到下一个限制词开始为止。
但为了程序清楚，养成这样的习惯：使每一种成员访问限定符在类定义体中只出现一次。
假如未加说明，类中成员默认的访问权限是private，即私有的。
class Student
{ char Name[20];
float Math;
float Chiese;
public :
float average;
void SetName(char *name);
void SetMath(float math);
void SetChinese(float ch);
float GetAverage(void);
};
class A
{ float x, y;
public:
void Setxy(float a,float b)
{ x=a; y=b; }
void Print(void)
{ cout<<x<<‘\t’<<y<<endl; }
};
在类外不能直接使用 x 或 y ，必须通过Setxy()给 x 或 y 赋值，通过Print()输出 x 或 y 。
成员函数与成员数据的定义不分先后，可以先说明函数原型，再在类体外定义函数体。
class A
{ float x, y;
public:
void Setxy(float a,float b)
{ x=a; y=b; }
void Print(void)
{ cout<<x<<‘\t’<<y<<endl; }
};
class A
{ float x, y;
public:
void Setxy(float a,float b)；
void Print(void)；
};
void A::Setxy(float a,float b)
{ x=a; y=b; }
void A::Print(void)
{ cout<<x<<‘\t’<<y<<endl; }
在定义一个类时，要注意如下几点：
1、类具有封装性，并且类只是定义了一种结构（样板），所以类中的任何成员数据均不能使用关键字extern，auto或register限定其存储类型。
2、在定义类时，只是定义了一种导出的数据类型，并不为类分派存储空间，所以，在定义类中的数据成员时，不能对其初始化。如：
class Test { int x=5,y=6; //是不允许的
extern float x; //是不允许的
}
在C++语言中，结构体类型只是类的一个特例。结构体类型与类的唯一的区别在于：在类中，其成员的缺省的存取权限是私有的；而在结构体类型中，其成员的缺省的存取权限是公有的。
内联成员函数
对象
在定义类时，只是定义了一种数据类型，即说明程序中也许会出现该类型的数据，并不为类分派存储空间。
只有在定义了属于类的变量后，系统才会为类的变量分派空间。
类的变量我们称之为对象。

2－2成员函数：成员函数定义；使用对象指针；常成员函数；重载成员函数

对象是类的实例，定义对象之前，一定要先说明该对象的类。
不同对象占据内存中的不同区域，它们所保存的数据各不相同，但对成员数据进行操作的成员函数的程序代码均是同样的。
在建立对象时，只为对象分派用于保存数据成员的内存空间，而成员函数的代码为该类的每一个对象所共享。
对象的定义方法同结构体定义变量的方法同样，也分三种，当类中有数据成员的访问权限为私有时，不允许对对象进行初始化。
class A {
float x,y;
public:
void Setxy( float a, float b ){ x=a; y=b; }
void Print(void) { cout<<x<<‘\t’<<y<<endl; }
} a1,a2;
void main(void)
{ A a3,a4;
}
对象的使用
一个对象的成员就是该对象的类所定义的成员，有成员数据和成员函数，引用时同结构体变量类似，用“.”运算符。
class A