C++中的數(shù)組類模板

首先先了解一個小知識點：
模板參數(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ù)
  • ........

本質：模板參數(shù)是在編譯階段被處理的單元，因此，在編譯階段必須準確無誤的唯一確定。

了解完數(shù)值型模板參數(shù)這個知識點以后，再來做一個面試題：

用一個最高效的方法求1+2+3+4+....+N的值！

或許大家會想到使用一個循環(huá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;
}

輸出結果為：

func() 10 = 55
func() 100 = 5050
1 + 2 + 3 + ... + 10 = 55
1 + 2 + 3 + ... + 100 = 5050

是不是會有疑問，代碼中表述了2中方式的求值過程。第一種是正常的方法，直接for循環(huán)來累加求值；第二種是使用函數(shù)模板遞歸來求值。可是這兩種方式沒有什么不同呀！

其實這里是有區(qū)別的，我們都知道對于函數(shù)模板編譯器是分兩次編譯。那在這里對于func函數(shù)模板，第一次編譯是編譯函數(shù)模板本身，第二次是替換參數(shù)后的代碼，也就是說最終的值是在運行期main函數(shù)中調用這個函數(shù)，傳入?yún)?shù)，然后求值；那對于sum函數(shù)模板，就不一樣了，第一次是編譯函數(shù)模板本身，但是這里是使用遞歸，那就是說第一次編譯的時候就已經把值求出來，第二次編譯是有一個靜態(tài)變量存在函數(shù)體中。

對于兩種方法，第一個是在運行期求值，會消耗掉計算量，第二個是在編譯器就求出來了，運行期直接輸出，不消耗任何計算量。所以第二個方法更高效。

最后在這里用代碼闡述array類的內部實現(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();
    //設置某一個索引的值
    bool set(int index, T value);
    //獲取某一個索引的值
    bool get(int index, T& value);
    //使用[]來獲取某一個索引的值
    T& operator[] (int index);
    T operator[] (int index) const;
    //析構函數(shù)
    virtual ~Array();
};

//設置某一個索引的值
template
< typename T, int N >
int Array<T, N>::length()
{
    return N;
}

//設置某一個索引的值
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;
    //設置長度
    HeapArray(int len);
    //拷貝構造
    HeapArray(const HeapArray<T>& obj);
    //構造
    bool construct();
public:
    //初始化類和申請數(shù)組空間
    static HeapArray<T>* NewInstance(int length); 
    //獲取長度
    int length();
    //獲取某個索引的值
    bool get(int index, T& value);
    //設置某個索引的值
    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

調用函數(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;
}

運行結果為：

0
1
4
9
16

a
b
c
d
e
f
g
h
i
j
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 前言 把《C++ Primer》[https://book.douban.com/subject/25708312...
    尤汐Yogy閱讀 9,537評論 1贊 51
  • 第一部分Common Lisp介紹第1章 介紹一下Lisp你在學的時候覺得已經明白了，寫的時候更加確信了解了，教別...
    geoeee閱讀 3,007評論 5贊 8
  • 一、溫故而知新 1. 內存不夠怎么辦 內存簡單分配策略的問題地址空間不隔離內存使用效率低程序運行的地址不確定 關于...
    SeanCST閱讀 7,880評論 0贊 27
  • Java8 in action 沒有共享的可變數(shù)據(jù)，將方法和函數(shù)即代碼傳遞給其他方法的能力就是我們平常所說的函數(shù)式...
    鐵牛很鐵閱讀 1,274評論 1贊 2
  • 我的眼里噴出怒火 試圖燒盡世間的不公 我的嘴里射出子彈 試圖消滅一切敵人 敵人在哪 雙手緊握AK47 子彈如雨，卻...
    鴻蒙一葉閱讀 280評論 4贊 7