C++模板階段性小結

在上面的第一個例子中，最容易出錯的就是下面這種情況：

int a[10], b[12];

test(a, b);

你以為a和b都是int類型的數組，然而結果確出乎你的意料：

錯誤：對‘test(int [10], int [12])’的調用沒有匹配的函數

我們知道，數組作為實參時，實際上會發生類型退化——int類型的數組將退化為指針int *。然而當我們為這個參數加上引用時，退化將不會發生，此時傳遞的不再是一個指針，而是整個數組，別忘了，數組是有大小的——也就是 int[10]和int[12]實際上是兩種不同的類型！

關於const轉換：
1.接受const**引用**或const指針的函數可以分別使用非const對象的引用或指針來調用，無需產生新的實例化——將非const傳遞給const是安全的。

2.如果函數接受非引用類型，形參類型和實參都忽略const——對於pass by value來說，const實參傳遞給非const形參並不會對實參造成任何影響。

模板編譯模型

如果你已經理解了模板本身不是類或函數，那麼這個知識點對你來說是很好理解的。

有了以上的基礎，我們再來聊一聊模板編譯模型。

模板編譯模型有兩種：包含編譯模型 和 分別編譯模型。

在包含編譯模型中：

1.只有在看到用到模板時編譯器才產生特定的模板實例。

2.要進行實例化，編譯器必須能夠訪問定義模板的源代碼。

第一點很好理解，沒有往模子到倒任何材料，編譯器永遠不知道會生產出什麼味道的蛋糕。

而第二點可以這樣理解：你說你有個蛋糕模子，但是卻不把模子給我，我無法給你生產你要的蛋糕。

這種編譯模型是最直觀的，所以編譯器都支持。

而分別編譯模型只有小部分編譯器支持，然而新的C++標准已經把支持這一方式的export關鍵字去掉了，因此此處不再討論。

非類型模板參數

非類型模板參數實參必須是編譯時常量表達式。

template 
class Test
{
    public:
        Test(): m_height(height), m_width(width) {}
    private:
        int m_height;
        int m_width;
};

int main()
{
    Test<80, 60> myTest;
}

//test.h

template
class Test
{
    public:
        void setData(const T&);
        const T getData();
    private:
        T m_value;
};

//test.cpp
#include "test.h"

template
void Test::setData(const T& value)
{
    m_value = value;
}

template
const T Test::getData()
{
    return m_value;
}

//顯式實例化
template class Test;

//錯誤語法
//template Test;
//template<> Test;

template 
struct Factorial
{
    enum { value = n * Factorial::value };
};

template<>  //特殊情況
struct Factorial<0>
{
    enum { value = 1 };
}

class Widget
{
public:
    Widget();
    virtual ~Widget();
    virtual std::size_t size() const;
    virtual void normalize();
    void swap(Widget& other);
};

//顯式接口和運行時多態的例子
void doProcessing(Widget& w)
{
    if (w.size() > 10 && w != someNastyWidget)
    {
        Widget temp(w);
        temp.normalize();
        temp.swap(w);
    }
}

template
void doProcessing(T& w)
{
    if (w.size() > 10 && w != someNastyWidget)
    {
        T temp(w);
        temp.normalize();
        temp.swap(w);
    }
}

if (w != someNastyWidget)

template 
void print2nd(const C& container)
{
    C::const_iterator* x;
    ...
}

template 
void print2nd(const C& container)
{
    typename C::const_iterator* x; //這才是合法的C++代碼
    ...
}

template 
class Derived: public Base::Nested   //不允許typename
{
public:
    explicit Dervied(int x)
    : Base::Nested(x)    //不允許typename
    {
        typename Base::Nested temp;    //必須typename
        ...
    }
};

#include 

using namespace std;

void print( int iNum )
{
         cout<<"int print( int )"<< endl;
}

template < typename T >

void print( T type )
{
           typename T::value_type vt_someval;
           cout<<"template < typename T >"<< endl;
}

int main()
{
         short sNum = 10;
         print( sNum );
         return 0;
}

In function ‘void print(T) [with T = short int]’:
    instantiated from here
錯誤：‘short int’不是類、結構或聯合類型

#include 

using namespace std;

void print( int iNum )
{
         cout<<"int print( int )"<< endl;
}

template < typename T >
void print( T type, typename T::value_type* pvt_dummy = NULL )
{
           typename T::value_type vt_someval;
           cout<<"template < typename T >"<< endl;
}
int main()
{
         short sNum = 10;
         print( sNum );
         return 0;
}

typedef char TrueType;
typedef struct{char a[2];} FalseType;

template
static TrueType TestIsClass(int C::*); //參數是int*類型，在C作用於下，返回類型為TrueType

template
static FalseType TestIsClass(...); // 參數任意，返回類型為FalseType

template
class IsClass
{
    public:
        enum { OK = (sizeof(TestIsClass(0)) == sizeof(TrueType)) };
};

class IsClass
{
    public:
        enum { OK = (sizeof(TestIsClass(0)) == sizeof(TrueType)) }; //這裡的計算將會在編譯時完成，因此編譯結束後，OK只是一個true或者false而已。
};

template
static TrueType TestIsClass(int C::*);

enum { OK = (sizeof(TrueType) == sizeof(TrueType)) };

class IsClass
{
    public:
        enum { OK = (sizeof(TestIsClass(0)) == sizeof(TrueType)) };
};

enum { OK = (sizeof(FalseType) == sizeof(TrueType)) };