在C++中操縱具有函數的多維數組

Question

我正在嘗試使用函數在C++中修改二維數組的內容。我一直無法找到有關如何通過引用將2D數組傳遞給函數的信息，然後處理單個單元格。

我試圖解決的問題有以下格式。爲簡潔起見，我做了一個簡單的程序。

#include<cstdlib> 
#include<iostream> 
using namespace std; 

void func(int& mat) { 
    int k,l; 
    for(k=0;k<=2;k++) { 
    for(l=0;l<=2;l++) { 
    mat[k][l]=1; //This is incorrect because mat is just a reference, but 
        // this is the kind of operation I want. 
    } 
} 

return; 
} 

int main() { 
int A[3][3]; 
int i, j; 
char jnk; 

for(i=0;i<=2;i++) { 
    for(j=0;j<=2;j++) { 
     A[i][j]=0; 
    } 
} 

    func(A); 

cout << A[0][0]; 
    return 0; 
} 

所以A [0] [0]的值應該從0變爲1.什麼是正確的方法呢？提前感謝...

Answer 1

數組不按值傳遞的，所以你可以簡單地使用

void func(int mat[][3]) 

，如果你修改裏面func的mat值你實際上是在main修改它。

您可以使用這種方法，如果你預先知道你的矩陣的大小，否則考慮與指針的工作：

#include <iostream> 

void f(int **m, int r, int c) { 
    m[0][0]=1; 
} 

int main() { 

    int **m; 
    int r=10,c=10; 
    int i; 

    m = (int**)malloc(r*sizeof(int*)); 

    for (i=0; i<r;i++) 
     m[i] = (int*)malloc(c*sizeof(int)); 

    f(m,r,c); 

    printf("%d\n",m[0][0]); 

    for(i=0;i<r;i++) 
     free(m[i]); 

    free(m); 

    return 0; 

} 

Answer 2

C++允許你封裝代碼結構，像這樣成一個對象，例如一個數組有std::vector和std::array對象。

我親自推出我自己的矩陣容器。這樣你就不必擔心它們如何通過的細節。

矩陣實行的一個基本的例子可能是：

template<typename T> 
class matrix 
{ 
public:      //TYPEDEFS 
    typedef       T              value_type; 
private: 
    typedef     std::vector<value_type>   vect_type; 
public: 
    typedef typename  vect_type::iterator    iterator; 
    typedef typename  vect_type::const_iterator  const_iterator; 

private:   //DATAMEMBERS 
    vect_type values; 
    size_t x_sz, y_sz;/not const for assingment reasons 

public:      //MEMBER FUNCTIONS 
    matrix(const matrix&)   =default; 
    matrix(matrix&&)    =default; 
    matrix& operator=(const matrix&)=default; 
    matrix& operator=(matrix&&)  =default; 

    matrix(size_t x_sz_=0u, size_t y_sz_=0u, value_type t=value_type()) 
    : values(x_sz_*y_sz_, t) 
    , x_sz(x_sz_) 
    , y_sz(y_sz_) 
    { } 

    //return  symbol   const body 
    size_t   x_size()  const { return x_sz; } 
    size_t   y_size()  const { return y_sz; } 

    iterator  begin()     { return values.begin();  } 
    iterator  end()     { return values.end();   } 
    const_iterator begin()   const { return values.cbegin();  } 
    const_iterator end()   const { return values.cend();   } 
    const_iterator cbegin()  const { return values.cbegin();  } 
    const_iterator cend()   const { return values.cend();   } 

    value_type& at(size_t x, size_t y) 
    { 
      return values.at(y*x_sz+x); 
    } 

    const value_type& at(size_t x, size_t y) const 
    { 
      return values.at(y*x_sz+x); 
    } 
}; //class matrix 

然後你只需做到以下幾點：

void func(const mat& m).... 
::: 

matrix<int> mat(3,3); 

 //this isn't necessary as the ctor take a default value, 
// however it show you how you might iterate through the values. 
for(size_t y=0; y!=mat.y_size(); ++y) 
    for(size_t x=0; x!=mat.x_size(); ++x) 
     mat.at(x, y)=0; 

func(mat); //as param 

Answer 3

您可以檢查此：

#include <cstdio> 
#include <cstdlib> 

void printArrays(int* array[], int len1, int len2) { 
    for (int i=0; i<len1; i++) { 
    for (int j=0; j<len2; j++) { 
     printf("%d ", array[i][j]); 
    } 
    printf("\n"); 
    } 
} 

void modify(int* array[], int len1, int len2) { 
    for (int i=0; i<len1; i++) { 
    for (int j=0; j<len2; j++) { 
     array[i][j]*=(i+j); 
    } 
    } 
} 

int main() { 
    int arr1[3] = {4, 5, 5}; 
    int arr2[3] = {6, 1, 5}; 
    int arr3[3] = {7, 5, 1}; 
    int *array[3] = {arr1, arr2, arr3}; 
    printArrays(array, 3, 3); 
    printf("After modify:\n"); 
    modify(array, 3, 3); 
    printArrays(array, 3, 3); 
    return 0; 
} 

Answer 4

這裏的常規的方式。你可以使用任何版本的功能「f」：

#include <cstdlib> 

const size_t cols = 10; // You can hardcode this below if you want 

// Can only be called if you know "cols" at compile-time 
void f(int pArray[][cols], size_t rows) 
{ 
    for(size_t i = 0; i < rows; ++i) 
    { 
     for(size_t j = 0; j < cols; ++j) 
     { 
      pArray[i][j] = 1; 
     } 
    } 
} 

// Use this if you don't know "cols" at compile-time (good for any arbitrary 2D array) 
void f(int *pArray, size_t rows, size_t cols) 
{ 
    for(size_t i = 0; i < rows; ++i) 
    { 
     const size_t RowOffset = (i * cols); 
     for(size_t j = 0; j < cols; ++j) 
     { 
      pArray[RowOffset + j] = 1; 
     } 
    } 
} 

int main() 
{ 
    int array[][cols]= {{ 5, 10, 15, 20, 25, 30, 35, 40, 45, 50 }, 
         { 55, 60, 65, 70, 75, 80, 85, 90, 95, 100 }, 
         { 105, 110, 115, 120, 125, 130, 135, 140, 145, 150 }, 
         { 155, 160, 165, 170, 175, 180, 185, 190, 195, 200 }, 
         { 205, 210, 220, 225, 230, 235, 240, 245, 250, 255}}; 

    const size_t rows = sizeof(array)/sizeof(array[0]); // 5 in this example but you can hardcode it if you want 
    f(array, rows); 
    f(array[0], rows, cols); 

    return 0; 
}