在 C++ 语法上，外部是无法访问private（私有型）数据 和 protected（保护型）数据的，但不代表真的无法访问，在技术上是可以突破类的访问权限。
假设有这样一个类：
class D
{
public:
D(int a, short b, int c):mA(a),mB(b), mC(c) {}
private :
int mA;
short mB;
int mC;
};
我们想要访问私有成员变量mA、mB、mC。
（1）通过指针访问
首先初始化D：
D* d = new D(10, 20, 30);
mA赋值成10，mB赋值成20。
有一个重要的常识需要清楚：对象的首地址就是第一个成员变量的地址，在类D中，第一个成员变量是整数类型的mA，第二个成员变量是短整型的mB。
d的首地址就是d本身，如果d没有使用 new 创建的话，比如：
D d;
那么的它的首地址是：&d。
由于mA是int型的，所以需要将 d 强转成int类型的指针：
int* p = (int*)d
此时，p就是指向 mA 的指针，mA的值就是：
*p
由于mA、mB 和 mC是内存空间是连续的，所以mB和mC的指针分别是：p+1 和 p+2。
此时，可以编写代码直接访问这三个私有成员变量：
D* d = new D(10, 20, 30);
int* p = (int*)d;
cout << *p << endl;
short b = *(p + 1);
cout << b << endl;
int c = *(p + 2);
cout << c << endl;
打印结果是：
10
20
30
指针不仅可以访问 private 和 protected 成员变量，还可以对它们赋值：
D* d = new D(10, 20, 30);
int* p = (int*)d;
*p = 20; // 对mA赋值
*(p+1) = 30; // 对mB赋值
*(p+2) = 40; // 对mC赋值
cout <<"mA:"<< *p << endl;
short b = *(p + 1);
cout << "mB:" << b << endl;
int c = *(p + 2);
cout << "mC:" << c << endl;
输出结果是：
mA:20
mB:30
mC:40
（2）通过友元的方式
通过友元的方式既可以突破访问 private 和 protected 修饰的成员变量，还可以对它们进行赋值，代码如下：
class D
{
public:
D(int a):mA(a) {}
friend int getA(const D& d);
friend void setA(D& d, int a);
private:
int mA;
};
int getA(const D& d)
{
return d.mA;
}
void setA(D& d, int a)
{
d.mA = a;
}
int main()
{
D d(10);
int a1 = getA(d);
cout << a1 << endl;
setA(d, 20);
int a2 = getA(d);
cout << a2 << endl;
return 0;
}
输出结果是：
10
20
（3）通过宏的方式
通用宏定义，将private 替换 成 public
#define private public
using namespace std;
class D
{
public:
D(int a):mA(a) {}
private:
int mA;
};
int main()
{
D d(10);
cout << d.mA << endl;
return 0;
}
（4）重载模板函数
在类中定义一个模板，在类外重载这个模板函数。
class D
{
public:
D(int a):mA(a) {}
template<class T>
int getA(const T&)
{
return mA;
}
private:
int mA;
};
template <>
int D::getA(const D&) { // 模板函数的重载
return mA;
}
int main()
{
D d(10);
cout << d.getA(d) << endl;
return 0;
}
[本章完...]
