积木

说明：
      本文来自CSDN博客：http://blog.csdn.net/goodluckyxl/archive/2005/01/19/259851.aspx

强制转化无论从语法还是语意上看，都是c++中最难看的特征之一。但是基于c风格的转化的语义的不明确性及其一些潜在问题。强制类型转化最终还是被c++接受了。
1.static_cast运算符号
static_cast<T>(e),stroustrup让我们可以把它看成隐含转换的显示的逆运算。这个是有一定道理的，基于隐式转化的对象类型我们可以使用static_cast转化运算符号。它是静态的检测，无法运行时检测类型，在继承中尤为突出。
使用范围
<1>用于所有系统类型之间转化，不能用于系统类型指针类型转化
  double t_d = 0;
int t_i= static_cast<int>(t_d); //是合法的转化
而企图将double*->int*是不允许的
<2>用于继承类之间的转化（含指针），不能用于其他没有隐式转化的对象类型之间的转化
继承举例:
class x
{
};
class y: public x
{
};
使用:x t_o_x;
y t_o_y = static_cast<y>(t_o_x); //x* y*转化也可以进行因为x,y继承关
//系，类型可以自动隐式转化使用
   隐式转化举例:
class x
{
};
class y
{

public:
    y( x i_x ) {}
};
    x t_o_x;
     y t_o_y = static_cast<y>(t_o_x); //大家看到y构造函数可以对于x类型隐式转化
//所以可以将x->y，如果企图将y->x会报错
2.reinterpret_cast 运算
主要用于对于类型指针类型的强制转化，some_type* -> special_type*这样转化，类型信息可以是不完全的。它允许将任意指针转化到其他类型指针，也允许任意整数类型到任意指针类型转化(BT)。这样导致的结果是极其不安全的，不能安全的应用于其他目的，除非转化到原来类型。
<1> 使用所有整形可以转化为任意类型的指针(指针是4字节的long的东东，那么机器就认为同类型就是可以转化)
int c;
x* p = reinterpret_cast<x*>(c); //x是自定义的任意类型，当然包括系统类型
<2> 可以对于任意类型指针之间转化
y* c;
x* p = reinterpret_cast<x*>(c);//x,y代表所有自定义或系统类型
大家可以看到reinterpret_cast的转化是极度的不负责任的，他只管转化不检测是否可以转化。
<3> const_cast运算符号
这个很简单从名字大家可以看出来，仅仅为了去掉或着加上const修饰符号。但是对于本身定义时为const的类型，即使你去掉const性，在你操作这片内容时候也要小心，只能r不能w操作，否则还是会出错。
const char* p = "123";
char* c = const_cast<char*>(p);
c[0] = 1;  //表面上通过编译去掉了const性，但是操作其地址时系统依然不允许这
//么做。这是一个漏洞吧
<4> dynamic_cast运算符号
Scott Mayers将其描述为用来执行继承体系中：安全的向下转型或者跨系转型动作。也就是说你可以，用dynamic_cast将 指向base class的指针或引用转型为 指向子类的对象的指针或引用。
class B {};  //polymorphic类型含virtual才能dynamic_cast
class D: public B {}
void f( B* pb )
{
    D* pd1 = dynamic_cast<D*>(pb);//如果pb为d类型正确返回，如果不是返回0
    D* pd2 = static_cast<D*>(pb); //不管怎么样都返回指针有可能指向不合适的对
//象，因为static仅仅静态检测，不能得到运
//行时对象的信息是否真正为D类型
}

反正大家在使用知道怎么用就ok了，c++强制转化在模板中还是非常有用的，其他时候本人也喜欢用c的转化方便。^_^

 1class Strategy
 2{
 3public:
 4  //
 5  virtual void Func1(void) = 0;
 6  virtual void Func2(void) = 0;//这两个接口只是示例
 7  // some other interfaces here
 8};
 9
10class Sub1 : Strategy
11{
12public:
13  void Func1(void)
14  {
15    // do something
16  }
17  void Func2(void)
18  {
19    // do something
20  }
21};
22
23class Sub2 : Strategy
24{
25public:
26  void Func1(void)
27  {
28    // do something
29  }
30  void Func2(void)
31  {
32    // do something
33  }
34};
35
36class Strategy;
37//策略类结构
38class Context
39{
40public:
41  Context(const Strategy* pStrategyObj) : m_pStrategyObj(pStrategyObj) {}
42  // 
43  // 逻辑接口DoAction
44  void DoAction(void)
45  {
46    if (NULL != m_pStragegyObj)
47    {
48      m_pStrategyObj->Func1();
49      m_pStrategyObj->Func2();
50      // 
51    }
52  }
53};

    注意：设计模式中，更提倡优先使用组合，而非继承。详细原因，也可以从以上模式比较得出。

 该模式也相对简单。其主要处理的是这类问题：当系统或某些模块已经成形后，突然需要增加某些功能。而这些功能的增加
在现有的对象中，暂时没有办法处理。同时，却发现，该功能，其实另一模块的对象却可以处理的了。因此，就希望能够在不修改原
有操作及系统结构的情况下，就自然而然地将该功能实现出来。此时，就可以使用Adapter来处理之。（注：在此，我们强调的是不
去修改原有系统的结构的情况下）。
 就上述问题，Adapter模式有两种解决方法。一种是通过对象适配来解决。另一种是通过类适配来解决。所谓的对象适配，指
的是，通过引入具有我们需要功能接口的对象（设类为X），在实现处理过程中，我们使用的是X的功能接口，以此来达到我们的需求。
而类适配，则指的是，产生一个新类，让该新类，继承自X类，则自然，该新类就会有了X的相关接口。下面看下，这两种适配的代码。

对象适配
class X
{
public:
 ...
 virtual func(...);
};

class ObjAdapterObject : public ...
{
public:
 void func(...)
 {
  if (m_pXObj != NULL)
   m_pXObj->func(...);
 }
private:
 X* m_pXObj;
};

类适配
class X的声明及定义同上。

class ClassAdapterObject: public X, public  ...
{
public:
 ...
};

以下调用就不写了，你懂得的。