首先先了解一個小知識點：
模板參數(shù)可以是數(shù)值型參數(shù)（非類型參數(shù)）,例如這樣：
template
<typename T, int N>
void func()
{
//使用模板參數(shù)定義局部數(shù)組
T a[N];
}
//使用
func<double, 10>();
這種數(shù)值型模板參數(shù)也有很多限制：
- 變量不能作為模板參數(shù)
- 浮點數(shù)不能作為模板參數(shù)
- 類對象不能作為模板參數(shù)
- ........
本質(zhì)：模板參數(shù)是在編譯階段被處理的單元，因此冻晤，在編譯階段必須準確無誤的唯一確定懂版。
了解完數(shù)值型模板參數(shù)這個知識點以后，再來做一個面試題：
用一個最高效的方法求1+2+3+4+....+N的值补憾！
或許大家會想到使用一個循環(huán)累加踪栋、遞歸跑筝、或者直接使用公式一步就可以得到結(jié)果套利。但這里介紹一個最高效的辦法奴璃，和上面的小知識點有關(guān)：
#include <iostream>
#include <string>
using namespace std;
//定義一個函數(shù)模板
template
< typename T, int N >
void func()
{
T a[N] = {0};
int sum = 0;
int i = 0;
for(i=0; i<N; i++)
{
a[i] = i;
}
for(i=0; i<N; i++)
{
sum += a[i];
}
sum += i;
cout << "func() " << N << " = "<< sum << endl;
}
//定義函數(shù)模板
template
< int N >
class Sum
{
public:
//遞歸
static const int VALUE = Sum<N-1>::VALUE + N;
};
//定義函數(shù)模板悉默，參數(shù)直接固定城豁，且為數(shù)值
template
< >
class Sum < 1 >
{
public:
static const int VALUE = 1;
};
int main()
{
func<int, 10>();
func<int, 100>();
cout << "1 + 2 + 3 + ... + 10 = " << Sum<10>::VALUE << endl;
cout << "1 + 2 + 3 + ... + 100 = " << Sum<100>::VALUE << endl;
return 0;
}
輸出結(jié)果為：
func() 10 = 55
func() 100 = 5050
1 + 2 + 3 + ... + 10 = 55
1 + 2 + 3 + ... + 100 = 5050
是不是會有疑問苟穆，代碼中表述了2中方式的求值過程。第一種是正常的方法唱星，直接for循環(huán)來累加求值雳旅；第二種是使用函數(shù)模板遞歸來求值〖淞模可是這兩種方式?jīng)]有什么不同呀攒盈！
其實這里是有區(qū)別的，我們都知道對于函數(shù)模板編譯器是分兩次編譯哎榴。那在這里對于func函數(shù)模板型豁，第一次編譯是編譯函數(shù)模板本身，第二次是替換參數(shù)后的代碼尚蝌，也就是說最終的值是在運行期main函數(shù)中調(diào)用這個函數(shù)迎变，傳入?yún)?shù)，然后求值飘言；那對于sum函數(shù)模板衣形，就不一樣了，第一次是編譯函數(shù)模板本身姿鸿，但是這里是使用遞歸谆吴，那就是說第一次編譯的時候就已經(jīng)把值求出來，第二次編譯是有一個靜態(tài)變量存在函數(shù)體中苛预。
對于兩種方法句狼，第一個是在運行期求值，會消耗掉計算量热某，第二個是在編譯器就求出來了腻菇，運行期直接輸出突诬，不消耗任何計算量。所以第二個方法更高效芜繁。
最后在這里用代碼闡述array類的內(nèi)部實現(xiàn)過程旺隙，分兩種實現(xiàn)，一種是在棧上開辟空間骏令，一種是在堆上開辟空間：
在棧上開辟空間演示（Array.h）
#ifndef _ARRAY_H_
#define _ARRAY_H_
template
< typename T, int N >
class Array
{
//array類成員變量蔬捷，為一個數(shù)組
T m_array[N];
public:
//獲取長度
int length();
//設(shè)置某一個索引的值
bool set(int index, T value);
//獲取某一個索引的值
bool get(int index, T& value);
//使用[]來獲取某一個索引的值
T& operator[] (int index);
T operator[] (int index) const;
//析構(gòu)函數(shù)
virtual ~Array();
};
//設(shè)置某一個索引的值
template
< typename T, int N >
int Array<T, N>::length()
{
return N;
}
//設(shè)置某一個索引的值
template
< typename T, int N >
bool Array<T, N>::set(int index, T value)
{
bool ret = (0 <= index) && (index < N);
if( ret )
{
m_array[index] = value;
}
return ret;
}
//獲取某一個索引的值
template
< typename T, int N >
bool Array<T, N>::get(int index, T& value)
{
bool ret = (0 <= index) && (index < N);
if( ret )
{
value = m_array[index];
}
return ret;
}
//使用[]來獲取某一個索引的值
template
< typename T, int N >
T& Array<T, N>::operator[] (int index)
{
return m_array[index];
}
//使用[]來獲取某一個索引的值
template
< typename T, int N >
T Array<T, N>::operator[] (int index) const
{
return m_array[index];
}
template
< typename T, int N >
Array<T, N>::~Array()
{
}
#endif
在堆上開辟空間演示（HeapArray.h）
#ifndef _HEAPARRAY_H_
#define _HEAPARRAY_H_
//定義類模板
template
< typename T >
class HeapArray
{
private:
//數(shù)組長度 外界不可訪問
int m_length;
//數(shù)組指針
T* m_pointer;
//設(shè)置長度
HeapArray(int len);
//拷貝構(gòu)造
HeapArray(const HeapArray<T>& obj);
//構(gòu)造
bool construct();
public:
//初始化類和申請數(shù)組空間
static HeapArray<T>* NewInstance(int length);
//獲取長度
int length();
//獲取某個索引的值
bool get(int index, T& value);
//設(shè)置某個索引的值
bool set(int index ,T value);
//使用[]符號來獲取某個索引的值
T& operator [] (int index);
T operator [] (int index) const;
//獲取當前類對象指針
HeapArray<T>& self();
~HeapArray();
};
template
< typename T >
HeapArray<T>::HeapArray(int len)
{
m_length = len;
}
template
< typename T >
bool HeapArray<T>::construct()
{
m_pointer = new T[m_length];
return m_pointer != NULL;
}
template
< typename T >
HeapArray<T>* HeapArray<T>::NewInstance(int length)
{
//初始化一個類
HeapArray<T>* ret = new HeapArray<T>(length);
//為類中的數(shù)組申請堆空間
if( !(ret && ret->construct()) )
{
delete ret;
ret = 0;
}
return ret;
}
template
< typename T >
int HeapArray<T>::length()
{
return m_length;
}
template
< typename T >
bool HeapArray<T>::get(int index, T& value)
{
bool ret = (0 <= index) && (index < length());
if( ret )
{
value = m_pointer[index];
}
return ret;
}
template
< typename T >
bool HeapArray<T>::set(int index, T value)
{
bool ret = (0 <= index) && (index < length());
if( ret )
{
m_pointer[index] = value;
}
return ret;
}
template
< typename T >
T& HeapArray<T>::operator [] (int index)
{
return m_pointer[index];
}
template
< typename T >
T HeapArray<T>::operator [] (int index) const
{
return m_pointer[index];
}
template
< typename T >
HeapArray<T>& HeapArray<T>::self()
{
return *this;
}
template
< typename T >
HeapArray<T>::~HeapArray()
{
delete[]m_pointer;
}
#endif
調(diào)用函數(shù)（main.cpp）：
#include <iostream>
#include <string>
#include "Array.h"
#include "HeapArray.h"
using namespace std;
int main()
{
Array<double, 5> ad;
for(int i=0; i<ad.length(); i++)
{
ad[i] = i * i;
}
for(int i=0; i<ad.length(); i++)
{
cout << ad[i] << endl;
}
cout << endl;
HeapArray<char>* pai = HeapArray<char>::NewInstance(10);
if( pai != NULL )
{
HeapArray<char>& ai = pai->self();
for(int i=0; i<ai.length(); i++)
{
ai[i] = i + 'a';
}
for(int i=0; i<ai.length(); i++)
{
cout << ai[i] << endl;
}
}
delete pai;
return 0;
}
運行結(jié)果為：
0
1
4
9
16
a
b
c
d
e
f
g
h
i
j
