1 常量成员

class Polygon
{
    int x;
    int y; 
    const int area = 1; //类内初始值，类似于默认值
public:
	Polygon()	//没有通过初始化表达式对area初始化，默认初始化area的值为1
	{ ;}
    Polygon(int a):area(a)	//可以通过初始化表达式对const成员初始化，area 的值为a
    { ;}
    ~Polygon()
    { ;}


};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

数据成员可以由const修饰，这样，一经初始化，该数据数据成员便具有“只读属性”，在程序中无法对其值修改。
事实上，在构造函数内或复制构造函数体内赋值const数据成员是非法的，const数据成员只能通过成员初始化表达式进行初始化。
注意：如果没有类内初始值，所有的构造函数中的初始化表达式都要对这个const数据成员进行初始化

2 引用成员

本质：指针常量
int &p;
引用成员的用处：
通过引用访问外部的空间，操作同const数据成员
注意：不能有类内初始化值，因为它初始化需要变量名
应用：
可以与类外部的空间关联起来
就可以向操作自己成员一样去操作外部的

class Polygon
{

    int x;
    int &p;
public:
	Polygon(int a, int &b):x(a),p(b)
    ~Polygon()
    { ;}
};
1
2
3
4
5
6
7
8
9
10

3 类对象成员

A类对象的空间分配在 B类的构造函数中
通常，在B类的初始化表达式中，利用A类的构造函数对这个对象进行初始化
但是，类对象其实也可以在构造函数内部进行赋值

class Date {
    int year;
    int month;
    int day;
public:
    Date(int y = 1970, int m = 1, int d = 1):year(y), month(m),day(d)
    {;}

    void setYear(int y);
    void setMonth(int y);
    void setDay(int y);
};
void Date::setYear(int y)
{
   year = y;
}
void Date::setMonth(int m)
{
    month = m;
}
void Date::setDay(int d)
{
    day = d;
}
class Student
{
    string name;    //姓名
    int age;        //年龄
    Date in;        //入校时间
public:
    Student()
    {
        name.clear();
        age = 0;
    }

    Student(string mz, int n, Date &c) //调用了in（），即调用Date的无参构造
    {
        in = c;
        name = mz;
        in.setYear(1922);
        in.setMonth(2);
        in.setDay(1);
    }

    Student(string mz, int n, Date &c):in(c)
    {

    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

4 静态成员

C++允许使用static修饰数据成员，这样的成员在编译时就被创建并初始化的（与之相比，对象是在运行时才被创建的），且其实例只有一个，被所有该类的对象共享，就像是住在同一宿舍的同学共享一个房间号一样。
静态数据成员和静态变量一样，程序执行时，该成员已经存在，一直到程序结束，任何对象都可以对其进行访问。

静态数据成员的初始化必须在类声明之外进行，且不再包含static关键字，格式如下：
类型 类名::变量名 = 初始化表达式；//普通变量
类型 类名::对象名（构造函数； //对象变量

class Aa
{
public:
    Aa() {}
    Aa(int A) {}
};
class Point
{
    int x;
    int y;
    static int z;	//普通变量
    static Aa a;	//对象变量
public:
    Point(){}
    void setZ(int c);
    void show();
};
int Point::z = 12;
//Aa Point::a;	//调用无参构造
Aa Point::a(2);	//调用带参构造
void Point::setZ(int c)
{
    z = c;
}
void Point::show()
{
    std::cout<<"z = "<<z<<std::endl;
}
int main()
{
    Point aa;
    aa.show();
    Point bb;
    bb.show();
    aa.setZ(15);
    aa.show();
    bb.show();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38