第01讲　对象成员的初始化、静态成员、友元函数　　

5.1 对象成员的初始化

　　类的定义：
　　
　　
　　
　　
　　示例【5.1】
　　double 变成了其他类

5.2 静态成员

　　成员定义时使用了static关键字
　　1.静态成员变量的初始化只能在类外进行。
　　2.类中的任何成员函数都可访问静态成员变量。
　　3.访问静态成员时，一般加上类名限定。
　　4.静态成员变量是类的成员,不是对象的成员。
　　5.对象未建立之前静态成员已经存在。
　　6.静态成员没有this指针，除非使用引用方式否则不能存取类的成员。
　　5.2静态成员—-静态对象
　　
　　

5.3 友元函数

　　可以实现两个类之间无限制的存取另一个类的成员。
　　友元函数可以访问私有成员，公有成员和保护成员。友元函数可以是一个类或函数。友元需通过对象来使用类的成员。
　　友元的三种形式：
　　1，普通函数作一个类的友元
　　2，a类的成员函数作b类的友元
　　3，a类作为b类的友元

1，普通函数作一个类的友元 例5.4

2，a类的成员函数作b类的友元

3，a类作b类的友元

　　
　　总结：友元函数
　　可以实现两个类之间无限制的存取另一个类的成员。
　　友元函数可以访问私有成员，公有成员和保护成员。友元函数可以是一个类或函数。友元需通过对象来使用类的成员。
　　友元的三种形式：
　　1，普通函数作一个类的友元
　　2，a类的成员函数作b类的友元
　　3，a类作为b类的友元

第02讲　const对象、数组和类、指向类成员函数的指针　　

5.4 const对象

　　const可限定变量、指针、对象、函数、数据成员、成员函数。表示不可改变。
　　1,const成员 2,const对象 3,const函数

1,const成员 区别于const变量

　　const变量定义时需要初始化。
　　const成员在构造函数中初始化
　　（初始化列表形式）
　　
　　

2,const引用作参数

3,const对象和const函数

　　const 对象只能调用const成员函数
　　const 函数中不允许使用改变变量或成员值的语句
　　
　　复习上节
　　对象初始化：构造函数两种定义形式。
　　　　　　　　const限定的数据成员
　　　　　　　　引用数据成员
　　静态成员：静态数据成员，静态成员函数
　　友元：普通函数做友元
　　　　　类的成员函数做友元
　　　　　类做友元
　　const成员：const数据成员（const引用）
　　　　　　　 const成员函数
　　　　　　　 const对象
　　类的对象数组：对象数组中的每个元素都是一个对象。
　　对象数组元素的使用同普通对象使用。
　　对象的指针： 指向对象的指针使用对象的成员函数和数据成员。
　　对象指针数组：数组中每个元素都是一个指向对象的指针。
　　指向函数的指针：函数有地址，指针能存地址，指针可以指向函数。

5.5 数组和类

　　类可定义对象数组。
　　int a[5]； int a[5]={1,2,3,4,5}；
　　point p[3]；
　　point p[3]={point（1,2）,
　　　　　　　　point（3,4）,
　　　　　　　　point（5,6）}
　　定义数组时未初始化调用point（）形式构造函数
　　定义数组并初始化调用point（a,b）形式构造函数
　　使用数组中的元素时利用：point[i]形式
　　Point[i]的使用同普通对象使用方式相同
　　类可定义对象数组，可定义指向对象的指针
　　数组名是数组在内存中的首地址
　　指针可以存放地址
　　可用指针指向数组
　　通过指针可以使用对象成员p->show（）
　　通过指针可以使用对象数组元素的成员
　　P＝a；a[0].show（）; p->show（）;
　　定义对象的指针数组
　　int p;表示定义一个指针变量
　　int p[5]；表示定义一个数组。
　　int p[5] 表示定义一个数组中有5个元素，每个元素是一个指针。
　　此类数组称为指针数组。
　　point p;
　　p=new point;
　　p=new point（1,2）;
　　point p[3];
　　p[0]=new point（1,2）;
　　p[1]=new point（3,4）;
　　p[2]=new point（5,6）;
　　通过p[0]使用p[0]指向的对象。
　　p[0]->show（）;
　　可通过循环使用p[i]指向的对象。
　　定义指向对象的指针数组，并初始化。
　　point *p[3]={new point（1,2）,
　　　　　　　　 new point（3,4）,
　　　　　　　　 new point（5,6）};

5.6 指向类成员函数的指针

　　函数被调用时需要调入内存
　　函数有地址：存放函数的内存单元的首地址
　　指针可以存放地址
　　存放函数地址的指针称为指向函数的指针
　　定义形式：类型 （指针名）（参数类型）;
　　int max（int a,int b）
　　{return a>b?a:b;}
　　void main（）
　　{
　　　int （p）（int ,int ）;
　　　p=max;
　　　（p）（1,2）;
　　}
　　若max函数是某类A的成员函数则：
　　int A :: max（int a,int b）
　　{return a>b?a:b;}
　　void main（）
　　{
　　　int （A :: p）（int ,int ）;
　　　A a;
　　　p=A :: max;
　　　a.（*p）（1,2）;
　　}

第03讲　求解一元二次方程　　

5.7 求解一元二次方程

　　利用C＋＋实现
　　设计类，定义类，
　　定义main函数
　　定义对象，
　　利用对象调用成员函数
　　执行
　　设计类
　　类的对象中应能存放相关数据：具有数据成员
　　a,b,c一元二次方程的三个系数
　　x1，x2存放求得的方程解
　　delta存放bb-4a*c
　　类的对象应能完成计算功能：具有成员函数
　　1，将数据存入数据成员的函数
　　2，显示结果的函数
　　3，计算x1，x2的函数
　　定义类
　　
　　设计类
　　定义类的成员函数
　　
　　
　　main函数
　　
　　
　　
　　
　　

第五章复习

　　构造函数定义：
　　class A
　　{ int a
　　public:
　　A（int x）:a（x）{}
　　A（int x）{a=x;}
　　}
　　const限定的数据成员和引用数据成员初始化必须使用初始化列表形式。
　　const限定的数据成员初始化必须用？形式？
　　还有什么数据成员必须用此种形式初始化？？
　　静态成员 不依赖于对象而存在。
　　静态数据成员：定义时加static
　　静态成员必须初始化
　　使用语句：int A::b=0;
　　静态对象：
　　static对象一旦定义存在于内存中，直到程序结束才释放内存。
　　静态成员使用注意：
　　非静态对象　　　静态成员　　　可否使用？
　　静态对象　　　　静态成员　　　可否使用？
　　静态对象　　　　非静态成员　　可否使用？
　　静态成员函数　　非静态成员　　可否使用？
　　非静态成员函数　静态成员　　　可否使用？
　　其他注意事项： p108 1-7
　　静态函数没有this指针
　　不能声明为virtual函数
　　友元
　　普通函数作友元
　　类的成员函数作友元
　　类作友元
　　类A的友元（函数，成员函数，类）可以访问类A中的所有成员，但必须通过对象或引用来访问。
　　友元应在类A中利用friend声明
　　const对象
　　const数据成员
　　const成员函数
　　const指针
　　const变量
　　const引用
　　加const限定后不可改变，任何企图改变都导致错误，并应注意他们的初始化！！
　　使用规则：
　　const对象 不能调用任何非const成员函数
　　const成员函数只能调用const成员函数
　　非const对象可以调用const成员函数
　　非const对象可以使用const数据成员
　　const成员函数中不能使用任何试图改变变量值的语句。
　　数组和类
　　类可以定义对象
　　类可以定义对象数组
　　对象数组中的每个元素都是对象，其使用方式和对象的使用方式相同。
　　对象数组名表示数组的首地址
　　可以定义指向对象的指针p使其指向某个对象
　　可以用指针p指向数组中的元素
　　对象的指针数组使用
　　函数指针定义形式：
　　int （p）（int，int）；
　　int （A：：P）（int，int）；
　　int max（int a，int b）{ }
　　int A：：max（int a，int b）{ }
　　习题五-1
　　
　　
　　
　　
　　
　　
　　
　　
　　习题五-4