將指針分配給固定大小的數組

Question

對於指針用法的基本知識，我有2個疑問。

用下面的代碼

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

p_b指向3個元素的數組，每個元素的固定大小長度為10 int。

Q1：

如果我希望每個元素都是一個指向固定數組大小的指針，該如何聲明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

Q2：

按照上面的原始代碼示例，如何調用new，以便p_b指向10 int的唯一固定大小的數組，而不是調用p_b = new int[1][10] ？ 為了釋放內存，我必須調用delete[]而找不到一個只能調用delete的表達式。

Answer 1

p_b指向3個元素的數組，每個元素的固定大小長度為10 int。

如果我希望每個元素都是一個指向固定數組大小的指針，該如何聲明p_b ？

您的第一句話沒有完全涵蓋這個問題嗎？

按照上面的原始代碼示例，如何調用new，以便p_b指向10 int的唯一固定大小的數組，而不是調用p_b = new int[1][10] ？ 為了釋放內存，我必須調用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

這是有關如何實現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 []，則可以使用向量或其他STL容器。 的確，除非這是一些超級優化，否則您還是應該使用向量。 除非絕對必要，否則請不要手動管理內存。

Answer 4

實際上，還沒有人發布您確切問題的答案。

代替

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;

Q1

如果我希望每個元素都是一個指向固定數組大小的指針，該如何聲明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>>();

Q2

按照上面的原始代碼示例，如何調用new，以便p_b指向10 int的唯一固定大小的數組，而不是調用p_b = new int[1][10] ？

並非沒有將數組包裝為其他類型。

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>>();

Answer 5

要使用原始指針來管理二維數組，您必須首先創建一個指向數組元素類型的指針，該指針將指向數組的每一行。 接下來，必須將每個行指針分配給該行的實際數組元素。

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 6

對於第一季度，我認為你想要

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

如果不確定，請嘗試使用cdecl 。

您的其他問題似乎已得到其他答案的很好回答。

問候，亞提·薩加德