將多維指針數組的指針傳遞給函數

Question

好的，假設我有一個函數myFunction 。 然后在main我有一個多維數組的指針。 我想將一個指向該指針數組的指針傳遞給myFunction 。 我該怎么做？ 我知道，如果您要將int傳遞給我的函數，可以將函數編寫為

myfunct( int x) { ...}

如果我必須將一個指針傳遞給指針數組，那么x的類型將是什么？ 提前致謝

Answer 1

通常，您要修改數組的元素，而不是實際的指針。 實際的指針是由malloc給出的，如果您對其進行更改，則通過直接寫入該值，它不會影響內存分配（除非您可能會丟失初始指針...）。

這可能就是您要在2D陣列中尋找的東西。

void myfunct(int** ptr,int items, int array_items)
{
    //some code
}
int main(int argc, char *argv[])
{
    const auto items = 5;
    const auto array_items = 7;
    int** multi_dimensional_array = reinterpret_cast<int**>(std::malloc(items * sizeof(int*)));
    for (auto i = 0 ;i < items;++i)
    {
        multi_dimensional_array[i] = static_cast<int*>(std::malloc(sizeof(int) * array_items));
    }
    myfunct(multi_dimensional_array,items,array_items);
    //deallocate
}

Answer 2

將多維數組包裝在類中。 這樣，您就可以將數據和維度放在一個塊中，並將其傳遞就像在任何其他類中移動一樣簡單。

請記住遵守三，五和零規則 ，以最適合您在類中存儲數組的方式為准。 std::vector是個人喜好，因為它允許您使用零規則。

例如：

#include <iostream>
#include <vector>

struct unspecified
{
};

template<class TYPE>
class TwoDee{
    int rows;
    int cols;
    std::vector<TYPE> data;
public:
    TwoDee(int row, int col):rows(row), cols(col), data(rows*cols)
    {
        // does nothing. All of the heavy lifting was in the initializer
    }
    // std::vector eliminates the need for destructor, assignment operators, and copy
    //and move constructors. All hail the Rule of Zero!
    //add a convenience method for easy access to the vector
    TYPE & operator()(size_t row, size_t col)
    {
        return data[row*cols+col];
    }
    TYPE operator()(size_t row, size_t col) const
    {
        return data[row*cols+col];
    }
};

void function(TwoDee<unspecified *> & matrix)
{
    // does stuff to matrix
}

int main()
{
    TwoDee<unspecified *> test(10,10);
    function(test);
}

Answer 3

要直接回答你的問題，通常是通過型式將int *為向量int和int **為一個二維數組int

void myfunct( int **x) 
{ 
    x[2][1] = 25;
    return;
}

如果由於某種原因您希望將其作為一個int指針數組而不是int ，則需要一個額外的*。

void myfunct( int ***x) 
{ 
    *(x[2][1]) = 25;
    return;
}

Answer 4

讓我首先嘗試解釋您要處理的確切類型。 我想在您的main功能中有一個“多維數組”，用於存儲每個元素的指針。 例如，假設您有一個指向整數類型的3維指針數組。

假設您知道數組的大小：

C樣式數組將如下所示：

int *a[4][3][2];

這意味着a是一個4x3x2數組，並且數組中的每個元素都是一個指向整數的指針。 因此，總體而言，您現在總共有24個指向整數的指針，通過測試sizeof(a) / sizeof(int*)的結果可以看出（結果應為24）。 好的，到目前為止很好。 但是現在我想你想要的是一個指向上面提到的數組a的指針，比如b ，所以定義了b

int *(*b)[4][3][2] = &a;

請注意，盡管現在b看起來令人生畏，但最后它只是一個指針，僅存儲一個地址，並且sizeof(b) / sizeof(int*)給出1作為結果。 （括號內的*表示b是指針類型，因此b是指向整數的“多維數組”的指針。）

現在將b傳遞給myFunction ，只需在聲明中提供與參數類型相同的b類型：

void myFunction(int *(*x)[4][3][2]) {
    // do something
}

就是這樣！ 您可以直接使用myFunction(b)調用此函數。 另外，您可以測試myFunction ， x仍然是一個指針的大小，而*x是24個指針的大小。

*請注意，由於我們正在將指向數組類型的指針傳遞給函數，因此數組到指針的衰減不適用於此處。

假設您在編譯時不知道數組的大小：

假設您有int N1 = 4, N2 = 3, N3 = 2; 並且您想初始化一個指向整數的N1xN2xN3指針數組，則不能直接在堆棧上執行此操作。

您可以按照@Mikhail的答案中的建議使用new或malloc初始化，但是該方法對多維數組采用嵌套循環，並且在釋放內存時需要再次執行嵌套循環。 因此，正如@ user4581301所建議的那樣， std::vector為動態大小數組提供了一個很好的包裝器，不需要我們自己釋放內存。 是的

所需的數組a可以用這種方式編寫（看起來仍然很丑陋，但是沒有顯式循環和釋放內存的麻煩）

std::vector<std::vector<std::vector<int*>>> a (N1,
    std::vector<std::vector<int*>> (N2,
        std::vector<int*> (N3)
    )
);

現在， b （指針到a ）可以被寫為

auto *b = &a;

現在，您可以通過b與

void myFunction(std::vector<std::vector<std::vector<int*>>>* x) {
    // do something
}

請注意， x之前的*表示x是指針。