第2章-C++类和对象

第2章类和对象

面向对象的编程思想类的实现类的使用this指针static关键字1、结构化的编程思想

在计算机发展的初期，编写软件的主要目的是控制计算机以实现人们想要实现的功能。在这一阶段，人们主要是采用功能分解的指导思想。所谓的功能分解，就是将大的功能模块分解成比较小的功能模块，然后再将较小的功能模块分解成更小的功能模块。

按这一思路，分解到每一小功能模块可以采用一个函数实现为止。一、面向对象的编程思想

模块之间的分解关系，在编程实现时体现为函数之间的调用关系。因此，在学习C语言的过程中，大家重点是要掌握函数相关的知识。2、面向对象的编程思想计算机发展到一定阶段后，编写软件的为模拟实现世界，即将现实生活中的某些现象或场景在计算机中模拟出来。

例如，现实生活中的商店购物过程对应于互联网的天猫店购物，赛车活动对应于计算机中的赛车游戏等。在计算机中所模拟场景的逼真程度，取决于我们对现实世界的认识程度。

面临的问题：

怎样有效地认识现实世界的现象或场景？

唯物辩证法认为：世界是由物质所组成的，并且物质之间存在普遍联系。

何为物质？物质是指自然界客观存在的事物，它不以人们的意识为转移，即不管人们是否看到或意识到某一物质，它都真实存在于自然界。物质---->实体---->对象将唯物辩证法引入到软件工程领域中，就形成了面向对象的系统分析：被模拟世界是由对象所组成的，对象之间存在普遍联系。具体应用时，我们可以对这句话进行深入分解，作为我们认识现实世界的指导方针。“被模拟世界是由对象所组成的”可以被分解成三个层次：1、所模拟世界是由哪些对象所组成的？据此，我们可以分析出所有的研究对象。2、每一个对象有哪些状态？3、每一个对象有哪些行为？通过这两步的分析，我们可以深入认识每一个研究对象的具体内容。“对象之间存在普遍联系”也可以被分解成：4、对象之间是否存在组合关系？比如结构上、空间上或逻辑上存在整体与部分的关系。5、对象之间是否满足现实生活中的分类常识？比如存在一般与特殊的关系或同属于一大类下的不同子类。6、对象之间是否存在依赖关系，以实现不同对象之间的协作？利用这种面向对象的思维方式，可以让我们有计划、有步骤地分析现实世界。针对日常的教学活动(极端简化版)，可以分析很多对象：张三、侯俊杰、C语言、李四、谭浩强、C++语言，…。针对大量的对象，怎样进行有效的描述或交流？归纳、总结，进行分类处理3、由对象抽象出类通过分类处理，可以发现这些对象都归属于学生、教师和课程三种类型之一。好处：不需要面对千千万万个内容各异的具体对象，只需要将精力集中在每种类型的共性方面，方便交流。怎样描述同一类型的数据？C++类中有什么内容？C语言：数据类型、结构体------->C++:类类是什么？在C++语言中，类是一种自定义的数据类型，用来描述同一类对象的属性与行为。对象状态行为类成员变量成员函数数据代码4、对象与类的关系先由现实世界中的对象抽象出类，然后在计算机世界中依据类实例化出相应的对象。5、面向对象编程思想的主要特征1、抽象是对具体对象（问题）进行概括，抽出这一类对象的公共性质并加以描述的过程。=>是指由系统分析所得的各种具体对象，归纳出描述性的类。2、封装是将抽象出的数据成员、代码成员相结合，将它们视为一个整体。=>是指利用this指针，将对象的成员函数与成员变量关联起来。3、继承是C++中支持层次分类的一种机制，允许程序员在保持原有类特性的基础上，进行更具体的说明。=>是指利用分类学的原理，优化类的层次结构关系，提高代码的重用率。4、多态性是同一名称，不同的功能实现方式。具有重载函数和虚函数两种实现方式。=>虚函数是构架大型框架与平台的基础，是底层框架与上层应用的关联点。下列术语中，能表明面向对象思想主要特征的是（）。封装性灵活性安全性可靠性ABCD提交单选题1分下列关于类的叙述中，错误的是（）。类是一种抽象数据类型类是面向对象程序设计的核心类与类之间不能形成层次结构类可以实现对数据的封装和隐藏ABCD提交可为此题添加文本、图片、公式等解析，且需将内容全部放在本区域内。正常使用需3.0以上版本类设计之初，就是为了体现面向对象的思想，将有相似属性和行为的实体抽象为一个类，包含这一类实体的共有属性和行为，选项A、B正确。类的三大特性：封装性、继承性、多态性，选项D正确。类的继承属性就能使类形成层次结构，故C选项错误，故答案为C选项。答案解析答案解析单选题1分下面关于类和对象说法不正确是（）。类由数据与函数组成一个对象必属于某个类对象是类的实例一个类的对象只有一个ABCD提交单选题1分类是一种复杂的数据类型，它是将不同类型的数据和与这些数据相关的运算封装在一起的集合体。1、类的定义类将一些数据及与数据相关的函数封装在一起，使类中的数据得到很好的“保护”。在大型程序中不会被随意修改。二、类的实现类的定义格式：class类名{private:

成员变量;

成员函数；

public:

成员变量;

成员函数；};关键字类名私有公有classStudent{private:charName[20];floatMath;floatChiese;

public:floataverage;

voidSetName(char*name);voidSetMath(floatmath);voidSetChinese(floatch);floatGetAverage(void);};分号不能少用关键字priviate限定的成员称为私有成员对私有成员限定在该类的内部使用私有成员变量只能被该类内的成员函数调用私有成员函数只能被该类内的成员函数调用类就相当于私有成员的作用域。用关键字public限定的成员称为公有成员，公有成员变量或函数不受类的限制，可以在类内或类外自由使用。对类而言是透明的。私有变量公有变量类内函数可以访问可以访问类外函数不可访问可以访问私有函数公有函数类内函数可以调用可以调用类外函数不可调用可以调用类外类里每一个限制词(private等)在类体中可使用多次。一旦使用了限制词，该限制词一直有效，直到下一个限制词开始为止。如果未加说明，类中成员默认的访问权限是private，即私有的。classStudent{ charName[20]; floatMath; floatChiese;

public: floataverage;voidSetName(char*name); voidSetMath(floatmath); voidSetChinese(floatch); floatGetAverage(void);};均为私有权限均为公有权限16.若有如下类定义classFruit{charname[20];public:voidPrint();private:doubleprice;};则下列叙述中，正确的是（）。类中有1个公有数据成员类中有1个私有数据成员类中有2个私有数据成员数据成员name的访问权限未知ABCD提交单选题1分classA{floatx,y;public:

voidSetxy(floata,floatb){x=a;y=b;}voidPrint(void){cout<<x<<‘\t’<<y<<endl;}}; xySetxy()Print()A私有数据公有函数在类外不能直接使用x或y，必须通过Setxy()给x或y赋值，通过Print()输出x或y。成员函数与成员数据的定义不分先后，可以先说明函数原型，再在类体外定义函数体。classA{floatx,y;public:

voidSetxy(floata,floatb){x=a;y=b;}voidPrint(void){cout<<x<<‘\t’<<y<<endl;}}; 在类体内定义成员函数classA{floatx,y;public:

voidSetxy(floata,floatb)；

voidPrint(void)；};

voidA::Setxy(floata,floatb){x=a;y=b;}voidA::Print(void){cout<<x<<‘\t’<<y<<endl;}在类体内说明成员函数原型在类体外定义成员函数，需要使用作用域运算符有如下类定义：

classCup{public:voidSetPrice(doubleval);private:doubleprice;};若要在类体外给出对成员函数SetPrice的定义，下列选项中正确的是（）。voidCup::SetPrice(doubleval){price=val;}voidCup.SetPrice(doubleval){price=val;}voidSetPrice(doubleval){Cup::price=val;}voidSetPrice(doubleval){Cup.price=val;}ABCD提交单选题1分在定义一个类时，要注意如下几点：1、类具有封装性，并且类只是定义了一种结构（样板），所以类中的任何成员数据均不能使用关键字extern，auto或register限定其存储类型。2、在定义类时，只是定义了一种导出的数据类型，并不为类分配存储空间，所以，在定义类中的数据成员时，不能对其初始化。如：classTest{intx=5,y=6;//是不允许的

externfloatx; //是不允许的};在C++语言中，结构体类型只是类的一个特例。结构体类型与类的唯一的区别在于：在类中，其成员的缺省的存取权限是私有的；而在结构体类型中，其成员的缺省的存取权限是公有的。2、内联成员函数当我们定义一个类时，可以在类中直接定义函数体。这时成员函数在编译时是作为内联函数来实现的。注意：一定是内联函数！同时，我们也可以在类体外定义类的内联成员函数，在类体内说明函数，在类体外定义时，在成员函数的定义前面加上关键字inline。classA{floatx,y;public:voidSetxy(floata,floatb)；

voidPrint(void)；}; inlinevoidA::Setxy(floata,floatb){x=a;y=b;}inlinevoidA::Print(void){cout<<x<<‘\t’<<y<<endl;}说明该成员函数为内联3、成员函数的重载类中的成员函数与前面介绍的普通函数一样，成员函数可以带有缺省的参数，也可以重载成员函数。重载时，函数的形参必须在类型或数目上不同。classTest{ intx,y; intm,n;public:

voidSetxy(inta,intb){x=a; y=b;}

voidSetxy(inta,intb,intc,intd){x=a;y=b;m=c;n=d;}

voidPrintxy(intx){cout<<“m="<<m<<'\t'<<“n="<<n<<endl;}voidPrintxy(void){cout<<"x="<<x<<'\t'<<"y="<<y<<endl;}};voidmain(void){ Testp1,p2;

p1.Setxy(3,5);p2.Setxy(10,20,30,40);//参数不同

p1.Printxy();

p2.Printxy();p2.Printxy(2);//参数、类型不同}输出：x=3y=5x=10y=20m=30n=404、缺省参数的成员函数classA{floatx,y;public:floatSum(void){returnx+y;}

voidSet(floata,floatb=10.0){x=a; y=b;}voidPrint(void){ cout<<"x="<<x<<'\t'<<"y="<<y<<endl;}};voidmain(void){ Aa1,a2;

a1.Set(2.0,4.0); cout<<"a1:"; a1.Print(); cout<<"a1.sum="<<a1.Sum()<<endl;

a2.Set(20.0); cout<<"a2:"; a2.Print(); cout<<"a2.sum="<<a2.Sum()<<endl;}不缺省参数，a1.x=2,a1.y=4缺省参数，a2.x=20,a2.y=10下列关于类成员函数特性的叙述中，错误的是（）。成员函数可以递归成员函数可以重载成员函数都是内联函数成员函数可以设置默认参数值ABCD提交单选题1分1、创建对象只有在定义了属于类的变量后，系统才会为类的变量分配空间。在定义类时，只是定义了一种数据类型，即说明程序中可能会出现该类型的数据，并不为类分配存储空间。类的变量我们称之为对象。对象是类的实例，定义对象之前，一定要先说明该对象的类。三、类的使用不同对象占据内存中的不同区域，它们所保存的数据各不相同，但对成员数据进行操作的成员函数的程序代码均是一样的。类名对象1，对象2《,......》；Studentst1，st2；对象的定义格式：类名对象名在建立对象时，只为对象分配用于保存数据成员的内存空间，而成员函数的代码为该类的每一个对象所共享。classA{floatx,y;public:voidSetxy(floata,floatb){x=a;y=b;}voidPrint(void){cout<<x<<‘\t’<<y<<endl;}};Aa1,a2;voidmain(void){Aa3,a4;}定义全局对象定义局部对象成员变量全局变量局部变量2、对象的使用一个对象的成员就是该对象的类所定义的成员，有成员变量和成员函数，引用时同结构体变量类似，用“.”运算符。classA{floatx,y;public:floatm,n;voidSetxy(floata,floatb){x=a;y=b;}voidPrint(void){cout<<x<<‘\t’<<y<<endl;}};voidmain(void){Aa1,a2;//定义对象

a1.m=10;a1.n=20;//为公有成员数据赋值

a1.Setxy(2.0,5.0);//为私有成员数据赋值

a1.Print();}a1nmyxa2nmyx10202.05.0输出：2 5在类外，用成员选择运算符“.”只能访问对象的公有成员，而不能访问对象的私有成员或保护成员。若要访问对象的私有的数据成员，只能通过对象的公有成员函数来获取。classA{floatx,y;public:floatm,n;

voidSetxy(floata,floatb){x=a;y=b;}voidPrint(void){cout<<x<<‘\t’<<y<<endl;}};voidmain(void){Aa1,a2;a1.m=10;a1.n=20; //为公有成员数据赋值

a1.x=2;a1.y=5;

a1.Setxy(2.0,5.0);

a1.Print();}必须通过类内公有函数访问私有数据成员非法，私有成员不能在类外访问同类型的对象之间可以整体赋值，这种赋值与对象的成员的访问权限无关。classA{floatx,y;public:floatm,n;voidSetxy(floata,floatb){x=a;y=b;}voidPrint(void){cout<<x<<‘\t’<<y<<endl;}};voidmain(void){Aa1,a2;a1.m=10;a1.n=20; //为公有成员数据赋值

a1.Setxy(2.0,5.0);

a2=a1;a1.Print();a2.Print();}同类型的对象之间可以整体赋值相当于成员变量间相互赋值对象可以作函数的入口参数（实参、形参），也可以作函数的出口参数。这与一般变量作为函数的参数是完全相同的。可以定义类类型的指针，类类型的引用，对象数组，指向类类型的指针数组和指向一维或多维数组的指针变量一个类的对象，可作为另一个类的成员类体的区域称为类作用域。类的成员函数与成员数据，其作用域都是属于类的作用域，仅在该类的范围内有效，故不能在主函数中直接通过函数名和成员名来调用函数。3、类作用域和对象的作用域对象的作用域与前面介绍的变量作用域完全相同,全局对象、局部对象、局部静态对象等。classA{floatx,y;public:floatm,n;voidSetxy(floata,floatb){x=a;y=b;}voidPrint(void){cout<<x<<‘\t’<<y<<endl;}};voidmain(void){Aa1,a2;a1.m=20;a1.n=10;

a1.Setxy(2.0,5.0);

a1.Print();}voidmain(void){Aa1,a2;

m=20;n=10;

Setxy(2.0,5.0);

Print();

}用对象名调用不能直接调用classA{floatx,y;public:floatm,n;voidSetxy(floata,floatb){x=a;y=b;}//成员函数voidPrint(void){cout<<x<<‘\t’<<y<<endl;}//成员函数};voidmain(void)//全局函数{Aa1,a2;a1.m=20;a1.n=10;

a1.Setxy(2.0,5.0);

a1.Print();}成员函数：局部变量-->成员变量-->全局变量全局函数：局部变量-->全局变量4、类的对象如何引用私有成员变量1)通过公有函数为私有成员赋值classTest{ intx,y;public:

voidSetxy(inta,intb){x=a; y=b;}voidPrintxy(void){cout<<"x="<<x<<'\t'<<"y="<<y<<endl;}};voidmain(void){ Testp1,p2;

p1.Setxy(3,5);

p1.Printxy();}调用公有函数为私有对象赋值2)利用函数访问私有数据成员classTest{intx,y;public:voidSetxy(inta,intb){x=a; y=b;}intGetx(void){returnx;}//返回x值

intGety(void){returny;}//返回y值

voidPrintxy(void){cout<<"x="<<x<<'\t'<<"y="<<y<<endl;}};voidmain(void){Testp1,p2;p1.Setxy(3,5);inta,b;

a=p1.Getx();b=p1.Gety();//将a=x,b=ycout<<a<<'\t'<<b<<endl;}函数值就是私有成员变量的值3)利用指针访问私有数据成员classTest{intx,y;public:voidSetxy(inta,intb){x=a; y=b;}

voidGetxy(int*px,int*py){*px=x;*py=y;}//提取x,y值

voidPrintxy(void){cout<<"x="<<x<<'\t'<<"y="<<y<<endl;}};voidmain(void){Testp1,p2;p1.Setxy(3,5);inta,b;p1.Getxy(&a,&b);//将a=x,b=ycout<<a<<'\t'<<b<<endl;}输出：3 54)利用引用访问私有数据成员classTest{ intx,y;public:voidSetxy(inta,intb){ x=a;y=b;}

voidGetxy(int&px,int&py){px=x; py=y; }//提取x,y值

voidPrintxy(void){cout<<"x="<<x<<'\t'<<"y="<<y<<endl;}};voidmain(void){Testp1,p2;p1.Setxy(3,5);inta,b;p1.Getxy(a,b);//将a=x,b=ycout<<a<<'\t'<<b<<endl;}输出：3 5类引用举例（三角形类：三角形的三边及与三边相关的运算）classTriangle{private: floata,b,c;//三边为私有成员数据public: voidSetabc(floatx,floaty,floatz);//置三边的值

voidGetabc(float&x,float&y,float&z);//取三边的值

floatPerimeter(void);//计算三角形的周长

floatArea(void);//计算三角形的面积

voidPrint(void);//打印相关信息};voidTriangle::Setabc(floatx,floaty,floatz){a=x;b=y;c=z;}//置三边的值voidTriangle::Getabc(float&x,float&y,float&z)//取三边的值

{x=a;y=b;z=c;}floatTriangle::Perimeter(void){return(a+b+c)/2;}//计算三角形的半周长floatTriangle::Area(void)//计算三角形的面积{floatarea，p;p=Perimeter();area=sqrt((p-a)*(p-b)*(p-c)*p);//海伦公式returnarea;}voidTriangle::Print(void)//打印相关信息{cout<<"Peri="<<Perimeter()<<'\t'<<"Area="<<Area()<<endl;}voidmain(void){ TriangleTri1; //定义三角形类的一个实例（对象）

Tri1.Setabc(4,5,6); //为三边置初值

floatx,y,z; Tri1.Getabc(x,y,z);//将三边的值为x,y,z赋值

cout<<x<<'\t'<<y<<'\t'<<z<<endl; cout<<“s=”<<Tri1.Perimeter()<<endl;//求三角形的周长

cout<<“Area=”<<Tri1.Area()<<endl;//求三角形的面积

cout<<"Tri1:"<<endl; Tri1.Print();//打印有关信息}类引用举例（学生类：学生的姓名成绩及相关的运算）classStudent{ charName[20]; //学生姓名

floatChinese; //语文成绩

floatMath; //数学成绩public:floatAverage(void);//计算平均成绩

floatSum(void); //计算总分

voidShow(void); //打印信息

voidSetStudent(char*,float,float);//为对象置姓名、成绩

voidSetName(char*); //为对象置姓名

char*GetName(void); //取得学生姓名};floatStudent::Average(void){return(Chinese+Math)/2;}//平均成绩floatStudent::Sum(void){returnChinese+Math;}//总分voidStudent::Show(void) //打印信息{cout<<"Name:"<<Name<<endl<<"Score:"<<Chinese<<'\t'<<Math<<'\t'<<"average:"<<Average()<<'\t'<<"Sum:"<<Sum()<<endl;}voidStudent::SetStudent(char*name,floatchinese,floatmath){ strcpy(Name,name); //置姓名

Chinese=chinese; //置语文成绩

Math=math; //置数学成绩}char*Student::GetName(void){returnName;}//返回姓名voidmain(void){ Studentp1,p2;p1.SetStudent(“Liqing”,98,96);//对象置初值p2.SetStudent("WangGang",90,88);//对象置初值p1.Show();//打印信息p2.Show();//打印信息p1.SetName(“Zhaojian”);//重新置p1对象的名字p1.Show();cout<<“p1.Name:”<<p1.GetName()<<endl;//打印对象的名字cout<<“p1.average:”<<p1.Average()<<endl;//打印对象的成绩}575、定义类的指针及如何用指针来引用对象classA{ floatx,y;public: floatSum(void){returnx+y;} voidSet(floata,floatb){x=a; y=b;}voidPrint(void){ cout<<"x="<<x<<'\t'<<"y="<<y<<endl;}};voidmain(void){Aa1,a2;A*p; //定义类的指针

p=&a1; //给指针赋值

p->Set(2.0,3.0);//通过指针引用对象的成员函数

p->Print();cout<<p->Sum()<<endl;a2.Set(10.0,20.0);a2.Print();}xy2.03.0pa1定义类的数组及数组中元素的引用voidmain(void){

Stustu[3]; //定义类的数组

Stu*pstu; //定义类的指针

pstu=stu; //为指针赋值

inti;

stu[0].SetStudent(“A”,90,90);//通过数组元素的引用赋值

stu[1].SetStudent("B",80,80); stu[2].SetStudent("C",70,70); for(i=0;i<3;i++) {

pstu->Show();//指针变量指向数组元素

pstu++; //指针变量加一，指向下一元素

}}stupstupstu四、this指针不同对象占据内存中的不同区域，它们所保存的数据各不相同，但对成员变量进行操作的成员函数的程序代码均是一样的。classA{intx,y;public:voidSetxy(inta,intb){x=a;y=b;}};Aa1,a2;1a1.x2a1.y3a2.x4a2.y......x=a;y=b;......a1.Setxy()a2.Setxy()a1.Setxy(1,2);a2.Setxy(3,4);this->x=a;this->y=b;系统自动将对象的指针带到成员函数中当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，也隐含使用this指针。this指针具有如下形式的缺省说明：

Student*constthis;类名即this指针里的地址是一个常量源代码：classA{intx,y;public:voidSetxy(inta,intb){x=a;y=b;}};Aa1;a1.Setxy(1,2);编译后的代码：classA{intx,y;public:voidSetxy(inta,intb,

A

*const

this){this->x=a;this->y=b;}};Aa1;a1.Setxy(1,2,&a1);由此可知，对对象的成员进行访问或调用时，都是依据对象来进行的：显式的形式：对象.成员或指针->成员隐式的形式：this->成员下列关于this指针的叙述中，错误的是（）。this指针只能在类的非静态成员函数中使用this指针存储着对象的地址this指针不需要显式定义在构造函数中不能使用this指针ABCD提交单选题1分什么是封装？怎样理解封装？在面向对象的编程语言中，一个对象的成员变量和成员函数是一个逻辑统一体。即这个对象的成员函数可以直接访问对象的成员变量或直接调用对象的成员函数。classA{intx,y;public:voidSetxy(inta,intb)//对象的成员函数{

x=a;

//成员函数直接访问成员变量

y=b;}};封装是通过成员函数中的this指针来实现。在编译过程中，编译器会自动为成员函数中的成员变量增加一个this指针，以实现对成员变量的访问。classA{intx,y;public:voidSetxy(inta,intb,

A

*const

this){this->x=a;

this->y=b;}};总结一句话：在面向对象的语言中，对象的成员要通过对象来访问！

通常，每当说明一个对象时，把该类中的有关成员数据拷贝到该对象中，即同一类的不同对象，其成员数据之间是互相独立的。因此，我们通常也称之为对象成员变量。classA{intx,y;public:voidSetxy(inta,intb){x=a;y=b;}};Aa1,a2;a1.xa1.ya2.xa2.y......x=a;y=b;......a1.Setxy()a2.Setxy()a1.Setxy(1,2);a2.Setxy(3,4);this->x=a;this->y=b;四、static关键字四、static关键字1、静态成员变量如果要在同一类的多个对象之间实现数据共享，则可使用该类的静态成员变量，即由同一类的所有对象共享该类的静态成员变量。这样的做法可避免使用全局变量所带来的危险。对象1…对象n同类型多个对象静态成员变量共享同一个静态在员变量概念在类中，用关键字static修饰的成员变量称为静态成员变量。classA{intx,y;staticintz;public:voidSetxy(inta,intb){x=a;y=b;}};Aa1,

a2;a1.xa1.ya2.xa2.yza1.za2.z不同对象，同一空间四、static关键字classCounter{

staticintcount; //用于表示已建立的对象数目

intobjnum; //用于表示对象序号public:Counter(){count++;//每建立一个对象就加一

objnum=count;//为当前对象序号赋值

}voidshow(){cout<<“objid："<<objnum<<"created"<<endl;cout<<“totally：“<<count<<"objects“<<endl;}};intCounter::count=0;//在类体之外进行初始化1、在成员变量前使用static关键字2、必须在类体之外进行初始化，此时要数据类型，但不要static关键字实现四、static关键字方式一：静态成员变量为类所有，因此可以通过类名来进行访问。形式为：

类名::静态成员变量cout<<Counter::count<<endl;方式二：静态成员变量为此类所有对象所共享，因此也可以是通过对象访问。形式为：

对象.静态成员变量voidshow(){cout<<“objid："<<objnum<<"created"<<endl;cout<<“totally：“<<count<<"objects“<<endl;}使用方式四、static关键字1、静态成员变量属于类，也可以说是属于此类的所有对象，而不是属于该类的某一个对象。静态成员变量的生命周期是整个程序，而其作用域是它被定义时所在的类。因此，也称为类成员。非静态成员变量的生命周期与其对象同在，而其作用域是它被定义时所在的类。因此，也称为对象成员。注意事项732、类的静态数据成员是静态分配存储空间的，而其它成员是动态分配存储空间的（全局变量除外）。对于对象成员变量，只有在程序执行期间遇到创建类对象的语句时，才为对象的所有成员依次分配存储空间，这种存储空间的分配是动态的；对于类成员变量，在编译时，就要为类的静态数据成员分配存储空间。因此，必须在实现文件中，对静态数据成员作一次且只能作一次定义性说明。classA{staticintx;//定义静态成员};intA::x=0;//必须对静态成员作一次定义性说明743、静态数据成员具有全局变量和局部变量的一些特性。静态数据成员与全局变量一样都是静态分配存储空间的。全局变量在程序中的任何位置都可以访问它，而静态数据成员受到访问权限的约束。必须是public权限时，才可能在类外进行访问。2、静态成员函数可以将成员函数定义为静态的成员函数，即使用关键字static来修饰成员函数。classA{floatx,y;public:A(){}staticvoidsum(void){.....}};在类内定义静态成员函数76classTc{private:intA;

staticintB;//静态数据成员public:Tc(inta){A=a;B+=a;}

staticvoiddisplay(Tcc)；//Tc的对象为形参};voidTc::display(Tcc)//不用static修饰{cout<<"A="<<c.A<<",B="<<B<<endl;}1、在类内声明静态成员函数2、在类外实现静态成员函数，不需要使用static关键字77对静态成员函数的