分配指向固定大小数组的指针

Question

我对指针使用的基础有两个疑问。

使用以下代码

 int (*p_b)[10];
 p_b = new int[3][10];
 // ..do my stuff
 delete [] p_b

p_b 指向一个由 3 个元素组成的数组，每个元素的长度固定为 10 int。

第一季度：

如果我希望每个元素都是指向固定数组大小的指针，如何声明 p_b？ 基本上我想要以下

  p_b[0] = pointer to a fixed-array size of 10
  p_b[1] = pointer to a fixed-array size of 10
  // ... and so on

本来想int (** p_b)[10]，后来不知道怎么用new来分配？我想避免回到更一般的int** p_b

第二季度：

根据我上面的原始代码示例，除了调用p_b = new int[1][10] 之外，如何调用 new 以使 p_b 指向一个唯一的 10 int 固定大小数组？为了释放内存，我必须调用 delete[]，而我找不到只能简单调用 delete 的表达式。

Answer 1

p_b 指向一个由 3 个元素组成的数组，每个元素的长度固定为 10 int。

如果我希望每个元素都是指向固定数组大小的指针，如何声明p_b？

你的第一句话没有完全涵盖这个问题吗？

按照我上面的原始代码示例，除了调用p_b = new int[1][10] 之外，如何调用 new 以使 p_b 指向一个唯一的 10 int 的固定大小数组？要释放内存，我必须调用 delete[]，而我找不到只能调用 delete 的表达式。

我完全不明白为什么这是个问题，但你可以通过将数组包装在另一种类型中来做到这一点......比如std::array、boost::array 或std::vector。

Answer 2

首先，如果您的 new 表达式有方括号 (new somtype[somesize])，那么您的 delete 也必须有方括号 (delete [] your_pointer)。

其次，现在您已将p_b 定义为指向某些数据的单个指针。如果你真正想要的是一个指针数组，那么你需要将它定义为一个数组。由于您显然想要三个独立的数组，因此您必须分别分配它们。如果你从 typedef 开始，这可能是最简单的：

typedef int *p_int;
p_int p_b[3];

然后你将分配你的三个数组：

for (int i=0; i<3; i++)
    p_b[i] = new int[10];

要删除这些，您需要分别删除每一个：

for (int i=0; i<3; i++)
    delete [] p_b[i];

我绝对同意@Tomalak 的观点，即你几乎不应该自己搞砸这样的事情。目前尚不清楚您真正想要完成什么，但仍然很容易猜测标准容器很可能是一种更简单、更清洁的方式。

Answer 3

要使用原始指针来管理二维数组，您必须首先创建一个指向数组元素类型的指针，该指针将指向数组的每一行。接下来，必须将每个行指针分配给该行的实际数组元素。

int main()
{
  int **p;

  // declare an array of 3 pointers
  p = new int*[3];

  // declare an array of 10 ints pointed to by each pointer
  for( int i = 0; i < 3; ++i ) {
    p[i] = new int[10];
  }

  // use array as p[i][j]

  // delete each array of ints
  for( int i = 0; i < 3; ++i ) {
    delete[] p[i];
  }

  // delete array of pointers
  delete[] p;
}

一个更简单的解决方案是使用std::array。如果您的编译器不提供该类，您也可以使用std::vector。

std::array<std::array<int,10>,3> myArr; 
myArr[0][0] = 1;

Answer 4

下面是如何实现 Q1 的示例：

int main()
{
    typedef int foo[10];

    foo* f = new foo[3];

    f[0][5] = 5;
    f[2][7] = 10;

    delete [] f;
}

对于 Q2，删除使用 new[] 分配的内存的唯一方法是使用 delete[]。如果个人不想写delete[]，可以使用vector或者其他STL容器。真的，除非这是一些核心的超级优化，否则无论如何你都应该使用向量。除非万不得已，否则切勿手动管理内存。

Answer 5

对于第一季度，我想你想要

int (*p[3])[10];

如果您不确定，请尝试cdecl。

其他答案似乎很好地回答了您的其他问题。

问候， 亚提萨加德

Answer 6

实际上，还没有人回答您的确切问题。

代替

int (*p_arr)[10] = new int[3][10];
// use, then don't forget to delete[]
delete[] p_arr;

我建议使用

std::vector<std::array<int, 10>> vec_of_arr(3);

或者如果您不需要移动它并且不需要运行时长度：

std::array<std::array<int, 10>, 3> arr_of_arr;

第一季度

如果我希望每个元素都是指向固定数组大小的指针，如何声明 p_b？

int(**pp_arr)[10] = new std::add_pointer_t<int[10]>[3];
for (int i = 0; i < 3; ++i)
    pp_arr[i] = new int[1][10];
// use, then don't forget to delete[]
for (int i = 0; i < 3; ++i)
    delete[] pp_arr[i];
delete[] pp_arr;

该代码的现代变体是

std::vector<std::unique_ptr<std::array<int, 10>>> vec_of_p_arr(3);
for (auto& p_arr : vec_of_p_arr)
    p_arr = std::make_unique<std::array<int, 10>>();

或者如果您不需要移动它并且不需要运行时长度：

std::array<std::unique_ptr<std::array<int, 10>>, 3> arr_of_p_arr;
for (auto& p_arr : arr_of_p_arr)
    p_arr = std::make_unique<std::array<int, 10>>();

第二季度

按照我上面的原始代码示例，除了调用p_b = new int[1][10]之外，如何调用 new 以使 p_b 指向一个唯一的 10 int 的固定大小数组？

如果不将数组包装成另一种类型。

std::array<int, 10>* p_arr = new std::array<int, 10>;
// use, then don't forget to delete
delete p_arr;

您可以将std::array<int, 10> 替换为您最喜欢的数组包装类型，但您不能将其替换为固定大小的数组别名。该代码的现代变体是：

auto p_arr = std::make_unique<std::array<int, 10>>();