C++开发指导之使用编译期的契约：约束，在编译期发现程序的错误

此文版权属于作者所有，任何人、媒体或者网站转载、借用都必须征得作者本人同意！

利用 C/C++ 编译器对源程序进行编译的时候会检查语法错误和计算常量等特性，可以给我们的 C/C++ 源代码添加一些编译期的契约，要求源代码按一定的规则使用，这样的好处是可以减少很多使用错误，减少软件的 bug ，因为这些 bug 在代码编译的时候就发现了，不用等测试或现场使用时才发现。

下面举一些编译期的契约，约束例子。

1.        must_have_base() 必须继承自

template <typenameD, typename B>

struct must_have_base

{

     ~must_have_base()

     {

         void (*p)(D*,B*) = constraints;

     }

private :

     static void constraints(D*pd, B* pb)

     {

         pb = pd;

     }

};

模板原理：子类指针可以直接赋值给基类指针。

使用场景举例：

class Base

{

public :

     Base();

};

template <classT>

class C : must_have_base<T,Base>

{ /* ... */ };

这个例子要求你使用模板类 C 时，模板参数必须继承自类 Base 。

2.        must_be_subscriptable() 必须可以按下标方式访问

template <typenameT>

struct must_be_subscriptable

{

     static void constraints(Tconst &T_is_not_subscriptable)

     {

         sizeof(T_is_not_subscriptable[0]);

     }

};

模板原理：就是按下标方式来访问进行检验。

使用场景举例：

template <classT>

void fun(T& t)

{

     must_be_subscriptable<T>constraint;

     // t[0] ?

     // ...

}

要求输入参数要求可以用下标来访问

3.        must_be_subscriptable_as_decayable_pointer() 必须可以按下标方式访问，并且可以退化为原生指针

template <typenameT>

struct must_be_subscriptable_as_decayable_pointer

{

     static void constraints(Tconst &T_is_not_decay_subscriptable)

     {

         sizeof(0[T_is_not_decay_subscriptable]);

     }

};

模板原理：原生指针的特性，通过下标访问可以反过来，就是即可以这样 pointer[offset] 使用指针，也可以这样 offset[pointer]使用指针。

4.        must_be_pod() 必须为 POD 类型

POD 类型： POD 意思是“ plain-old-data ”（ C++-98:1.8;5 ），它是 C++ 中的一个重要概念。 POD 类型必修满足以下条件：

将组成它的一个对象的各字节拷贝到一个字节数组中，然后再将它们重新拷贝回原先的对象所占的存储区中；此时对象应该仍具有它原来的值。

POD 类型定义：标量类型、 POD 结构类型、 POD 联合类型，这些类型的数组，以及这些类型以 const/volatile 修饰的版本。

POD 结构：一个聚合体类，其任何非静态成员的类型都不能是如下任意一种：指向成员的指针、非 POD 联合，以及以上这些类型的数组或引用，同时该聚合体类不允许包含用户自定义的拷贝赋值操作符和用户自定义的析够函数。

POD 类型的重要作用： POD 类型允许 C++ 与 C 交互！

template <typenameT>

struct must_be_pod

{

     static void constraints()

     {

         union{ T T_is_not_POD_type; };

     }

};

模板原理：利用 POD 类型可以放在 union 中实现这个约束。

使用场景举例：

template <typenameT>

union must_be_pod

{

     T t;

};

template <typenameT>

void SafeZeroMemory(T* p, size_t size)

{

     must_be_pod<T>();

     memset(p, 0,size);

}

class A

{

public :

     ~A(){}

     void Reset() { _value = 0; }

private :

     int _value;

};

class B

{

public :

     void Reset() { _value = 0; }

private :

     int _value;

};

class C

{

private :

     int _value;

};

void TestImpl()

{

     A a;

     B b;

     C c;

     int i = 0;

     int* p = 0;

     SafeZeroMemory(&a,sizeof(a)); // 编译失败

     SafeZeroMemory(&b,sizeof(b)); // 编译通过

     SafeZeroMemory(&c,sizeof(c)); // 编译通过

     SafeZeroMemory(&i,sizeof(i)); // 编译通过

     SafeZeroMemory(&p,sizeof(p)); // 编译通过

};

上面例子中，类 A 有析构函数，因此它不是 POD 结构。

一个类或结构如果有构造函数、析构函数、复制构造函数、赋值函数、或虚函数、它从非 POD 的类或结构继承或者从多个类继承，都不是 POD 结构。

5.       must_be_same_size()大小必须相同

template <typenameT>

struct size_of

{

     enum{ value = sizeof(T) };

};

template <>

struct size_of<void>

{

     enum{ value = 0 };

};

template <typenameT1, typename T2>

struct must_be_same_size

{

public :

     ~must_be_same_size()

     {

         void (*pfn)(void) =constraints;

         (void)(pfn);

     }

private :

     static void constraints()

     {

         struct must_be_same_size_

         {

              int T1_must_be_same_size_as_T2 : size_of<T1>::value ==size_of<T2>::value;

         };

     }

};

模板原理：已命名位域不能有零宽度。

使用场景举例：

template <typenameT1, typename T2>

void ObjCopy(T1& l, const T2&r)

{

     must_be_same_size<T1,T2>();

     must_be_pod<T1>();

     must_be_pod<T2>();

     memcpy(&l, &r,sizeof(l));

}

struct A { int foo; };

struct B { int foo; };

struct C { char foo; };

void TestImpl()

{

     A a;

     B b;

     C c;

     ObjCopy(a,b); // 编译通过

     ObjCopy(a,c); // 编译失败

}

上述例子中，结构 C的大小和结构 A的不同，因此编译失败。