conversión de matrices multidimensionales a los punteros en C++

Question

Tengo un programa que se parece a lo siguiente:

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

ahora quiero para calcular la inversa de startMatrix y ponerlo en inverseMatrix. Tengo una función de biblioteca para este propósito cuyo prototipo es el siguiente:

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

que se lleva a la inversa de A y lo pone en B. El problema es que necesito saber cómo convertir el doble [4] [ 4] en un doble ** para dar a la función. He intentado sólo hacer que la "forma obvia":

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

pero eso no parece funcionar. ¿Es esa la forma correcta de hacerlo?

Answer 1

No, no hay una forma correcta de hacerlo específicamente. Una matriz double[4][4] no es convertible a un puntero double **. Estas son dos maneras alternativas e incompatibles de implementar una matriz 2D. Algo necesita ser cambiado: ya sea la interfaz de la función o la estructura de la matriz pasada como un argumento.

La forma más sencilla de hacer esto último, es decir, para hacer que su double[4][4] matriz existente compatible con la función, es la creación de "índice" matrices temporales de tipo double *[4] apuntando a los inicios de cada fila de cada matriz

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

y pasar estas matrices "índice" en lugar

MatrixInversion(startRows, 4, inverseRows); 

Una vez terminada la función de trabajo, puede olvidarse de los startRows y inverseRows matrices, ya que el resultado será pl ingresado correctamente en su matriz original inverseMatrix.

Answer 2

Dos dimensiones matriz no es un puntero a puntero o algo similar. El tipo correcto para startMatrix es double (*)[4]. Para su función, la firma debe ser similar a:

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

Answer 3

El problema es que una matriz bidimensional no es lo mismo que una matriz de punteros. Una matriz bidimensional almacena los elementos una fila tras otra —, por lo tanto, cuando pasa una matriz de este tipo, solo se proporciona un puntero al inicio. La función de recepción puede encontrar la forma de encontrar cualquier elemento de la matriz, pero solo si conoce la longitud de cada fila.

Por lo tanto, su función de recepción debe declararse como void MatrixInversion(double A[4][], int order, double B[4][]).

Answer 4

Dado que está utilizando C++, la forma correcta de hacer algo como esto sería con una clase personalizada y algunas plantillas. El siguiente ejemplo es bastante difícil, pero tiene el punto básico.

#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

por buen codificante si C++:

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

matrix startMatrix; 
matrix inverseMatrix; 

lo que la interfaz habría

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

y utilizarlo

MatrixInversion(startMatrix, 4, inverseMatrix); 

El beneficio

1. la interfaz es muy simple y clara.
2. una vez que necesite modificar "m" de la matriz internamente, no necesita actualizar la interfaz.

O esta manera

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

matrix startMatrix; 
matrix inverseMatrix; 
... 

una manera fea en c

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

EDIT: código de referencia de MatrixInversion la que no fallará:

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

Por razón dada que matriz bidimensional (un bloque contiguo de memoria) y una matriz de punteros (no contiguos) son cosas muy diferentes, no puede pasar una matriz bidimensional a una función que funciona con puntero a puntero.

Una cosa que podría hacer: plantillas. Haga que el tamaño de la segunda dimensión sea un parámetro de plantilla.

#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); 
} 

Otro, un poco más torpe forma podría ser que la función acepta un puntero a una unidimensional matriz, y la anchura y la altura dada como argumentos, y calcular los índices en una representación en dos dimensiones a sí mismo.

#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); 
} 

Naturalmente, una matriz es algo que merece una clase propia (pero lo anterior aún puede ser relevante, si es necesario escribir funciones de ayuda).

Answer 7

Hay una solución usando el puntero a punto por bobobobo

William Sherif (bobobobo) utilizaron la versión C y sólo quiero mostrar C++ versión de la respuesta de bobobobo.

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) ]; 
} 

El resto del código es el mismo con bobobobo de.