这是More Effecitve C++里的第二条对类型转换讲的很好，也很基础好懂。
Item M2：尽量使用C++风格的类型转换
仔细想想地位卑贱的类型转换功能（cast），其在程序设计中的地位就象goto语句一样令人鄙视。但是它还不是无法令人忍受，因为当在某些紧要的关头，类型转换还是必需的，这时它是一个必需品。
不过C风格的类型转换并不代表所有的类型转换功能。
一来它们过于粗鲁，能允许你在任何类型之间进行转换。不过如果要进行更精确的类型转换，这会是一个优点。在这些类型转换中存在着巨大的不同，例如把一个指向 const对象的指针（pointer-to-const-object）转换成指向非const对象的指针（pointer-to-non-const -object）(即一个仅仅去除const的类型转换)，把一个指向基类的指针转换成指向子类的指针（即完全改变对象类型）。传统的C风格的类型转换不对上述两种转换进行区分。（这一点也不令人惊讶，因为C风格的类型转换是为C语言设计的，而不是为C++语言设计的）。
二来C风格的类型转换在程序语句中难以识别。在语法上，类型转换由圆括号和标识符组成，而这些可以用在C＋＋中的任何地方。这使得回答象这样一个最基本的有关类型转换的问题变得很困难：“在这个程序中是否使用了类型转换？”。这是因为人工阅读很可能忽略了类型转换的语句，而利用象grep的工具程序也不能从语句构成上区分出它们来。
C++通过引进四个新的类型转换操作符克服了C风格类型转换的缺点，这四个操作符是, static_cast, const_cast, dynamic_cast, 和reinterpret_cast。在大多数情况下，对于这些操作符你只需要知道原来你习惯于这样写，
(type) expression
而现在你总应该这样写：
static_cast<type>(expression)
例如，假设你想把一个int转换成double，以便让包含int类型变量的表达式产生出浮点数值的结果。如果用C风格的类型转换，你能这样写：
int firstNumber, secondNumber;
...
double result = ((double)firstNumber)/secondNumber；
如果用上述新的类型转换方法，你应该这样写：
double result = static_cast<double>(firstNumber)/secondNumber;
这样的类型转换不论是对人工还是对程序都很容易识别。
static_cast 在功能上基本上与C风格的类型转换一样强大，含义也一样。它也有功能上限制。例如，你不能用static_cast象用C风格的类型转换一样把 struct转换成int类型或者把double类型转换成指针类型，另外，static_cast不能从表达式中去除const属性，因为另一个新的类型转换操作符const_cast有这样的功能。
其它新的C++类型转换操作符被用在需要更多限制的地方。const_cast用于类型转换掉表达式的const或volatileness属性。通过使用const_cast，你向人们和编译器强调你通过类型转换想做的只是改变一些东西的 constness或者volatileness属性。这个含义被编译器所约束。如果你试图使用const_cast来完成修改constness 或者volatileness属性之外的事情，你的类型转换将被拒绝。下面是一些例子：
class Widget { ... };
class SpecialWidget: public Widget { ... };
void update(SpecialWidget *psw);
SpecialWidget sw; // sw 是一个非const 对象。
const SpecialWidget& csw = sw; // csw 是sw的一个引用
// 它是一个const 对象
update(&csw); // 错误!不能传递一个const SpecialWidget* 变量
// 给一个处理SpecialWidget*类型变量的函数
update(const_cast<SpecialWidget*>(&csw));
// 正确，csw的const被显示地转换掉（
// csw和sw两个变量值在update
//函数中能被更新）
update((SpecialWidget*)&csw);
// 同上，但用了一个更难识别
//的C风格的类型转换
Widget *pw = new SpecialWidget;
update(pw); // 错误！pw的类型是Widget*，但是
// update函数处理的是SpecialWidget*类型
update(const_cast<SpecialWidget*>(pw));
// 错误！const_cast仅能被用在影响
// constness or volatileness的地方上。,
// 不能用在向继承子类进行类型转换。
到目前为止，const_cast最普通的用途就是转换掉对象的const属性。
第二种特殊的类型转换符是dynamic_cast，它被用于安全地沿着类的继承关系向下进行类型转换。这就是说，你能用dynamic_cast把指向基类的指针或引用转换成指向其派生类或其兄弟类的指针或引用，而且你能知道转换是否成功。失败的转换将返回空指针（当对指针进行类型转换时）或者抛出异常（当对引用进行类型转换时）：
Widget *pw;
...
update(dynamic_cast<SpecialWidget*>(pw));
// 正确，传递给update函数一个指针
// 是指向变量类型为SpecialWidget的pw的指针
// 如果pw确实指向一个对象,
// 否则传递过去的将使空指针。
void updateViaRef(SpecialWidget& rsw);
updateViaRef(dynamic_cast<SpecialWidget&>(*pw));
//正确。传递给updateViaRef函数
// SpecialWidget pw 指针，如果pw
// 确实指向了某个对象
// 否则将抛出异常
dynamic_casts在帮助你浏览继承层次上是有限制的。它不能被用于缺乏虚函数的类型上（参见条款M24），也不能用它来转换掉constness：
int firstNumber, secondNumber;
...
double result = dynamic_cast<double>(firstNumber)/secondNumber;
// 错误！没有继承关系
const SpecialWidget sw;
...
update(dynamic_cast<SpecialWidget*>(&sw));
// 错误! dynamic_cast不能转换
// 掉const。
如你想在没有继承关系的类型中进行转换，你可能想到static_cast。如果是为了去除const，你总得用const_cast。
这四个类型转换符中的最后一个是reinterpret_cast。使用这个操作符的类型转换，其的转换结果几乎都是执行期定义（implementation-defined）。因此，使用reinterpret_casts的代码很难移植。
reinterpret_casts的最普通的用途就是在函数指针类型之间进行转换。例如，假设你有一个函数指针数组：
typedef void (*FuncPtr)(); // FuncPtr is 一个指向函数
// 的指针，该函数没有参数
// 返回值类型为void
FuncPtr funcPtrArray[10]; // funcPtrArray 是一个能容纳
// 10个FuncPtrs指针的数组
让我们假设你希望（因为某些莫名其妙的原因）把一个指向下面函数的指针存入funcPtrArray数组：
int doSomething();
你不能不经过类型转换而直接去做，因为doSomething函数对于funcPtrArray数组来说有一个错误的类型。在FuncPtrArray数组里的函数返回值是void类型，而doSomething函数返回值是int类型。
funcPtrArray[0] = &doSomething; // 错误！类型不匹配
reinterpret_cast可以让你迫使编译器以你的方法去看待它们：
funcPtrArray[0] = // this compiles
reinterpret_cast<FuncPtr>(&doSomething);
转换函数指针的代码是不可移植的（C++不保证所有的函数指针都被用一样的方法表示），在一些情况下这样的转换会产生不正确的结果（参见条款M31），所以你应该避免转换函数指针类型，除非你处于着背水一战和尖刀架喉的危急时刻。一把锋利的刀。一把非常锋利的刀。
如果你使用的编译器缺乏对新的类型转换方式的支持，你可以用传统的类型转换方法代替static_cast, const_cast, 以及reinterpret_cast。也可以用下面的宏替换来模拟新的类型转换语法：
#define static_cast(TYPE,EXPR) ((TYPE)(EXPR))
#define const_cast(TYPE,EXPR) ((TYPE)(EXPR))
#define reinterpret_cast(TYPE,EXPR) ((TYPE)(EXPR))
你可以象这样使用使用：
double result = static_cast(double, firstNumber)/secondNumber;
update(const_cast(SpecialWidget*, &sw));
funcPtrArray[0] = reinterpret_cast(FuncPtr, &doSomething);
这些模拟不会象真实的操作符一样安全，但是当你的编译器可以支持新的的类型转换时，它们可以简化你把代码升级的过程。
没有一个容易的方法来模拟dynamic_cast的操作，但是很多函数库提供了函数，安全地在派生类与基类之间进行类型转换。如果你没有这些函数而你有必须进行这样的类型转换，你也可以回到C风格的类型转换方法上，但是这样的话你将不能获知类型转换是否失败。当然，你也可以定义一个宏来模拟 dynamic_cast的功能，就象模拟其它的类型转换一样：
#define dynamic_cast(TYPE,EXPR) (TYPE)(EXPR)
请记住，这个模拟并不能完全实现dynamic_cast的功能，它没有办法知道转换是否失败。
我知道，是的，我知道，新的类型转换操作符不是很美观而且用键盘键入也很麻烦。如果你发现它们看上去实在令人讨厌，C风格的类型转换还可以继续使用并且合法。然而，正是因为新的类型转换符缺乏美感才能使它弥补了在含义精确性和可辨认性上的缺点。并且，使用新类型转换符的程序更容易被解析（不论是对人工还是对于工具程序），它们允许编译器检测出原来不能发现的错误。这些都是放弃C风格类型转换方法的强有力的理由。还有第三个理由：也许让类型转换符不美观和键入麻烦是一件好事。

In C++ it is possible to declare constructors for a class, taking a single parameter, and use those constructors for doing type conversion. For example:

				

						
						
						
						
								class
						
						
								 A {

								public
						
						
								:
        A(
								int
						
						
								);
};


								void
						
						
								 f(A) {}

								void
						
						
								 g()
{
         A a1 
								=
								 
								37
						
						
								;
         A a2 
								=
								 A(
								47
						
						
								);
         A a3(
								57
						
						
								);
         a1 
								=
								 
								67
						
						
								;
         f(
								77
						
						
								);
}

						
				
				

				A declaration like:
	 A a1 = 37;
says to call the A(int) constructor to create an A object from
the integer value. Such a constructor is called a "converting
constructor". 

		

However, this type of implicit conversion can be confusing, and there is a way of disabling it, using a new keyword "explicit" in the constructor declaration:

				

						
						
						
						
								class
						
						
								 A {

								public
						
						
								:
        
								explicit
								 A(
								int
						
						
								);
};


								void
						
						
								 f(A) {}

								void
						
						
								 g()
{
          A a1 
								=
								 
								37
								;      
								//
								 illegal
						
						
								

						
						
								          A a2 
								=
								 A(
								47
								);   
								//
								 OK
						
						
								

						
						
								          A a3(
								57
								);       
								//
								 OK
						
						
								

						
						
								          a1 
								=
								 
								67
								;        
								//
								 illegal
						
						
								

						
						
								          f(
								77
								);          
								//
								 illegal
						
						
								

						
						
								}


						
				
				

		

				

						
						
								class
						
						
								 A {

								public
						
						
								:
        
								explicit
								 A(
								int
						
						
								);
        };


								void
						
						
								 f(A) {}


								void
						
						
								 g()
{
        A a1 
								=
								 A(
								37
						
						
								);
        A a2 
								=
								 A(
								47
						
						
								);
        A a3(
								57
						
						
								);
        a1 
								=
								 A(
								67
						
						
								);
        f(A(
								77
						
						
								));
}


						
				
				

		

Note that an expression such as:

				        A(47)

		

is closely related to function-style casts supported by C++. For example:

				        double d = 12.34;

        int i = int(d);

		

结果是：
p1=>1107951616
p2=>3.45

书上的解释是：p1尽管与p2的地址相同，但它是整型指针，它总是访问该地址中的整型数。
首先在32位CPU上面,指针都是4位的,例如0xXX XX XX XX
那么既然指针是一样的,那么为什么指针类型不同的话,读出来的数据就变了样呢?
这是编译器的问题,例如我有个例子

char *p = 'c';
int *p1 = 10;
在32位机器上面
这里面p1是指向4字节的int变量,而p是指向1字节的char 变量
这样编译器在用p1变量的时候,会取0x XX XX XX XX后面的4个字节
而p变量,只会取0x XX XX XX XX后面的1个字节

因为本人现在在网吧里面[不知道大家有没有在网吧里面碰到装有c++编译器的计算机]
晚上我给大家一个例子,可以从其内存上面看的很清楚

    1998年，国际C++标准正式通过，标准化对C++最重要的贡献是：对"强大的抽象概念"给于更有力的支持，以降低软件的复杂度，C++提供了二种功能强大的抽象方法：面向对象编程与泛型编程。面向对象编程大家一定很熟悉了，这里就不再哆嗦了。提到泛型编程(Generic Programming)，有的人可能还不太熟悉，但是提到STL，你就一定会有所耳闻了。STL(Standard Template Library，标准模板库) 其实就是泛型编程的实现品，STL是由Alexander Stepanov(STL之父)、David R Musser和Meng Lee三位大师共同发展，于1994年被纳入C++标准程序库。STL虽然加入C++标准库的时间相对较晚，但它却是C++标准程序库中最具革命性的部分，同时也是C++标准程序库中最重要的组成部分。由于新的C++标准库中几乎每一样东西都是由模板(Template)构成的，当然，STL也不会例外。所以，在这里有必要先概要说明一下模板的有关概念。

模板概念
    通过使用模板可以使程序具有更好的代码重用性。记住，模板是对源代码进行重用，而不是通过继承和组合重用对象代码，当用户使用模板时，参数由编译器来替换。模板由类模板和函数模板二部分组成，以所处理的数据类型的说明作为参数的类就叫类模板，而以所处理的数据类型的说明作为参数的函数叫做函数模板。模板参数可以由类型参数或非类型参数组成，类型参数可用class和typename关键字来指明，二者的意义相同，都表示后面的参数名代表一个潜在的内置或用户定义的类型，非类型参数由一个普通参数声明构成。下面是类模板和函数模板的简单用法： template<class T1, int Size> class Queue // 类模板，其中T1为类型参数，Size为非类型参数 { public: explicit Queue():size_(Size){}; // 显式构造，避免隐式转换 …… template<class T2> void assign(T2 first,T2 last); // 内嵌函数模板 private: T* temp_; int size_; } // 类模板中内嵌函数模板Compare的外围实现(如在Queue类外实现) template<class T1,int Size> template<class T2> void Queue<T1,Size>::assign (T2 first,T2 last) {}; // 模板的使用方法 int ia[4] = {0,1,2,3}; Queue<int, sizeof(ia)/sizeof(int)> qi; qi.assign(ai,ai+4); 泛型编程
    泛型编程和面向对象编程不同，它并不要求你通过额外的间接层来调用函数，它让你编写完全一般化并可重复使用的算法，其效率与针对某特定数据类型而设计的算法相同。泛型编程的代表作品STL是一种高效、泛型、可交互操作的软件组件。所谓泛型(Genericity)，是指具有在多种数据类型上皆可操作的含意，与模板有些相似。STL巨大，而且可以扩充，它包含很多计算机基本算法和数据结构，而且将算法与数据结构完全分离，其中算法是泛型的，不与任何特定数据结构或对象类型系在一起。STL以迭代器(Iterators)和容器(Containers)为基础，是一种泛型算法(Generic Algorithms)库，容器的存在使这些算法有东西可以操作。STL包含各种泛型算法(algorithms)、泛型指针(iterators)、泛型容器(containers)以及函数对象(function objects)。STL并非只是一些有用组件的集合，它是描述软件组件抽象需求条件的一个正规而有条理的架构。
    迭代器(Iterators)是STL的核心，它们是泛型指针，是一种指向其他对象(objects)的对象，迭代器能够遍历由对象所形成的区间(range)。迭代器让我们得以将容器(containers)与作用其上的算法(algorithms)分离，大多数的算法自身并不直接操作于容器上，而是操作于迭代器所形成的区间中。迭代器一般分为五种：Input Iterator、Output Iterator、Forward Iterator、Bidirections Iterator和Random Access Iterator。Input Iterator就象只从输入区间中读取数据一样，具有只读性，属于单向移动，如STL中的istream_iterator。Output Iterator刚好相反，只写出数据到输出区间中，具有只写性，属于单向移动，如STL中的ostream_iterator。Forward Iterator也属于单向移动，但不同之处是它同时具有数据读、写性。Bidirections Iterator如名称暗示，支持双向移动，不但可以累加(++)取得下一个元素，而且可以递减(--)取前一个元素，支持读、写性。Random Access Iterator功能最强，除了以上各迭代器的功能外，还支持随机元素访问(p+=n)，下标(p[n])、相减(p1-p2)及前后次序关系(p1<p2)等。Input Iterator和Output Iterator属于同等最弱的二种迭代器，Forward Iterator是前二者功能的强化(refinement)，Bidirections Iterator又是Forward Iterator迭代器的强化，最后Random Access Iterator又是Bidirections Iterator迭代器的强化。如下简单示例展示Input Iterator、Forward Iterator、Bidirections Iterator和Radom Access Iterator迭代器的功能（其中input_iterator_tag等带tag字符串为各不同迭代器的专属标识）：
1、InputIterator template<class InputIterator, class Distance> void advance(InputIterator& i, Distance n, input_iterator_tag) { for(; n>0; --n,++i){} // InputIterator具有++性 } 2、ForwardIterator template<class ForwardIterator, class Distance> void advance(ForwardIterator& i, Distance n,forward_iterator_tag) { advance(i, n, input_iterator_tag()); } 3、BidirectionalIterator template<class BidirectionalIterator, class Distance> void advance(BidirectionalIterator& i, Distance n, bidirectional_iterator_tag) { if(n>=0) // 具有++、--性 for(; n>0; --n,++i){} else for(; n>0; ++n,--i){} } 4、RandomAccessIterator template<class RandomAccessIterator, class Distance> void advance(RandomAccessIterator& i, Distance n, random_access_iterator_tag) { i += n; // 具有++、--、+=等性 }     函数对象(Function object)也称仿函数(Functor)，是一种能以一般函数调用语法来调用的对象，函数指针(Function pointer)是一种函数对象，所有具有operator()操作符重载的成员函数也是函数对象。函数对象一般分为无参函数(Generator)，单参函数(Unary Function)和双参函数(Binary Function)三种形式，它们分别能以f()、f(x)和f(x,y)的形式被调用，STL定义的其他所有函数对象都是这三种概念的强化。如下简单示例展示几种形式的实现：

1、无参(Generator)形式 struct counter { typedef int result_type; counter(result_type init=0):n(init){} result_type operator() { return n++;} result_type n; } 2、单参(Unary Function)形式 template<class Number> struct even // 函数对象even，找出第一个偶数 { bool operator()(Number x) const {return (x&1) == 0;} } // 使用算法find_if在区间A到A+N中找到满足函数对象even的元素 int A[] = {1,0,3,4}; const int N=sizeof(A)/sizeof(int); find_if(A,A+N, even<int>()); 3、双参(Binary Function)形式 struct ltstr { bool operator()(const char* s1, const char* s2) const { return strcmp(s1<s2) < 0;} }; // 使用函数对象ltstr，输出set容器中A和B的并集 const int N=3 const char* a[N] = {"xjz","xzh","gh"}; const char* b[N]= {"jzx","zhx","abc"}; set<const char*,ltstr> A(a,a+N); set<const char*,ltstr> B(b,b+N); set_union(A.begin(),A.end(),B.begin(),B.end(), ostream_iterator<const char*>(cout," "), ltstr());     容器(container)是一种对象(object)，可以包含并管理其它的对象，并提供迭代器(iterators)用以定址其所包含之元素。根据迭代器种类的不同，容器也分为几中，以Input Iterator为迭代器的一般container，以Forward Iterator为迭代器的Forward Container，以Bidirectional Iterator 为迭代器的Reversible Container，以Random Access Iterator为迭代器的Random Access Container。STL定义二种大小可变的容器：序列式容器(Sequence Container)和关联式容器(Associative Container)序列式容器包括vector、list和deque，关联式容器包括set、map、multiset和multimap。以下示例简单说明部分容器的使用： 1、vector使用 // 将A中以元素5为分割点，分别排序，使排序后5后面的元素都大于5之前的元素(后区间不排序)， // 然后输出 int main() { int A[] = {7,2,6,4,5,8,9,3,1}; const int N=sizeof(A)/sizeof(int); vector<int> V(A,A+N); partial_sort(V,V+5,V+N); copy(V,V+N,ostream_iterator<int>(cout," ")); cout << endl; } 输出可能是：1 2 3 4 5 8 9 7 6 2、list使用 // 产生一空list，插入元素后排序，然后输出 int main() { list<int> L1; L1.push_back(0); L1.push_front(1); L1.insert(++L1.begin,3); L1.sort(); copy(L1.begin(),L1.end(),ostream_iterator<int>(cout," ")); } 输出：0 1 3 3、deque使用 int main() { deque<int> Q; Q.push_back(3); Q.push_front(1); Q.insert(Q.begin()+1,2); Copy(Q.begin(),Q.end(),ostream_iterator<int>(cout," ")); } 输出：1 2 3 4、map使用 int main() { map<string,int> M; M.insert(make_pair("A",11); pair<map<string,int>::iterator, bool> p = M.insert(make_pair("C",5)); if(p.second) cout << p.first->second<<endl; } 输出：5 5、multiset使用 int main() { const int N = 5; int a[N] = {4,1,1,3,5}; multiset<int> A(a,a+N); copy(A.begin(),A.end(),ostream_iterator<int>(cout," ")); } 输出：1 1 3 4 5 设计新思维
    将设计模式(design patterns)、泛型编程(generic programming)和面向对象编程(object-oriented programming)有机的结合起来，便形成了设计新思维。其中，设计模式是经过提炼的出色设计方法，对于很多情况下碰到的问题，它都是合理而可复用的解决方案；泛型编程是一种典范(paradigm)，专注于将类型抽象化，形成功能需求方面的一个精细集合，并利用这些需求来实现算法，相同的算法可以运用于广泛的类型集中，所谓泛型，就是具有在多种数据类型上皆可操作的含意；最后同面象对象编程中的多态(polymorphism)和模板(templates)等技术相结合，便获得极高层次上的具有可复用性的泛型组件。泛型组件预先实现了设计模块，可以让用户指定类型和行为，从而形成合理的设计，主要特点是灵活、通用和易用。
    policies和policy类，是一种重要的类设计技术，所谓policy，是用来定义一个类或类模板的接口，该接口由下列之一或全部组成：内部类型定义、成员函数和成员变量。基于policy的类由许多小型类(称为policies)组成，每一个这样的小型类只负责单纯如行为或结构的某一方面。Policies机制由模板和多重继承组成，它们可以互相混合搭配，从而形成设计戎的多样性，通过plicy类，不但可以定制行为，也可以定制结构。

下面简单举例说明泛化思维和面向对象思维在部分设计模式中的运用。

    Singletons设计模式泛化实现 Singleton模式是一种保证一个对象(class)只有一个实体，并为它提供一个全局访问点。Singleton是一种经过改进的全局变量，既在程序中只能有唯一实体的类型，它的重点主要集中在产生和管理一个独立对象上，而且不允许产生另一个这样的对象。
先让我们看看一般的C++实现的基本手法，下面是实现源码： // Singleton.h文件中 class Singleton { public: static Singleton& Instance() { if(!pInstance_){ if(destroyed_){ // 引用是否已经失效 OnDeadReference(); } else { Create(); // 第一次时创建实例 } } return *pInstance_; } private: Singleton(); // 禁止默认构造 Singleton(const Singleton&); // 禁止拷贝构造 Singleton& operator= (const Singleton&);　 // 禁止赋值操作 static void Create() // 传加创建的实例引用 { static Singleton theInstance; pInstance_ = &theInstance; } static void OnDeadReference() { throw std::runtime_error(" 实例被不正当消毁"); } virtual ~Singleton() { pInstance- = 0; destroyed_ = true; } static Singleton *pInstance_; static bool destroyed_; } // Singleton.cpp中静态成员变量初始化 Singleton* Singleton::pInstance_ = 0; Bool Singleton::destroyed_ = false;     如上所示，Singleton模式实现中只有一个public成员Instance()用来第一次使用时创建单一实例，当第二次使用时静态变量将已经被设定好，不会再次创建实例。还将默认构造函数、拷贝构造函数和赋值操作符放在private中，目地是不让用户使用它们。另外，为避免实例意外消毁后再实例化情况，加入静态布尔变量destroy_来进行判断是否出错，从而达到稳定性。
    从上面一般实现可以看出Singleton模式实现主要在于创建(Creation)方面和生存期(Lifetime)方面，既可以通过各种方法来创建Singleton。Creation必然能创建和摧毁对象，必然要开放这两个相应函数，将创建作为独立策略分离开来是必需的，这样你就可以创建多态对象了，所以泛化Singleton并不拥有Creator对象，它被放在CreationPolicy<T>类模板之中。生命期是指要遵循C++规则，后创建都先摧毁，负责程序生命期某一时刻摧毁Singleton对象。

下面是一个简单的泛化Singleton模式的实现(不考虑线程因素) template < class T, template<class> calss CreationPolicy = CreateUsingNew, template<class> class LifetimePolicy=DefaultLifetime, > classs SingletonHolder { public: static T& Instance() { if(!pInstance_) { if(destroyed_) { LifetimePolicy<T>::OnDeadReference(); destroyed_ = false; } pInstance_ = CreationPolicy<T>::Create(); LifetimePolicy<T>::SchedultCall(&DestorySingleton); } return *pInstance_; } private: static void DestroySinleton() { assert(!destroyed_); CreationPlicy<T>::Destroy(pInstance_); pInstance_ = 0; destroyed_ = true; } SingletonHolder(); SingletonHolder (const SingletonHolder &); SingletonHolder & operator= (const SingletonHolder &);　 Static T* pInstance_; Static bool destroyed_; };     Instance()是SingletonHolder开放的唯一一个public函数，它在CreationPolicy、LifetimePolicy中打造了一层外壳。其中模板参数类型T，接收类名，既需要进行Singleton的类。模板参数内的类模板缺省参数CreateUsingNew是指通过new操作符和默认构造函数来产生对象，DefaultLifetime是通过C++规则来管理生命期。LifetimePolicy<T>中有二个成员函数，ScheduleDestrution()函数接受一个函数指针，指向析构操作的实际执行函数，如上面DestorySingleton析构函数；OnDeadReference()函数同上面一般C++中同名函数相同，是负责发现失效实例来抛出异常的。CreationPlicy<T>中的Create()和Destroy()两函数是用来创建并摧毁具体对象的。

下面是上述泛化Singleton模式实现的使用：

1、应用一 class A{}; typedef SingletonHolder<A, CreateUsingNew> SingleA; 2、应用二 class A{}; class Derived : public A {}; template<class T> struct MyCreator : public CreateUsingNew<T> { static T* Create() { return new Derived; } static void Destroy(T* pInstance) { delete pInstance; } } typedef SingletonHolder<A,MyCreator> SingleA;     通过上面示例可以看出， SingletonHolder采用基于plicy设计实现，它将Singleton对象分解为数个policies，模板参数类中CreationPolicy和LifetimePolicy相当于二个policies封装体。利用它们可以协助制作出使用者自定义的Singleton对象，同时还预留了调整和扩展的空间。由此而得，泛型组件(generic components)，是一种可复用的设计模板，结合了模板和模式，是C++中创造可扩充设计的新方法，提供了从设计到代码的简易过渡，帮助我们编写清晰、灵活、高度可复用的代码。

参考文献

• C++ Primer(第三版) --- 潘爱民等译
• Effective C++(第二版) --- 侯捷译
• More Effective C++ --- 侯捷译
• Exceptional C++ --- 卓小涛译
• More Exceptional C++ --- 於春景译
• 深度探索C++对象模型 --- 侯捷译
• 泛型编程与STL --- 侯捷译
• C++ STL程序员开发指南 --- 彭木根等箸
• 设计模式：可复用面向对象软件的元素 --- 李英军等译
• C++设计新思维 --- 侯捷等译

void main()
{
 char *str = NULL;
 GetMemory(str,100);
 strcpy(str,"Hello World");//出错
}
首先我们先看看asm
004010B8   mov         dword ptr [ebp-4],0
004010BF   push        64h
004010C1   mov         eax,dword ptr [ebp-4]
004010C4   push        eax
004010C5   call        @ILT+50(GetMemory) (00401037)
str 地址:12FF7C
其副本地址:12FF28
在存入参数的时候,同时都指向00 00 00 00
在执行p = (char*)malloc(sizeof(char)*num);之后
12FF28指向的内容变成了20 1C 43 00了.
林锐博士在这边的意思是只用指向指针的指针,这种方法我们在第二种方法种介绍,
下面给出我的一种看法,大家觉得好不好
我的方法:
char *GetMemory(char *p,int num)
{
 p = (char*)malloc(sizeof(char)*num);
 return p;
}

void main()
{
 char *str = NULL;
 str = GetMemory(str,100);
 strcpy(str,"Hello World");
 cout<<str<<endl;
}
可以简化为:
char *GetMemory(int num)
{
 char *p = (char*)malloc(sizeof(char)*num);
 return p;
}

void main()
{
 char *str = NULL;
 str = GetMemory(100);
 strcpy(str,"Hello World");
 cout<<str<<endl;
}
林锐博士的看法:
void GetMemory(char **p,int num)
{
   *p = (char*)malloc(sizeof(char)*num);
}
void main()
{
   char *str = NULL;
   GetMemory(&str,100);
   strcpy(str,"Hello,World");
   cout <<str<<endl;
}

设计更多的语法的言论。现实中，C++的库门类繁多，解决的问题也是极其广泛，库从轻量级到重量级

的都有。不少都是让人眼界大开，亦或是望而生叹的思维杰作。由于库的数量非常庞大，而且限于笔者

水平，其中很多并不了解。所以文中所提的一些库都是比较著名的大型库。

标准库

标准库中提供了C++程序的基本设施。虽然C++标准库随着C++标准折腾了许多年，直到标准的出台才正

式定型，但是在标准库的实现上却很令人欣慰得看到多种实现，并且已被实践证明为有工业级别强度的

佳作。

1、   Dinkumware C++ Library

         参考站点： http://www.dinkumware.com

P.J. Plauger编写的高品质的标准库。P.J. Plauger博士是Dr. Dobb's程序设计杰出奖的获得者。其编

写的库长期被Microsoft采用，并且最近Borland也取得了其OEM的license，在其C/C++的产品中采用

Dinkumware的库。

2、   RogueWave Standard C++ Library

         参考站点： http://www.roguewave.com/

这个库在Borland C++ Builder的早期版本中曾经被采用，后来被其他的库给替换了。笔者不推荐 。

3、SGI STL

         参考站点： http://www.roguewave.com/

SGI公司的C++标准模版库。

4、STLport

         参考站点： http://www.stlport.org

SGI STL库的跨平台可移植版本。

准标准库——Boost

Boost库是一个经过千锤百炼、可移植、提供源代码的C++库，作为标准库的后备，是C++标准化进程的

发动机之一。 Boost库由C++标准委员会库工作组成员发起，在C++社区中影响甚大，其成员已近2000人

。 Boost库为我们带来了最新、最酷、最实用的技术，是不折不扣的“准”标准库。

Boost中比较有名气的有这么几个库：

Regex
正则表达式库

Spirit
LL parser framework，用C++代码直接表达EBNF

Graph
图组件和算法

Lambda
在调用的地方定义短小匿名的函数对象，很实用的functional功能

concept check
检查泛型编程中的concept

Mpl
用模板实现的元编程框架

Thread
可移植的C++多线程库

Python
把C++类和函数映射到Python之中

Pool
内存池管理

smart_ptr
5个智能指针，学习智能指针必读，一份不错的参考是来自CUJ的文章：

Smart Pointers in Boost,哦，这篇文章可以查到，CUJ是提供在线浏览的。中文版见笔者在《Dr.

Dobb's Journal软件研发杂志》第7辑上的译文。

Boost总体来说是实用价值很高，质量很高的库。并且由于其对跨平台的强调，对标准C++的强调，是编

写平台无关，现代C++的开发者必备的工具。但是Boost中也有很多是实验性质的东西，在实际的开发中

实用需要谨慎。并且很多Boost中的库功能堪称对语言功能的扩展，其构造用尽精巧的手法，不要贸然

的花费时间研读。Boost另外一面，比如Graph这样的库则是具有工业强度，结构良好，非常值得研读的

精品代码，并且也可以放心的在产品代码中多多利用。

         参考站点： http://www.boost.org 
         （国内镜像： http://www.c-view.org/tech/lib/boost/index.htm ）

GUI

在众多C++的库中，GUI部分的库算是比较繁荣，也比较引人注目的。在实际开发中，GUI库的选择也是

非常重要的一件事情，下面我们综述一下可选择的GUI库，各自的特点以及相关工具的支持。

1、   MFC

大名鼎鼎的微软基础类库（Microsoft Foundation Class）。大凡学过VC++的人都应该知道这个库。虽

然从技术角度讲，MFC是不大漂亮的，但是它构建于Windows API 之上，能够使程序员的工作更容易,编

程效率高，减少了大量在建立 Windows 程序时必须编写的代码，同时它还提供了所有一般 C++ 编程的

优点，例如继承和封装。MFC 编写的程序在各个版本的Windows操作系统上是可移植的，例如，在

Windows 3.1下编写的代码可以很容易地移植到 Windows NT 或 Windows 95 上。但是在最近发展以及

官方支持上日渐势微。

2、   QT    
         参考网站：http://www.trolltech.com/

Qt是Trolltech公司的一个多平台的C++图形用户界面应用程序框架。它提供给应用程序开发者建立艺术

级的图形用户界面所需的所用功能。Qt是完全面向对象的很容易扩展，并且允许真正地组件编程。自从

1996年早些时候，Qt进入商业领域，它已经成为全世界范围内数千种成功的应用程序的基础。Qt也是流

行的Linux桌面环境KDE 的基础，同时它还支持Windows、Macintosh、Unix/X11等多种平台。

3、WxWindows    
         参考网站：http://www.wxwindows.org/

跨平台的GUI库。因为其类层次极像MFC，所以有文章介绍从MFC到WxWindows的代码移植以实现跨平台的

功能。通过多年的开发也是一个日趋完善的GUI库，支持同样不弱于前面两个库。并且是完全开放源代

码的。新近的C++ Builder X的GUI设计器就是基于这个库的。

4、Fox     
         参考网站：http://www.fox-toolkit.org/

开放源代码的GUI库。作者从自己亲身的开发经验中得出了一个理想的GUI库应该是什么样子的感受出发

，从而开始了对这个库的开发。有兴趣的可以尝试一下。

5、WTL

基于ATL的一个库。因为使用了大量ATL的轻量级手法，模板等技术，在代码尺寸，以及速度优化方面做

得非常到位。主要面向的使用群体是开发COM轻量级供网络下载的可视化控件的开发者。

6、GTK    
         参考网站：http://gtkmm.sourceforge.net/

GTK是一个大名鼎鼎的C的开源GUI库。在Linux世界中有Gnome这样的杀手应用。而GTK就是这个库的C++

封装版本。

网络通信

ACE       
         参考网站：http://www.cs.wustl.edu/~schmidt/ACE.html

C++库的代表，超重量级的网络通信开发框架。ACE自适配通信环境（Adaptive Communication

Environment）是可以自由使用、开放源代码的面向对象框架，在其中实现了许多用于并发通信软件的

核心模式。ACE提供了一组丰富的可复用C++包装外观（Wrapper Facade）和框架组件，可跨越多种平台

完成通用的通信软件任务，其中包括：事件多路分离和事件处理器分派、信号处理、服务初始化、进程

间通信、共享内存管理、消息路由、分布式服务动态（重）配置、并发执行和同步，等等。

StreamModule    
            参考网站：http://www.omnifarious.org/StrMod/

设计用于简化编写分布式程序的库。尝试着使得编写处理异步行为的程序更容易，而不是用同步的外壳

包起异步的本质。

SimpleSocket       
            参考网站：http://home.hetnet.nl/~lcbokkers/simsock.htm

这个类库让编写基于socket的客户/服务器程序更加容易。

A Stream Socket API for C++

            参考网站：    http://www.pcs.cnu.edu/~dgame/sockets/socketsC++/sockets.html

又一个对Socket的封装库。

XML

Xerces   
                     参考网站：http://xml.apache.org/xerces-c/

Xerces-C++ 是一个非常健壮的XML解析器，它提供了验证，以及SAX和DOM API。XML验证在文档类型定

义(Document Type Definition，DTD)方面有很好的支持，并且在2001年12月增加了支持W3C XML

Schema 的基本完整的开放标准。

XMLBooster      
                     参考网站：http://www.xmlbooster.com/

这个库通过产生特制的parser的办法极大的提高了XML解析的速度，并且能够产生相应的GUI程序来修改

这个parser。在DOM和SAX两大主流XML解析办法之外提供了另外一个可行的解决方案。

Pull Parser

          参考网站： http://www.extreme.indiana.edu/xgws/xsoap/

 这个库采用pull方法的parser。在每个SAX的parser底层都有一个pull的parser，这个xpp把

这层暴露出来直接给大家使用。在要充分考虑速度的时候值得尝试。

Xalan

         参考网站： http://xml.apache.org/xalan-c/

         Xalan是一个用于把XML文档转换为HTML，纯文本或者其他XML类型文档的XSLT处理器。

CMarkup

         参考网站： http://www.firstobject.com/xml.htm

         这是一种使用EDOM的XML解析器。在很多思路上面非常灵活实用。值得大家在DOM和SAX之外寻

求一点灵感。

libxml++

                  参考网站   http://libxmlplusplus.sourceforge.net/

libxml++是对著名的libxml XML解析器的C++封装版本

科学计算

Blitz++

         参考网站： http://www.oonumerics.org/blitz/

Blitz++ 是一个高效率的数值计算函数库，它的设计目的是希望建立一套既具像C++ 一样方便，同时又

比Fortran速度更快的数值计算环境。通常，用C++所写出的数值程序，比 Fortran慢20%左右，因此

Blitz++正是要改掉这个缺点。方法是利用C++的template技术，程序执行甚至可以比Fortran更快。

Blitz++目前仍在发展中，对于常见的SVD，FFTs，QMRES等常见的线性代数方法并不提供，不过使用者

可以很容易地利用Blitz++所提供的函数来构建。

POOMA

         参考网站： http://www.codesourcery.com/pooma/pooma

POOMA是一个免费的高性能的C++库，用于处理并行式科学计算。POOMA的面向对象设计方便了快速的程

序开发，对并行机器进行了优化以达到最高的效率，方便在工业和研究环境中使用。

MTL      
                   参考网站：http://www.osl.iu.edu/research/mtl/

Matrix Template Library(MTL)是一个高性能的泛型组件库，提供了各种格式矩阵的大量线性代数方面

的功能。在某些应用使用高性能编译器的情况下，比如Intel的编译器，从产生的汇编代码可以看出其

与手写几乎没有两样的效能。

CGAL       
         参考网站：www.cgal.org

Computational Geometry Algorithms Library的目的是把在计算几何方面的大部分重要的解决方案和

方法以C++库的形式提供给工业和学术界的用户。

游戏开发

Audio/Video 3D C++ Programming Library

         参考网站： http://www.galacticasoftware.com/products/av/

AV3D是一个跨平台，高性能的C++库。主要的特性是提供3D图形，声效支持（SB,以及S3M），控制接口

（键盘，鼠标和遥感），XMS。

KlayGE

         参考网站： http://home.g365.net/enginedev/

国内游戏开发高手自己用C++开发的游戏引擎。KlayGE是一个开放源代码、跨平台的游戏引擎，并使用

Python作脚本语言。KlayGE在LGPL协议下发行。感谢龚敏敏先生为中国游戏开发事业所做出的贡献。

OGRE

         参考网站： http://www.ogre3d.org

OGRE（面向对象的图形渲染引擎）是用C++开发的，使用灵活的面向对象3D引擎。它的目的是让开发者

能更方便和直接地开发基于3D硬件设备的应用程序或游戏。引擎中的类库对更底层的系统库（如：

Direct3D和OpenGL）的全部使用细节进行了抽象，并提供了基于现实世界对象的接口和其它类。

线程

C++ Threads

         参考网站： http://threads.sourceforge.net/

这个库的目标是给程序员提供易于使用的类，这些类被继承以提供在Linux环境中很难看到的大量的线

程方面的功能。

ZThreads

         参考网站： http://zthread.sourceforge.net/

一个先进的面向对象，跨平台的C++线程和同步库。

序列化

s11n

         参考网站： http://s11n.net/

一个基于STL的C++库，用于序列化POD，STL容器以及用户定义的类型。

Simple XML Persistence Library

         参考网站： http://sxp.sourceforge.net/

这是一个把对象序列化为XML的轻量级的C++库。

字符串

C++ Str Library

         参考网站： http://www.utilitycode.com/str/

操作字符串和字符的库，支持Windows和支持gcc的多种平台。提供高度优化的代码，并且支持多线程环

境和Unicode，同时还有正则表达式的支持。

Common Text Transformation Library

         参考网站： http://cttl.sourceforge.net/

这是一个解析和修改STL字符串的库。CTTL substring类可以用来比较，插入，替换以及用EBNF的语法

进行解析。

GRETA

         参考网站： http://research.microsoft.com/projects/greta/

这是由微软研究院的研究人员开发的处理正则表达式的库。在小型匹配的情况下有非常优秀的表现。

综合

P::Classes

         参考网站： http://pclasses.com/

一个高度可移植的C++应用程序框架。当前关注类型和线程安全的signal/slot机制，i/o系统包括基于

插件的网络协议透明的i/o架构，基于插件的应用程序消息日志框架，访问sql数据库的类等等。

ACDK - Artefaktur Component Development Kit

void outdata(A &s)
{
 cout<<"out data:"<<s.name<<endl;
}

void main()
{
 string t="tim";
 A s1(t);
 outdata(s1);
}