数组作为模板参数：堆栈还是堆？-Arrayastemplateparameter:stackorheap?

2  

You've written your array extents backwards. This works:

你已经向后编写了数组范围。这有效:

  int m = 1000;
  const int n = 100;
  float (*array)[n] = new float[m][n];
  delete[] array;

If you want to keep the array extents in the same order you can use a type alias or appropriate template:

如果要以相同的顺序保留数组范围,可以使用类型别名或适当的模板:

  using A = float[n];
  A* array = new A[m];

or

// at file scope
template using add_extent = T[N];
// ...
  add_extent* array = new add_extent[m];

A multidimensional array whether on the stack or the heap is allocated as a single block of m*n elements. When you index a pointer to array type (like float (*array)[n]), the pointer is incremented n elements at a time, per the stride of the array type.

无论是在堆栈还是堆上的多维数组都被分配为m * n个元素的单个块。当您将指针索引到数组类型(如float(* array)[n])时,指针会按照数组类型的步幅一次递增n个元素。

3  

Array* array = new Array(m);

What is going on here is two heap allocations. The Array object will be allocated on the heap because you used new to create it. The new-expression calls the Array constructor, which again uses new to allocate the array data; therefore data is also allocated on the heap.

这里发生的是两个堆分配。 Array对象将在堆上分配,因为您使用new来创建它。 new-expression调用Array构造函数,它再次使用new来分配数组数据;因此,数据也在堆上分配。

It is better to do this:

最好这样做:

Array array(m);

This allocates array on the stack (so it will automatically be destroyed at the end of the block). However, while the array object itself is on the stack, the data is still stored on the heap because it's allocated on the heap in the Array constructor. This is similar to what happens when you have a std::vector or std::string local variable.

这会在堆栈上分配数组(因此它会在块的末尾自动销毁)。但是,虽然数组对象本身位于堆栈上,但数据仍然存储在堆上,因为它是在Array构造函数的堆上分配的。这类似于当你有一个std :: vector或std :: string局部变量时会发生的事情。

Furthermore, I can't seem to do this without the aid of a template. Specifically, this code does not compile:

此外,没有模板的帮助,我似乎无法做到这一点。具体来说,此代码无法编译:

This is just because your syntax is wrong. The correct syntax is:

这只是因为你的语法错误。正确的语法是:

float (*array)[n] = new float[m][n];

The left-hand side shows the correct way to declare a pointer to an array. For the right-hand side, you want an array of m float[n]s. This is denoted float[m][n]; the [m] doesn't go at the end.

左侧显示了声明指向数组的指针的正确方法。对于右侧,您需要一个m float [n]的数组。这表示为float [m] [n]; [m]最后没有结束。

1  

All the memory goes on the heap. The compiler allocates one giant chunk of memory for the array-of-arrays, and sets up the indexing so that it's accessible.

所有内存都在堆上。编译器为数组数组分配一个巨大的内存块,并设置索引以便可访问。

And as an aside if anyone ever copies or assigns your Array class you'll leak memory and/or double delete.

另外,如果有人复制或分配你的Array类,你将泄漏内存和/或双重删除。

0  

In the line

在线

Array* array = new Array(m);

An instance of Array is allocated on the heap. You already understood that, given your first statement about allocations in general.

在堆上分配Array 的实例。你已经明白了,一般来说你的第一个关于分配的陈述。

Perhaps the confusing part is the use of float[n] as a template parameter?

也许令人困惑的部分是使用float [n]作为模板参数?

The template parameter T, as denoted by the keyword class in your definition of Array, represents a type. It isn't in itself related to any form of allocation.

模板参数T(由Array定义中的关键字class表示)表示一种类型。它本身与任何形式的分配无关。

As a demonstration of this, let's write a simple template which doesn't make any use of its parameter:

作为对此的演示,让我们编写一个简单的模板,它不会使用它的参数:

#include 

using namespace std;

template 
class A {
};

int main(){

    A a1;
    A a2;
    float f[100];

    assert(sizeof(a1) == sizeof(a2));
    cout <<"a1 : " <

a1 : 1
f : 400