wie Arrays übergeben und Array-Werte von 2D-Matrizen zurückgegeben werden?

Question

Anruf von Haupt

matrix_multiplication(arrayA,arrayB,row1,col1,col2); 

Funktionsdefinition

float matrix__multiplication(float **arrayA,float **arrayB,int row1,int col1,int col2) 
{ 
float result[row1][col2]; 
result[][]=.... 

return result; 
} 

ich wissen wollte, wie 2D-Arrays in Funktionsaufruf zu übergeben, wie in Funktionsdefinition und wie das Ergebnis Matrix zurückzukehren erhalten?

Answer 1

Verwenden von rohen Zeigern für Ihre Arrays wie diese ist mehr C-Stil als C++. Verwenden Sie Vektor des Vektors (Indizierung ist immer noch sehr effizient).

size_t rows(5); 
size_t columns(15); 
vector<float> row(columns); 
vector<vector<float>> matrix(rows, row); 
matrix[0][0] = 0.1f; 

Noch besser wäre es, den zugrunde liegenden Speicher in einer Matrix-Klasse wickelt, die die erforderlichen Matrix-Operationen implementiert, halten und erzwingen Dimensionen sorgen Matrizen für die Multiplikation kompatibel sind, und so weiter.

class Matrix 
{ 
public: 
    Matrix(const int _rows, const int _cols) : rows(_rows), cols(_cols) 
    { 
    } 

    Matrix Multiply(const Matrix& rhs); 

private: 
    vector<vector<float>> storage; 
    size_t rows; 
    size_t cols; 
}; 

Matrix Matrix::multiply(const Matrix& rhs) 
{ 
    Matrix result(*this, rhs); // construct matrix of right dimensions 
    // multiply the operands 
    return result;  // modern compilers do not copy construct the result 
} 

Wenn Ihre Matrix Anforderungen komplex sind, könnten Sie eine Bibliothek wie Boost.UBlas betrachten gegen Ihre eigene Rolle. Dies ist Vorlagencode und unterstützt Spezialisierungen für spärliche, diagonale und andere gebräuchliche Matrixtypen.

Answer 2

Ich würde es in etwa so, indem Sie eine Referenz auf die 2D-Array (in der Tat ein D1 X D2) Array von jedem Typ übergeben. Dies würde auch die Notwendigkeit vermeiden, irgendetwas zurückzugeben.

Wenn die Funktion das Eingabearray-Argument ändern muss, entfernen Sie die Konstante const.

void f(T const (&r)[D1][D2]){} 

int main() { 
    float fbuf[10][3]; 
    f(fbuf); 
} 

Wenn Sie jedoch die Funktion zurückgeben beharren ein 2D-Array auf aufweisen, können Sie so etwas wie dies tun:

template<class T, size_t D1, size_t D2> 
T (&f(T const (&r)[D1][D2]))[D1][D2]{ 
    T temp[D1][D2]; 
    return temp; 
} 

int main() { 
    float fbuf[10][3]; 
    f(fbuf); 
} 

Answer 3

Was Sie geschrieben haben keine gültige C++ Code. Um result auf die richtige Größe zu initialisieren, müssen row und col Kompilierzeitkonstanten sein, die sie nicht sind. Sie geben entweder float** von Ihrer Funktion zurück, die Sie lokal zuweisen, oder (besser) übergeben Sie einen zuvor zugewiesenen float** result als einen anderen Parameter an Ihre Funktion (die Sie immer noch zurückgeben können). Normalerweise würden Sie jedoch keine 2D-Arrays zum Speichern von Matrizen verwenden, sondern lieber einen linearen Speicher für eine Matrix in einem 1-d-Array definieren und entsprechende Zugriffsmethoden definieren.

float** matrix__multiplication(float **arrayA,float **arrayB,float **result, int row1,int col1,int col2) 
{ 
// ... 
return result; 
} 

// caller needs to allocate (and de-allocate) space (see the mess?): 
result = new float* [row1]; 
std::for_each(result, result + row1, [col2] (float*& pCurr) -> void { 
pCurr = new float[col2]; 
}); 

result = matrix_multiplication(a, b, result, row1, col1, col2);