Chuyển đổi mảng đa chiều đối với con trỏ trong C++

Question

tôi có một chương trình mà trông giống như sau:

double[4][4] startMatrix; 
double[4][4] inverseMatrix; 
initialize(startMatrix) //this puts the information I want in startMatrix 

bây giờ tôi muốn để tính toán nghịch đảo của startMatrix và đặt nó vào inverseMatrix. Tôi có một chức năng thư viện cho mục đích này có prototype như sau:

void MatrixInversion(double** A, int order, double** B) 

mà có nghịch đảo của A và đặt nó trong B. Vấn đề là tôi cần phải biết làm thế nào để chuyển đổi kép [4] [ 4] thành một đôi ** để cung cấp cho hàm. Tôi đã thử chỉ làm điều đó "cách rõ ràng":

MatrixInversion((double**)startMatrix, 4, (double**)inverseMatrix)) 

nhưng điều đó dường như không hoạt động. Đó có phải là cách thực sự để làm điều đó không?

Answer 1

Không, không có cách nào để làm cụ thể điều đó. Mảng double[4][4] không thể chuyển đổi thành con trỏ double **. Đây là hai cách thay thế, không tương thích để triển khai mảng 2D. Một cái gì đó cần phải được thay đổi: hoặc là giao diện của chức năng, hoặc cấu trúc của mảng được truyền như một đối số.

Cách đơn giản nhất để làm sau này, tức là để làm cho double[4][4] mảng hiện tại của bạn phù hợp với chức năng, là tạo ra tạm thời "chỉ số" mảng kiểu double *[4] trỏ đến sự khởi đầu của mỗi hàng trong mỗi ma trận

double *startRows[4] = { startMatrix[0], startMatrix[1], startMatrix[2] , startMatrix[3] }; 
double *inverseRows[4] = { /* same thing here */ }; 

và vượt qua những "chỉ số" mảng thay vì

MatrixInversion(startRows, 4, inverseRows); 

Khi chức năng làm việc kết thúc, bạn có thể quên đi những startRows và inverseRows mảng, vì kết quả sẽ là pl được nhập vào mảng inverseMatrix gốc của bạn một cách chính xác.

Answer 2

Mảng hai chiều không phải là con trỏ trỏ đến con trỏ hoặc tương tự. Loại chính xác cho bạn startMatrix là double (*)[4]. Đối với chức năng của bạn, chữ ký phải như sau:

MatrixInversion(double (*A)[4], int order, double (*B)[4]); 

Answer 3

Vấn đề là mảng hai chiều không giống như một mảng con trỏ. Mảng hai chiều lưu trữ các phần tử một hàng sau một khác — vì vậy, khi bạn truyền một mảng xung quanh, chỉ có một con trỏ tới điểm bắt đầu được đưa ra. Chức năng tiếp nhận có thể tìm ra cách tìm bất kỳ phần tử nào của mảng, nhưng chỉ nếu nó biết chiều dài của mỗi hàng.

Vì vậy, chức năng nhận của bạn phải được khai báo là void MatrixInversion(double A[4][], int order, double B[4][]).

Answer 4

Vì bạn đang sử dụng C++, cách thích hợp để làm điều gì đó như thế này sẽ là với một lớp tùy chỉnh và một số mẫu. Ví dụ sau là khá thô, nhưng nó được điểm cơ bản trên.

#include <iostream> 

using namespace std; 

template <int matrix_size> 
class SquareMatrix 
{ 
    public: 
     int size(void) { return matrix_size; } 
     double array[matrix_size][matrix_size]; 
     void copyInverse(const SquareMatrix<matrix_size> & src); 
     void print(void); 
}; 

template <int matrix_size> 
void SquareMatrix<matrix_size>::copyInverse(const SquareMatrix<matrix_size> & src) 
{ 
    int inv_x; 
    int inv_y; 

    for (int x = 0; x < matrix_size; x++) 
    { 
     inv_x = matrix_size - 1 - x; 
     for (int y = 0; y < matrix_size; y++) 
     { 
      inv_y = matrix_size - 1 - y; 
      array[x][y] = src.array[inv_x][inv_y]; 
     } 
    } 
} 

template <int matrix_size> 
void SquareMatrix<matrix_size>::print(void) 
{ 
    for (int y = 0; y < 4; y++) 
    { 
     for (int x = 0; x < 4; x++) 
     { 
      cout << array[x][y] << " "; 
     } 
     cout << endl; 
    } 
} 

template <int matrix_size> 
void Initialize(SquareMatrix<matrix_size> & matrix); 

int main(int argc, char * argList[]) 
{ 
    SquareMatrix<4> startMatrix; 
    SquareMatrix<4> inverseMatrix; 

    Initialize(startMatrix); 

    inverseMatrix.copyInverse(startMatrix); 

    cout << "Start:" << endl; 
    startMatrix.print(); 

    cout << "Inverse:" << endl; 
    inverseMatrix.print(); 

    return 0; 
} 

template <int matrix_size> 
void Initialize(SquareMatrix<matrix_size> & matrix) 
{ 
    for (int x = 0; x < matrix_size; x++) 
    { 
     for (int y = 0; y < matrix_size; y++) 
     { 
      matrix.array[x][y] = (x+1)*10+(y+1); 
     } 
    } 
} 

Answer 5

bởi mã hóa tốt đẹp nếu C++:

struct matrix { 
    double m[4][4]; 
}; 

matrix startMatrix; 
matrix inverseMatrix; 

nên giao diện sẽ

void MatrixInversion(matrix &A, int order, matrix &B); 

và sử dụng nó

MatrixInversion(startMatrix, 4, inverseMatrix); 

Lợi ích

1. giao diện rất đơn giản và rõ ràng.
2. khi cần sửa đổi "m" ma trận trong nội bộ, bạn không cần cập nhật giao diện.

Hoặc cách này

struct matrix { 
    void Inversion(matrix &inv, int order) {...} 
protected: 
    double m[4][4]; 
}; 

matrix startMatrix; 
matrix inverseMatrix; 
... 

Một cách xấu xí trong c

void MatrixInversion(void *A, int order, void *B); 
MatrixInversion((void*)startMatrix, 4, (void*)inverseMatrix); 

EDIT: Mã tham chiếu cho MatrixInversion mà sẽ không sụp đổ:

void MatrixInversion(void *A, int order, void *B) 
{ 
    double _a[4][4]; 
    double _b[4][4]; 

    memcpy(_a, A, sizeof _a); 
    memcpy(_b, B, sizeof _b); 
    // processing data here 

    // copy back after done 
    memcpy(B, _b, sizeof _b); 
} 

Answer 6

Vì lý do cho rằng mảng hai chiều (một khối bộ nhớ liền kề) và một mảng các con trỏ (không tiếp giáp) là những thứ rất khác nhau, bạn không thể truyền một mảng hai chiều đến một hàm làm việc với con trỏ tới con trỏ.

Một điều bạn có thể làm: mẫu. Đặt kích thước của thứ nguyên thứ hai thành thông số mẫu.

#include <iostream> 

template <unsigned N> 
void print(double a[][N], unsigned order) 
{ 
    for (unsigned y = 0; y < order; ++y) { 
     for (unsigned x = 0; x < N; ++x) { 
      std::cout << a[y][x] << ' '; 
     } 
     std::cout << '\n'; 
    } 
} 

int main() 
{ 
    double arr[3][3] = {{1, 2.3, 4}, {2.5, 5, -1.0}, {0, 1.1, 0}}; 
    print(arr, 3); 
} 

khác, một chút vụng về cách có thể để làm cho chức năng chấp nhận một con trỏ đến một mảng đơn chiều, và cả chiều rộng và chiều cao được cho là đối số, và tính toán các chỉ số thành một đại diện hai chiều chính mình.

#include <iostream> 

void print(double *a, unsigned height, unsigned width) 
{ 
    for (unsigned y = 0; y < height; ++y) { 
     for (unsigned x = 0; x < width; ++x) { 
      std::cout << a[y * width + x] << ' '; 
     } 
     std::cout << '\n'; 
    } 
} 

int main() 
{ 
    double arr[3][3] = {{1, 2.3, 4}, {2.5, 5, -1.0}, {0, 1.1, 0}}; 
    print(&arr[0][0], 3, 3); 
} 

Tự nhiên, ma trận là thứ xứng đáng với một lớp riêng (nhưng ở trên vẫn có thể có liên quan, nếu bạn cần viết chức năng trợ giúp).

Answer 7

Có một giải pháp bằng cách sử dụng con trỏ đến điểm bởi bobobobo

William Sherif (bobobobo) sử dụng phiên bản C và tôi chỉ muốn hiển thị C++ phiên bản của câu trả lời bobobobo của.

int numRows = 16 ; 
int numCols = 5 ; 
int **a ; 

a = new int*[ numRows* sizeof(int*) ]; 
for(int row = 0 ; row < numRows ; row++) 
{ 
    a[row] = new int[ numCols*sizeof(int) ]; 
} 

Phần còn lại của mã giống với bobobobo.