目录
1 类的公有数据的保护
举例说明：定义一个类
Class Time
{
public:
const int m_hour; //const数据成员
int m_min;
int m_sec;
Time(int hour, int min, int sec);
void set_hour(int hour);
int get_hour() const; //const成员函数
};
const Time t1(12, 20, 50); //const对象
1.1 const数据成员
const数据成员不可修改，即在成员函数中不能修改这个数据成员的值。不能作为左值使用。
void Time::set_hour(int hour)
{
m_hour = hour; //严重错误
}必须使用初始化列表的形式对const数据成员进行初始化，不能在构造函数体里进行赋值的动作。
Time::Time(int hour, int min, int sec)
{
m_hour = hour; //严重错误
m_min = min;
m_sec = sec;
};
Time::Time(int hour,int min, int sec):m_hour(hour)
{
m_min = min;
m_sec = sec;
}1.2 const成员函数
int Time::get_hour() const
{
return m_hour;
}（1）const改变了this的类型，变为指向const对象的指针。不能修改调用该函数的对象，即只能使用对象的数据成员,不能修改这些数据成员。
int Time::get_hour(const Time* const this) const（2）任何不修改数据成员的函数都应该声明为const成员函数。
（3）在声明和定义的时候都必须加const,调用时不用加。
1.3 const对象
const Time t1(12, 20, 50);（1）对象t1中所有的数据成员的值都不能修改。
（2）只能调用类的const成员函数，并且在const成员函数里不能对数据成员进行修改。
（3）如果由于某种特殊需要一定要修改const对象中的某个数据成员，将其声明为mutable。
1.4 课堂练习
1.5 知识要点总结
（1） const数据成员在类的成员函数里都只能调用它，不能改变它。
（2） const成员函数里只能调用数据成员，不能改变它。
（3）对于任何不修改数据成员的函数都应该声明为const成员函数，提高程序可靠性。
（4）const对象只能调用const成员函数，不能调用非const成员函数。
2 指向const对象的指针和const指针
2.1 指向const对象的指针
const 类型名 *指针变量名。 //指针所指向的对象为常量
const Time *pt;
pt指向的是Time类的const对象，对象是常量，不能改变。
（1） 不允许吧一个const对象的地址赋值给一个指向非const对象的指针。
const double pi = 3.14;
double *p = π //非法
const double *cp = π //合法（2） 允许把非const对象的地址赋给指向const对象的指针。
double d = 3.14;
const double *p = &d; //合法
（3） 任何企图通过指针修改对象的值的行为都是非法的，指针一经定义，就不允许修改其所指向对象的值。
*p = 2.54; //非法
（4）但可以通过其他方法修改对象的值。
d = 2.56; //合法（5）指向const对象的指针常用于函数的形参，以确保传递给函数的实际对象在函数中不被修改。
void func(const int *p)
{
(*p)++; //非法
}（6）当形参为指向const对象的指针时，实参可以是const对象的地址，也可以是非const对象的地址。
const int a = 20;
func(&a); //合法
int b = 30;
func(&b); //合法2.2 const指针
类型名 * const 指针变量名
Time * const pt;
（1） 指针本身不能改变，不能再指向其它对象，在定义时就要初始化。
Time t1;
Time t2;
Time * const pt1 = &t1;
pt1 = &t2; //非法（2）const指针所指向的对象能否被修改，完全取决于该对象的类型，当指针指向一个非const对象时，可以通过指针来修改对象的值。
Time t1;
Time t2;
Time * const pt1 = &t1;
*pt1 = t2; //合法2.3 课堂练习
#include <iostream>
using namespace std;
int main()
{
//指向const对象的指针
int a = 5;
const int *ptr = NULL; //指针指向的对象是常量
ptr = &a; //左const右非const
int b = 10;
ptr = &b; //指针指向新的地址是可以的
cout << "*ptr:"<<*ptr << endl;
//*ptr = 100; //这样是错误的
//const指针
int c = 20;
int d = 10;
int *const ptr2 = &c; //指针为常量
ptr2 = &d; //错误
*ptr2 = 200;
cout << "c:"<< c << endl;
return 0;
}
3 const引用
3.1 知识要点
const引用是指向const对象的引用。
const类型名& 变量名；
（1）非const引用不能绑定const对象
const int ival = 1;
const int &rval = ival; //合法
int &rval2 = ival; //非法（2）非const引用只能绑定到与该引用同类型的对象。
const引用可以绑定到不同的但是相同的类型或者绑定到右值。
double dval = 1.2;
const double &rval = 2.5; //合法 绑定到右值
const int &rval2 = dval; //合法 不同的但相关的类型
int &rval3 = dval; =>int temp = dval; //临时变量替换
int &rval3 = temp;
非const引用不能绑定到编译器自动产生的临时对象。
（3）用引用作函数参数避免了时间空间的开销，不希望在函数中修改实参对象的值，则使用const引用作为函数形参。
void func(const int &r)
{
r++; //非法
}
4 静态成员
4.1 静态数据成员
（1）可以进行封装，静态成员可以是私有或者公有，全局对象则不可以。
（2）静态成员可以实现多个对象之间的数据共享，它与类相关联，而不是与类的对象相关联。
（3）静态数据成员可以节省内存，对于多个对象来说，静态数据成员只有一个，供所有对象共用。
4.2 静态成员函数
class A{
public:
int m_data;
static int m_sdata;
A(int data=0):m_data(data){}
};
int A::m_sdata = 0;
int main()
{
A a;
a.m_sdata;
A::m_sdata;
}（1）静态数据成员可以是任意类型，const，引用，数组，类类型。
（2）静态数据成员必须在类定义体外部定义，且定义时必须初始化。
（3）类外引用时需要指定其所属的类名。
（4）只需在类定义体内指定static关键字，类外不需要标识static。
（5）可通过对象名或类名引用静态数据成员。
4.3 静态数据成员与非静态数据成员的区别
（1）静态数据成员不是类对象的组成部分，独立于任何对象而存在，即使不定义对象，也为static数据成员分配空间。
（2）静态数据成员在编译时分配空间，在程序结束之前释放空间。
（3）静态数据成员可以成为成员函数默认实参，而非静态数据成员则不可以。
（4）静态数据成员在const成员函数中可以被合法的改变，而非静态成员则不可以。
4.4 静态成员函数的定义
class A{
private:
int m_data;
static int m_sdata;
public:
A(int data=0):m_data(data){}
static int get_sdata();
};
int A::m_sdata = 0;
int A::get_sdata()
{
return m_sdata;
}(1) 静态成员函数的作用是处理静态数据成员。
(2) 在类外定义静态成员函数时，不需要加static关键字。
4.5 静态成员函数知识要点
（1） 静态成员函数不属于任何一个对象，因此没有隐含的this指针。这是它与非静态成员函数的根本区别。
（2）静态成员函数不能直接引用非静态成员。
（3）静态成员函数不能被声明为const函数。
（4）静态成员函数不能被声明为虚函数。
（5）指向静态成员函数的指针在定义时不需要指明所属的类。
5 友元函数与友元类
5.1 友元的定义
友元机制允许一个类对其非公有成员的访问授权予指定的函数和类。
友元的声明以关键字friend开始，它只能出现在类的内部。
class A
{
private:
int m_data;
public:
friend int get_data(A &a);
friend int B::get_data(A& a);
friend class C;
};5.2 友元函数
（1）在类外定义函数，在类内用friend对该函数进行声明。
（2）友元函数可以为普通函数，也可以是另一个类的成员函数。
friend int B::get_data(A& a);5.3 友元类
（1） 将一个类B声明为另一个类A的友元类，则B类中的成员函数可以访问A类的私有数据。
（2）友元关系为单向，B类是A类的友元类，则B的成员可以访问A类的私有成员，但A的成员不能访问B类的私有成员。
（3）友元关系不能传递，B类是A类的友元类，C类是B类的友元类，C类并不是A类的友元类。
内容回顾：
（1） 静态数据成员占类对象的存储空间吗？
（2）静态成员函数是否可以被声明为const函数？
（3）什么是友元？一个类的成员函数可以定义成另一个类的友元函数吗？
（4）静态成员函数和非静态成员函数的根本区别是什么？
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
