一、在类的内部定义新的类型，并引伸出union的妙用
转自：http://www.blogjava.net/bacoo/archive/2008/07/13/214616.html
在类内部其实是可以定义一些类型的，比如struct、union、class，其实也就只有这三类可以被定义，
也只有这三类可以定义它们各自的对象，然后“.”出来或者“->”出来，C++中只有这三类了。
对于它们各自来说，在一个类的内部都可以有三种方式来定义它们，比如对于union，
第一种方式：//定义了一个union类型，并且定义了一个属于该类型的对象un，因此sizeof(X)==4
class X{
public:
union UN{
int m_nX;
char* pchar;
}un;
};
第二种方式：//定义了一个union类型，但并没有定义属于该类型的任何对象，因此sizeof(X)==0
class X{
public:
union UN{
int m_nX;
char* pchar;
};
};
第三种方式：//定义了一个匿名的union类型，因此也就只能在X内部使用了，并且此种情况隐含着已经
在X中定义了一个属于该匿名union类型的对象，因此sizeof(X)==4，并且此种情况最为特殊，可以直接
通过类X的对象来使用m_nX和pchar，例如X x;x.m_nX=10;x.pchar="Hello World!";
class X{
public:
union {
int m_nX;
char* pchar;
};
};
对于前两种方式，都在类的内部定义了一个新的具有名字的型别，因此可以用这种新的类型来定义对应
于该类型的对象，例如：X::UN myun;但是这种定义是要求类内部的union在定义时的修饰符为public，
否则就不能在类外部定义属于他们的对象，而只能在给类X内部使用了。
同理也可以知道在类内部通过typedef定义出来的新型别也是如此。
需要说明的是，union用类里以第三种定义的方式出现的话，会有很奇妙的效果，非常奇妙，或许在今
后的编程过程中可以加以利用。m_nX和pchar共享一块4个字节的内存，只要不是同时需要m_nX和pchar
出现的情况都可以只利用它们其中的一个，从而节省了内存开销。
我的补充：
class Student
｛
typedef int SubType; //这句作用就是最简单的在Student类内部定义一个新的类型SubType。
........
｝
另外，在模版中常用到typename关键子，这里简单提一下
template <class T>
class MyClass
{
typename T::SubType * ptr;
......
};
上面定义一个模版类MyClass，注意里面定义了一个ptr指针。为什么这里必须用到typename关键字，因为，T这个类型假设就是我门上面定义的类型Student之类的东西，那么以后所有用来代替T的东西都必须含有内部类型SubType（且是public的，上面的student忘写了）。如果没有typename，则T::SubType * ptr;就被编译器理解为T类内部的静态变量SubType乘以Ptr（*号也表示乘积的意思），注意：：域作用符的优先级可以认为是最高的，就像括号一样，T::SubType在任何地方就应该看成一个整体符号或名字。所以加上typename后，typename
T::SubType * ptr;这句中typename关键字就修饰离他最近的符号“T::SubType”，表示“T::SubType”是一个类型名字，这样编译器进一步翻译下一个符合*时，才认为*号是表示指针的意思，而不是乘积。
二、如何定义一个类内部（in-class）的常量
转自：http://blog.163.com/shi_shun/blog/static/237078492010045336946/
如果你需要一个通过常量表达式来定义的常量，例如数组的范围，你有两种选择：
class X {
static const int c1 = 7;
enum { c2 = 19 };
char v1[c1];
char v2[c2];
// ...
};
乍看起来，c1的声明要更加清晰，但是要注意的是，使用这种类内部的初始化语法的时候，
常量必须是被一个常量表达式初始化的整型或枚举类型，而且必须是static 和const 形
式。这是很严重的限制：
class Y {
const int c3 = 7; // 错误：不是 static
static int c4 = 7; // 错误：不是 const
static const float c5 = 7; // 错误：不是整型
};
我倾向使用枚举的方式，因为它更加方便，而且不会诱使我去使用不规范的类内初始化语法。
那么，为什么会存在这种不方便的限制呢？一般来说，类在一个头文件中被声明，而头文件
被包含到许多互相调用的单元去。但是，为了避免复杂的编译器规则，C++要求每一个对象
只有一个单独的定义。如果 C++允许在类内部定义一个和对象一样占据内存的实体的话，这
种规则就被破坏了。对于C++在这个设计上的权衡，请参见《C++语言的设计和演变》。
如果你不需要用常量表达式来初始化它，那么可以获得更大的弹性：
class Z {
static char* p; // 在定义中初始化
const int i; // 在构造函数中初始化
public:
Z(int ii) :i(ii) { }
};
char* Z::p = "hello, there";
你可以获取一个 static成员的地址，当且仅当它有一个类外部的定义的时候：
class AE {
// ...
public:
static const int c6 = 7;
static const int c7 = 31;
};
const int AE::c7; // 定义
int f()
{
const int* p1 = &AE::c6; // 错误：c6 没有左值
const int* p2 = &AE::c7; // ok
// ...
}