你可能經常需要利用運行時斷言技術，它可以方便地測試前提條件。但是，隨著Metaprogramming概念的出現，編譯時斷言技術也已經和runtime assertion一樣的普遍了。如何在編譯時進行斷言呢？其實，方法只有一個，就是讓編譯器生成一條錯誤信息，但是編譯器生成的錯誤信息信息性往往有又理想。并且，即使你在一種編譯上設計了一種方案，你也很難把它移植到其他的編譯器上。我們通過其實現方法的改進和一個Boost中的例子，來看看如何更好的實現這種技術。
例如，你需要一個安全的類型轉換機制，它只允許你把個頭小的類型轉換為個頭大的類型。此時，就可以利用Compile-time Assertion解決這個問題。
template <typename To, typename From>
To safe_reinterpret_cast(From from) {
assert(sizeof(To) >= sizeof(From));
return reinterrupt_cast (from);
};
而后，就像你使用同樣的 C++ 類型轉換一樣來使用這個 safe_reinterpret_cast ：
long l = 255;
short s = safe_reinterpret_cast<short>(l);
這樣一來，你就可以確保只有在小 à 大的轉換才是正確的，如果進行非法的轉換，就會在運行時發生斷言。
顯然，如果能夠在編譯時給用戶指出代碼中的問題更為合適一些。如果這個轉換只在程序很少被執行到的一個分支上被執行，那么當你把它移植到一個新的編譯器上或平臺上的時候，你就有可能忘記程序中所有不可移植的部分，例如上面提到的 reinterrupt_cast ，從而給你的程序帶來不必要的 bug 。
其實，上面我們被評估的表達式是一個編譯器常量，也就是說你完全有可以讓編譯器取代運行時代碼來進行檢查。解決的思路是在表達式為 true 的時候給編譯器傳遞正確的代碼，而在表達式為 false 的時候給編譯器提供一個語法錯誤的代碼，這樣，當被評估的表達式為 0 的時候，編譯器就會發出一個錯誤信號。
最簡單的 compile-time assertion 解決方案是 Van Horn 在 1997 年提出的，它可以在 C 和 C++ 的代碼中工作，依賴的條件很簡單，數組的長度不能為 0 。
#define STATIC_CHECK(expr) { char unnamed[(expr ? 1 : 0)]; }
現在，如果你寫下下面的代碼：
template <typename To, typename From>
To safe_reinterpret_cast(From from) {
STATIC_CHECK(sizeof(To) >= sizeof(From));
return reinterpret_cast (from);
};
… …
void * somePointer = 0;
char c = safe_reinterpret_cast<char>(somePointer);
如果 void* 的長度小于 char( 這個并沒有在目前的 C++ 標準的規定 ) ，編譯器就會告訴你創建了一個長度為 0 的數組。
問題是這個方法提供的錯誤信息并不是很說明問題。“不能創建長度為0的數組”并不能表示“char類型放不下一個指針”。這種方法很難想用戶提供customized message。錯誤信息的來源并不是因為代碼違法了程序設計的意圖，而是因為破壞了某些語法規則。
更好的解決方案是依賴一個模板提供一個具有說明性的名字，這樣，編譯器就會在錯誤信息中包含這個名字了。
template <bool> struct CompileTimeError;
template <> struct CompileTimeError<true> {};
#define STATIC_CHECK1(expr1) { (CompileTimeError<(expr1) != 0>()); }
CompileTimeError 帶有一個非類型參數，并且只有 true 的特化版本，這樣，當被評估的表達式不滿足條件時，編譯器就會抱怨沒有 CompileTimeError 的特化版本，這個比剛才的錯誤多多少少要好一些。
當然，這個設計仍然有很大的擴展空間。因為我們還是沒有辦法來訂制錯誤消息。一個簡單的辦法就是在 STATIC_CHECK 中加入一個消息參數，然后讓這個消息參數在錯誤信息中顯示。這個方法也有自己的缺點，就是你必須要保證傳遞給 C++ 的這個錯誤消息參數一定是合法的。于是我們可以對于上面的 CompileTimeError 做以下的改進：
template <bool> struct CompileTimeChecker {
CompileTimeChecker(...) {};
};
template <> struct CompileTimeChecker<false> { };
#define STATIC_CHECK2(expr2, msg) {\
class ERROR_##msg {}; \
sizeof((CompileTimeChecker<(expr2!=0)>((ERROR_##msg()))));\
}
template <typename To, typename From>
To safe_reinterpret_cast(From from) {
STATIC_CHECK2((sizeof(To) >= sizeof(From)),
Destination_Type_To_Narrow);
return reinterpret_cast (from);
};
這樣，當你仍舊使用剛才的代碼時：
void * somePointer = 0;
char c = safe_reinterpret_cast<char>(somePointer);
由于 CompileTimeChecker 可以接受任意參數，而特化的 CompileTimeChecker 并沒有這樣的構造函數，這樣，當被評估的表達式為 0 的時候，就會出現編譯時錯誤
cannot convert
from
'safe_reinterpret_cast::ERROR_Destination_Type_To_Narrow'
to
'CompileTimeChecker'
這次的錯誤信息變的比較有提示性了。
現實中的應用——BOOST_STATIC_ASSERT & boost::checked_delete
BOOST_STATIC_ASSERT
在boost/static_assert.hpp中定義了一個宏BOOST_STATIC_ASSERT，用于完成編譯時靜態檢查。其實現方式了我們的第2種方式很類似，利用了模板的特化技術
#define BOOST_STATIC_ASSERT( B ) \
typedef ::boost::static_assert_test<\
sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >)>\
BOOST_JOIN(boost_static_assert_typedef_, __COUNTER__)
其中：
template <int x> struct static_assert_test{};
#define BOOST_JOIN( X, Y ) X##Y
template <bool x> struct STATIC_ASSERTION_FAILURE;
template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
這里，只為 true 類型進行了特化，這樣，當我們嘗試聲明一個 STATIC_ASSERTION_FAILURE<false> 的時候就會引發編譯時錯誤。
這樣，整個宏的含義就是做了一個 typedef:
typedef ::boost::static_assert_test<evaluate condition> boost_static_assert_typedef___COUNTER__
而只有當evaluate condition為true的時候，這樣的typedef才是正確的，從而實現了編譯時斷言（上面的代碼只是msvc的實現，對不同的編譯器實現略有不同，但是思想是類似的）。
例子：確保一個模板參數的類型只能是整數
template <typename T> class only_compatible_with_integral_types {
BOOST_STATIC_ASSERT(boost::is_integral::value);
};
之后，如果你使用下面的定義：
only_compatible_with_integral_types<double> test2;
就會引發編譯錯誤：
use of undefined type 'boost::STATIC_ASSERTION_FAILURE
boost::checked_delete
當我們利用指針刪除一個對象的時候，對象類型是否完整決定了對象是否能夠被正確刪除。但是，如果你用 delete 去刪除一個類型并不完整的對象的指針，編譯器并不會給你提供任何錯誤信息，但是這樣做的結果卻是對象的析構函數根本就沒有被調用。
checked-delete 定義在 boost/checkd_delete.hpp 中，它可以保證在你摧毀一個對象的時候，必須對該對象的類型有完全的了解。先來看個例子：
#include
class some_class;
some_class* create() {
return (some_class*)0;
}
int main() {
some_class* p=create();
boost::checked_delete(p2);
}
編譯器就會抱怨 some_calss 是一個不完整的類型。在我們進一步去了解解決方案之前，我們先來看一個由于不完整類型帶來的 memory leak 的例子：
// in deleter.h
class to_be_deleted;
class deleter {
public :
void delete_it(to_be_deleted* p);
};
// in deleter.cpp
#include "deleter.h"
void deleter::delete_it(to_be_deleted* p) {
delete p; // !!!memory leak here
}
// in to_be_deleted.h
#include
class to_be_deleted {
class test {
public:
test() {};
~test() { std::cout<<"I'm destructed correctly!"<
};
test* p;
public :
to_be_deleted() { p = new test(); };
~to_be_deleted() {
delete p;
std::cout<<"I've important things to say!"<
}
};
之后用下面的測試代碼：
#include "deleter.h"
#include "to_be_deleted.h"
int main() {
to_be_deleted* p = new to_be_deleted();
deleter d;
d.delete_it(p);
return 0;
}
你會發現， to_be_deleted 的析構函數并沒有被調用，原因在于 deleter.cpp 中，并沒有包含 to_be_deleted.h ，這樣， delete 對于齊要刪除的指針一無所知，導致了析構函數并沒有真正被調用。
解決的方法也很簡單，利用 boost::checked_delete 進行刪除。
#include
#include "deleter.h"
void deleter::delete_it(to_be_deleted* p) {
//delete p; // memory leak here
boost::checked_delete(p);
}
這時，編譯器便會抱怨說 to_be_deleted 是未知的類型。其實 ,checked_delete 的實現原理是非常簡單的，只是說對于未知類型，使用 sizeof 運算符會返回 0 ，而 C++ 并不允許創建長度為 0 的數組。如下所示：
template <class T> inlinevoid checked_delete(T * x)
{
// intentionally complex - simplification causes regressions
typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
(void) sizeof(type_must_be_complete);
delete x;
}