我爱米井~~~

 double d[2] = {100.0,200.0};
00E13601  fld         qword ptr [__real@4059000000000000 (0E157B0h)]
00E13607  fstp        qword ptr [d]
00E1360A  fld         qword ptr [__real@4069000000000000 (0E15740h)]
00E13610  fstp        qword ptr [ebp-34h]
 double* pd = d;
00E13613  lea         eax,[d]
00E13616  mov         dword ptr [pd],eax
 double tmp = 1[pd];
00E13619  mov         eax,dword ptr [pd]
00E1361C  fld         qword ptr [eax+8]
00E1361F  fstp        qword ptr [tmp]
 tmp = pd[1];
00E13622  mov         eax,dword ptr [pd]
00E13625  fld         qword ptr [eax+8]
00E13628  fstp        qword ptr [tmp]

博大精深。。。。莫非还记录了偏移量的类型。。。那我平时的便宜都是unsigned int啊。。。cow....他是怎么办到的。。。

#define MUST_HAVE_BASE(D,B) do{must_has_base<D,B> i;}while(0)
#define MUST_BE_SUBSCRIPTABLE_AS_DECAYABLE_POINTER(T) do{must_be_subscriptable_as_decayable_pointer<T> i;}while(0)
#define MUST_BE_SUBSCRIPTABLE(T) do{must_be_subscriptable<T> i;}while(0)

template <class D, class B>
struct must_has_base
{
 ~must_has_base()
 {
  void (*p)(D*,B*) = constraint;
 }
private:
 static void constraint(D* pd, B* pb)
 {
  pb = pd;
 }
};

template <class T>
struct must_be_subscriptable_as_decayable_pointer
{
 ~must_be_subscriptable_as_decayable_pointer()
 {
  void (*p)(T const&) = constraint;
 }
private:
 static void constraint(T const& T_is_not_decay_subscriptable)
 {
  sizeof(0[T_is_not_decay_subscriptable]);//can only be done by pointers
 }
};

template <class T>
struct must_be_subscriptable
{
 ~must_be_subscriptable()
 {
  void (*p)(T const&) = constraint;
 }
private:
 static void constraint(T const& T_is_not_subscriptable)
 {
  sizeof(T_is_not_subscriptable[0]);
 }
};

class A
{
};

class B:public A
{
public:
 B operator[](size_t index) const;
 B& operator[](size_t index);
};

class C
{
};

int main()
{
//////////////////////////////////////////////////////////////////////////
// Sample of decay-able pointer

 int a = 100;
 int* p = &a;
 printf("%d\n",0[p]);

//
//////////////////////////////////////////////////////////////////////////
// Sample of MUST_HAVE_BASE
  MUST_HAVE_BASE(B,A);
 MUST_HAVE_BASE(int,void);
  MUST_HAVE_BASE(C,A);

//  
//////////////////////////////////////////////////////////////////////////
// Sample of MUST_BE_SUBSCRIPTABLE
 MUST_BE_SUBSCRIPTABLE(int*);
 MUST_BE_SUBSCRIPTABLE(int[10]);
 MUST_BE_SUBSCRIPTABLE(B);
 MUST_BE_SUBSCRIPTABLE(C);

//
//////////////////////////////////////////////////////////////////////////
// Sample of MUST_BE_SUBSCRIPTABLE_AS_DECAYABLE_POINTER
 MUST_BE_SUBSCRIPTABLE_AS_DECAYABLE_POINTER(int*);
 MUST_BE_SUBSCRIPTABLE_AS_DECAYABLE_POINTER(B);

//

 return 0;
}

#define MUST_HAVE_BASE(D,B) do{must_has_base<D,B> i;}while(0)

template <class D, class B>
struct must_has_base
{
 ~must_has_base()
 {
  void (*p)(D*,B*) = constraint;
 }
private:
 static void constraint(D* pd, B* pb)
 {
  pb = pd;
 }
};

class A
{
};

class B:public A
{
};

class C
{
};

int main()
{
 MUST_HAVE_BASE(B,A);
 MUST_HAVE_BASE(int,void);//solutions on postcard please..作者很可爱啊
 MUST_HAVE_BASE(C,A);
}

class _OnlyOnHeap
{
public:
 static T* NewHeapObject();
 static void FreeHeapObject(const T * const pOnlyOnHeap);
protected:
 _OnlyOnHeap(){};
 _OnlyOnHeap(_OnlyOnHeap& _other){};
 _OnlyOnHeap& operator=(const _OnlyOnHeap& _other){};
};



template <class T>
T* _OnlyOnHeap<T>::NewHeapObject()
{
 return new T;
}

template <class T>
void _OnlyOnHeap<T>::FreeHeapObject( const T * const pOnlyOnHeap )
{
 delete pOnlyOnHeap;
}




class A:public _OnlyOnHeap<A>
{
 friend _OnlyOnHeap<A>;
protected:
 A(){printf("construct A\n");}
 ~A(){printf("destruct A\n");}
};

int _tmain(int argc, _TCHAR* argv[])
{
 //A I_am_on_stack;//compile error 无法访问 private 成员(在“_OnlyOnHeap<T>”类中声明)
  //A* p_I_am_on_heap = new A;//compile error 无法访问 private 成员(在“_OnlyOnHeap<T>”类中声明)

 A* p_I_am_on_heap = A::NewHeapObject();
 A::FreeHeapObject(p_I_am_on_heap);

 return 0;
}