来自：黄邦勇帅
const 常量对象：
即把对象声明为常量，即 const hyong m，常量对象不能调用可能改变对象的值的函数，因此常量对象只能调用类中的 const 常量函数，因为不是 const 的函数都有可能改变对象的值。
常量对象可以调用类中的公有成员，如 m.a 就是正确的如果 a 是公有的。
不能对常量对象的公有成员重新赋值，如 m.a=3 就是错误的。但可以对类中的公有静态成员变量重新赋值，因为静态成员变是不属于这个常量对象，他是属于整个类的。
对象数组：
对象数组即数组中的每个成员都是一个对象，例如 hyong a[3];其中 a[0]，a[1]，a[2]都是一个 hyong 类型的对象。
对象数组的初始化，如果有默认构造函数则语句 hyong a[3]将调用默认构造函数初始化 3 个对象；
如果对象数组带有一个参数的构造函数则可以这样初始化 hyong a[3]={1,2,3}；
如果对象数组带有多个参数的构造函数，则初始化方法为 hyong a[3]={hyong(1,2),hyong(3,4),hyong(4,5)}。
类中的对象成员：
即把对象作为另一个类的成员。比如 class B{public: A x;}
如果要用带参数的构造函数初始化x, 必须用初始化列表初始化
例子：
#include <iostream>
using namespace std;
class A
{
public:
int a, b;
A()
{
a = b = 0;
cout << "A 默认构造函数" << endl;
}
A(int i)
{
a = b = i;
cout << "A 一个参数的构造函数" << endl;
}
A(int i, int j)
{
a = i;
b = j;
cout << "A 两个参数的构造函数" << endl;
}
};
class B
{
public:
int a, b;
A x;
B()
{
a = b = 2;
cout << "B 默认构造函数" << endl;
}
B(int i)
{
a = b = i;
cout << "B 一个参数的构造函数" << endl;
}
B(int i, int j);
};
B::B(int i, int j):a(i), b(j), x(A(3,4)){} //用含参数的构造函数初始化成员，用初始化列表
int main()
{
A m;
cout << "---------------" << endl;
B n;
cout << "---------------" << endl;
B n1(4, 5);
cout << "---------------" << endl;
n.x = A(6, 7);
cout << "---------------" << endl;
cout << n.x.a << n.x.b << endl;
return 0;
}
如果不用初始化列表，在构造函数里用两个变量的构造函数给x赋值，结果是
#include <iostream>
using namespace std;
class A
{
public:
int a, b;
A()
{
a = b = 0;
cout << "A 默认构造函数" << endl;
}
A(int i, int j)
{
a = i;
b = j;
cout << "A 两个参数的构造函数" << endl;
}
};
class B
{
public:
int a, b;
A x;
B()
{
a = b = 2;
x = A(1,2); //这里已经不是初始化了。而是重新赋值。
//先用A的默认构造函数生成了x, 这里又用A(1,2)构造了一个临时变量，通过赋值函数将临时变量赋给了x
cout << "B 默认构造函数" << endl;
}
};
int main()
{
B n;
return 0;
}
类成员指针
1.声明类成员指针的方式为：int hyong::*p1 声明了一个指向类中整型成员的指针 p1。 int (hyong::*p2)()注意括号，声明一个指向反回类型为 int 的无参数的函数的指针 p2
2.类成员指针即指向类中成员的指针注意是直接指向类中的成员而不是指向对象的某一成员的指针， 即与指针 p=&m.a是不一样的。
类成员指针提供的是成员在类中的对象的偏移量，不是一个真正的指针。
因为不是一个真正的指针所以不能通过指针来访问类中的成员，而只能通过特殊的运算符.*或->*来访问指针指向的成员。
比如*p1=2 ，hyong::*p1=2 是错误的，不能对类成员指针指向的类成员直接赋值。cout<<*p1<<hyong::*p1 也是错误的，不能直接用类成员指针来访问类中的成员。