《windows圖形編程》有講：

KTimer.h

#pragma?once
inline?unsigned?__int64?GetCycleCount( void )
{
????_asm?_emit? 0x0F
????_asm?_emit? 0x31
}

class ?KTimer??
{
????unsigned?__int64?m_startcycle;
public :
????unsigned?__int64?m_overhead;???? // RTSC指令的運行時間

????KTimer()
???? {
????????m_overhead? = ? 0 ;
????????Start();
????????m_overhead? = ?Stop();
????}
???? void ?Start();
????unsigned?__int64?Stop();
????unsigned?unsigned?GetCPUSpeed();

} ;

#include?"KTimer.h"

#include?<iostream>
#include?<windows.h>


void?KTimer::Start()
{
????m_startcycle?=?GetCycleCount();
}
unsigned?__int64?KTimer::Stop()
{
????return?GetCycleCount()?-?m_startcycle?-?m_overhead;
}
unsigned?unsigned?KTimer::GetCPUSpeed()
{
????cout?<<?"開始測試?cpu速度.."?<<?endl;
????Start();
????Sleep(1000);
????unsigned?cputime?=?Stop();
????unsigned?cpuspeed10?=?(unsigned)(cputime/100000);
????cout?<<?"CPU速度?每秒:"?<<?cputime?<<?"?clocks"?<<?endl;
????return?cpuspeed10?==?0???1?:?cpuspeed10;
}

#include?"stdafx.h"
#include?<tchar.h>
#include?<windows.h>
#include?<iostream>

#include?"KTimer.h"

int?main(int?argc,?char*?argv[])
{????
????KTimer?timer;

????unsigned?cpuspeed10?=?timer.GetCPUSpeed();

????timer.Start();
????
//做耗時操作
????
????unsigned?time?=?timer.Stop();

????TCHAR?mess[128];
????wsprintf(mess,_T("耗時:%d?ns"),?time?*?10000?/?cpuspeed10);
????cout?<<?mess?<<?endl;

????return?0;
}

書里面說的這個詞：
型別計算的邊界標記

NullType只有聲明沒有定義。

class NullType;

struct EmptyType {};

簡而言之：explicit修飾的構造函數不能擔任轉換函數

這個 《ANSI/ISO C++ Professional Programmer's Handbook 》是這樣說的

explicit Constructors
A constructor that takes a single argument is, by default, an implicit conversion operator, which converts its argument to
an object of its class (see also Chapter 3, "Operator Overloading"). Examine the following concrete example:
class string
{
private:
int size;
int capacity;
char *buff;
public:
string();
string(int size); // constructor and implicit conversion operator
string(const char *); // constructor and implicit conversion operator
~string();
};
Class string has three constructors: a default constructor, a constructor that takes int, and a constructor that
constructs a string from const char *. The second constructor is used to create an empty string object with an
initial preallocated buffer at the specified size. However, in the case of class string, the automatic conversion is
dubious. Converting an int into a string object doesn't make sense, although this is exactly what this constructor does.

Consider the following:
int main()
{
string s = "hello"; //OK, convert a C-string into a string object
int ns = 0;
s = 1; // 1 oops, programmer intended to write ns = 1,
}
In the expression s= 1;, the programmer simply mistyped the name of the variable ns, typing s instead. Normally,
the compiler detects the incompatible types and issues an error message. However, before ruling it out, the compiler first
searches for a user-defined conversion that allows this expression; indeed, it finds the constructor that takes int.
Consequently, the compiler interprets the expression s= 1; as if the programmer had written
s = string(1);
You might encounter a similar problem when calling a function that takes a string argument. The following example
can either be a cryptic coding style or simply a programmer's typographical error. However, due to the implicit
conversion constructor of class string, it will pass unnoticed:
int f(string s);
int main()
{
f(1); // without a an explicit constructor,
//this call is expanded into: f ( string(1) );
//was that intentional or merely a programmer's typo?
}
'In order to avoid such implicit conversions, a constructor that takes one argument needs to be declared explicit:
class string
{
//...
public:
explicit string(int size); // block implicit conversion
string(const char *); //implicit conversion
~string();
};
An explicit constructor does not behave as an implicit conversion operator, which enables the compiler to catch the
typographical error this time:
int main()
{
string s = "hello"; //OK, convert a C-string into a string object
int ns = 0;
s = 1; // compile time error ; this time the compiler catches the typo
}
Why aren't all constructors automatically declared explicit? Under some conditions, the automatic type conversion is
useful and well behaved. A good example of this is the third constructor of string:
string(const char *);

The implicit type conversion of const char * to a string object enables its users to write the following:
string s;
s = "Hello";
The compiler implicitly transforms this into
string s;
//pseudo C++ code:
s = string ("Hello"); //create a temporary and assign it to s
On the other hand, if you declare this constructor explicit, you have to use explicit type conversion:
class string
{
//...
public:
explicit string(const char *);
};
int main()
{
string s;
s = string("Hello"); //explicit conversion now required
return 0;
}
Extensive amounts of legacy C++ code rely on the implicit conversion of constructors. The C++ Standardization
committee was aware of that. In order to not make existing code break, the implicit conversion was retained. However, a
new keyword, explicit, was introduced to the languageto enable the programmer to block the implicit conversion
when it is undesirable. As a rule, a constructor that can be invoked with a single argument needs to be declared
explicit. When the implicit type conversion is intentional and well behaved, the constructor can be used as an
implicit conversion operator.

就是這樣一個結構：

template <typename T>
struct Type2Type
{
    typedef T OriginalType;    
};

template <class T,class U>
T* Create(const U& arg)
{
    return new T(arg);
}

//錯誤的代碼
template <class U>
Widget* Create<Widget,U>(const U& arg)
{
    return new Widget(arg,-1);
}

template <class T,class U>
T* Create(const U&arg,T /**//*虛擬*/)
{
   return new T(arg);
}

template <class U>
Widget * Create(const U& arg, Widget /**//*虛擬*/)
{
    return new Widget(arg,-1);
}

  這樣是可以解決問題，但最大的毛病在于運行時構造了 未被使用的對象這個開銷（虛擬的Widget參數）。這時 Type2Type 這個咚咚出場了，按照書的說法，這是“一個型別代表物、一個可以讓你傳給重載函數的輕量級ID”，如下：

template <class T,class U>
T* Create(const U& arg,Type2Type<T>)
{
    return new T(arg);
}

template <class U>
Widget * Create(const U& arg,Type2Type<Widget>)
{
    return new Widget(arg,-1);
}

調用方：
String *pStr = Create("hello",Type2Type<String>());
Widget *pW = Create(100,Type2Type<Widget>());

關鍵是，這個東西也是給編譯器看的，妙