模板和內存分配

Question

#include <iostream> 

template<class T> T CreateArray(T a, int n) 
{ 
    a = new T [n]; // mistake: double* = double** 
    return a; 
} 

int main() 
{ 
    double* a; 
    int n = 5; 
    a = CreateArray(a,n); 
    return 0; 
} 

我可以使用模板分配內存嗎？我的錯誤是什麼？

Answer 1

你的代碼有一些錯誤的東西。首先，你可以這樣做你想要做什麼，而是你應該寫這樣的事情：

template<class T> T* CreateArray(int n) 
{ 
    T* a = new T [n]; 
    return a; 
} 

int main() 
{ 
    double* a; 
    int n = 5; 
    a = CreateArray<double>(n); 
    return 0; 
} 

注意，您不必通過a陣列（將裏面CreateArray被複制，並且其更改將在main內不可見）。還要注意，你定義了模板來返回一個指針T*，這就是main()a所期望的。

Answer 2

你要接受指針到要分配類型：

template<class T> T* CreateArray(T* a, int n) 
{ 
    a = new T [n]; 
    return a; 
} 

這應該做的伎倆。

Answer 3

我寧願保留空指針值NULL。

#include <iostream> 

template<class T> bool CreateArray(T * &a, int n) 
{ 
    if (a != 0) 
     return false; 
    a = new T [n]; 
    return true; 
} 

int main() 
{ 
    double* a = 0; 
    int n = 5; 
    CreateArray(a,n); 
    return 0; 
} 

vector也可能是一個很好的解決方案。我認爲它更好，因爲你不會讓內存泄漏。

#include <vector> 

int main() 
{ 
    std::vector<double> a; 
    int n = 5; 
    a.resize(n); 
    return 0; 
} 

Answer 4

所以其他人已經解釋了爲什麼你的代碼不工作以及如何改進。

現在我將告訴您如何仍然得到下面的代碼編譯 - 和正常工作：

double* a = CreateArray(5); 
int* b = CreateArray(7); 

的問題，前面已經提到的，是C++不從推斷模板參數僅返回類型。

您可以通過使上述函數返回一個簡單的代理對象來繞過這個限制。代理對象具有單個操作：（隱式）轉換爲T*。這是實際分配發生的地方。

因此CreateArray功能很簡單（不模板）：

CreateArrayProxy CreateArray(std::size_t num_elements) { 
    return CreateArrayProxy(num_elements); 
} 

至於代理：

struct CreateArrayProxy { 
    std::size_t num_elements; 

    CreateArrayProxy(std::size_t num_elements) : num_elements(num_elements) { } 

    template <typename T> 
    operator T*() const { 
     return new T[num_elements]; 
    } 
}; 

容易爲π。

現在，你應該使用這個代碼？不，可能不是。它不提供直接分配的真正優勢。但這是一個有用的習語。