模板与内存分配

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

因此其他人已经解释了为什么您的代码不起作用以及如何改进它。

现在我将展示如何仍然让以下代码进行编译并正常工作：

 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];
    }
};

简单如 π。

现在，您应该使用这段代码吗？不，可能不会。与直接分配相比，它没有提供真正的优势。但这是一个很有用的习语。

Answer 3

您想要接受指向要分配的类型的指针：

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

这应该可以解决问题。

Answer 4

我更喜欢将空指针值保留为 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;
}