Comment allouer dynamiquement une matrice?

Comment allouer dynamiquement une matrice 2D en C++?
J'ai essayé basé sur ce que je sais déjà:

#include <iostream>

int main(){
    int rows;
    int cols;
    int * arr;
    arr = new int[rows][cols];
 }

Il travaille pour un seul paramètre, mais maintenant pour les deux. Que dois-je faire?

source d'informationauteur chustar

arrays c++dynamic-data matrix

Une matrice est un tableau de tableaux.

int rows = ..., cols = ...;
int** matrix = new int*[rows];
for (int i = 0; i < rows; ++i)
    matrix[i] = new int[cols];

Bien sûr, de supprimer la matrice, vous devez effectuer les opérations suivantes:

for (int i = 0; i < rows; ++i)
    delete [] matrix[i];
delete [] matrix;

J'ai trouvé une autre possibilité:

int rows = ..., cols = ...;
int** matrix = new int*[rows];
if (rows)
{
    matrix[0] = new int[rows * cols];
    for (int i = 1; i < rows; ++i)
        matrix[i] = matrix[0] + i * cols;
}

La libération de ce tableau est plus facile:

if (rows) delete [] matrix[0];
delete [] matrix;

Cette solution a l'avantage de l'allocation d'un seul gros bloc de mémoire pour tous les éléments, au lieu de plusieurs petits morceaux. La première solution que j'ai posté est un meilleur exemple de la des tableaux de tableaux le concept, mais.

Vous pouvez également utiliser std::vectors pour la réalisation de ce:

à l'aide de std::vector< std::vector<int> >

Exemple:

std::vector< std::vector<int> > a;

  //m * n is the size of the matrix

    int m = 2, n = 4;
    //Grow rows by m
    a.resize(m);
    for(int i = 0 ; i < m ; ++i)
    {
        //Grow Columns by n
        a[i].resize(n);
    }
    //Now you have matrix m*n with default values

    //you can use the Matrix, now
    a[1][0]=1;
    a[1][1]=2;
    a[1][2]=3;
    a[1][3]=4;

//OR
for(i = 0 ; i < m ; ++i)
{
    for(int j = 0 ; j < n ; ++j)
    {      //modify matrix
        int x = a[i][j];
    }

}

Essayer boost::multi_array

#include <boost/multi_array.hpp>

int main(){
    int rows;
    int cols;
    boost::multi_array<int, 2> arr(boost::extents[rows][cols] ;
}

 #include <iostream>

    int main(){
        int rows=4;
        int cols=4;
        int **arr;

        arr = new int*[rows];
        for(int i=0;i<rows;i++){
           arr[i]=new int[cols];
        }
        //statements

        for(int i=0;i<rows;i++){
           delete []arr[i];
        }
        delete []arr;
        return 0;
     }

1

ou vous pouvez simplement allouer un tableau 1D, mais des éléments de référence dans une 2D de la mode:

à l'adresse de la ligne 2, colonne 3 (en haut à gauche est la ligne 0, colonne 0):

arr[2 * MATRIX_WIDTH + 3]

où MATRIX_WIDTH est le nombre d'éléments dans une rangée.
1
```
arr = new int[cols*rows];
```
Si vous n'avez pas l'esprit de la syntaxe
```
arr[row * cols + col] = Aij;
```
ou de l'utilisation de l'opérateur[] overaloading quelque part. Cela peut être plus de cache-friendly que tableau de tableaux, ou peut être pas, le plus probablement, vous ne devriez pas s'en soucier. Je veux juste souligner qu'un) tableau de tableaux est pas la seule solution, b) certaines opérations sont plus faciles à mettre en œuvre si la matrice situé dans un bloc de mémoire. E. g.
```
for(int i=0;i < rows*cols;++i)
   matrix[i]=someOtherMatrix[i];
```
une ligne plus courte que
```
for(int r=0;i < rows;++r)
  for(int c=0;i < cols;++s)
     matrix[r][c]=someOtherMatrix[r][c];
```
bien que d'ajouter des lignes à une telle matrice est de plus en plus douloureux
0

L'autre réponse décrivant des tableaux de tableaux sont corrects.

MAIS si vous prévoyez de faire un quelque chose de mathématique avec les tableaux ou besoin de quelque chose de spécial comme les matrices creuses, vous devriez regarder dans l'un des nombreux mathématiques libs comme TNT avant de le ré-inventer trop de roues

J'ai cette classe de la grille qui peut être utilisé comme une matrice simple si vous n'avez pas besoin d'opérateurs mathématiques.

/**
* Represents a grid of values.
* Indices are zero-based.
*/
template<class T>
class GenericGrid
{
public:
GenericGrid(size_t numRows, size_t numColumns);
GenericGrid(size_t numRows, size_t numColumns, const T & inInitialValue);
const T & get(size_t row, size_t col) const;
T & get(size_t row, size_t col);
void set(size_t row, size_t col, const T & inT);
size_t numRows() const;
size_t numColumns() const;
private:
size_t mNumRows;
size_t mNumColumns;
std::vector<T> mData;
};
template<class T>
GenericGrid<T>::GenericGrid(size_t numRows, size_t numColumns):
mNumRows(numRows),
mNumColumns(numColumns)
{
mData.resize(numRows*numColumns);
}
template<class T>
GenericGrid<T>::GenericGrid(size_t numRows, size_t numColumns, const T & inInitialValue):
mNumRows(numRows),
mNumColumns(numColumns)
{
mData.resize(numRows*numColumns, inInitialValue);
}
template<class T>
const T & GenericGrid<T>::get(size_t rowIdx, size_t colIdx) const
{
return mData[rowIdx*mNumColumns + colIdx];
}
template<class T>
T & GenericGrid<T>::get(size_t rowIdx, size_t colIdx)
{
return mData[rowIdx*mNumColumns + colIdx];
}
template<class T>
void GenericGrid<T>::set(size_t rowIdx, size_t colIdx, const T & inT)
{
mData[rowIdx*mNumColumns + colIdx] = inT;
}
template<class T>
size_t GenericGrid<T>::numRows() const
{
return mNumRows;
}
template<class T>
size_t GenericGrid<T>::numColumns() const
{
return mNumColumns;
}

À l'aide de la double pointeur est de loin le meilleur compromis entre vitesse d'exécution/de l'optimisation et de la lisibilité. À l'aide d'un seul tableau pour stocker la matrice de contenu est en fait qu'un double pointeur n'.

J'ai utilisé avec succès les suivantes basées sur des modèles de créateur de fonction (oui, je sais que j'ai utiliser de vieux C-style pointeur de référencement, mais il le fait de rendre le code plus clair sur la partie appelante en ce qui concerne la modification des paramètres - quelque chose que j'aime sur les pointeurs qui n'est pas possible avec des références. Vous verrez ce que je veux dire):

///
///Matrix Allocator Utility
///@param pppArray Pointer to the double-pointer where the matrix should be allocated.
///@param iRows Number of rows.
///@param iColumns Number of columns.
///@return Successful allocation returns true, else false.
template <typename T>
bool NewMatrix(T*** pppArray, 
size_t iRows, 
size_t iColumns)
{
bool l_bResult = false;
if (pppArray != 0) //Test if pointer holds a valid address.
{                  //I prefer using the shorter 0 in stead of NULL.
if (!((*pppArray) != 0)) //Test if the first element is currently unassigned.
{                        //The "double-not" evaluates a little quicker in general.
//Allocate and assign pointer array.
(*pppArray) = new T* [iRows]; 
if ((*pppArray) != 0) //Test if pointer-array allocation was successful.
{
//Allocate and assign common data storage array.
(*pppArray)[0] = new T [iRows * iColumns]; 
if ((*pppArray)[0] != 0) //Test if data array allocation was successful.
{
//Using pointer arithmetic requires the least overhead. There is no 
//expensive repeated multiplication involved and very little additional 
//memory is used for temporary variables.
T** l_ppRow = (*pppArray);
T* l_pRowFirstElement = l_ppRow[0];
for (size_t l_iRow = 1; l_iRow < iRows; l_iRow++)
{
l_ppRow++;
l_pRowFirstElement += iColumns;
l_ppRow[0] = l_pRowFirstElement;
}
l_bResult = true;
}
}
}
}
}

De désallouer de la mémoire créé à l'aide de la susdite utilitaire, il suffit de répartir dans le sens inverse.

///
///Matrix De-Allocator Utility
///@param pppArray Pointer to the double-pointer where the matrix should be de-allocated.
///@return Successful de-allocation returns true, else false.
template <typename T>
bool DeleteMatrix(T*** pppArray)
{
bool l_bResult = false;
if (pppArray != 0) //Test if pointer holds a valid address.
{
if ((*pppArray) != 0) //Test if pointer array was assigned.
{
if ((*pppArray)[0] != 0) //Test if data array was assigned.
{
//De-allocate common storage array.
delete [] (*pppArray)[0];
}
}
//De-allocate pointer array.
delete [] (*pppArray);
(*pppArray) = 0;
l_bResult = true;
}
}
}

À l'utilisation de ces précitée modèle de fonctions est alors très facile (par exemple):

   .
.
.
double l_ppMatrix = 0;
NewMatrix(&l_ppMatrix, 3, 3); //Create a 3 x 3 Matrix and store it in l_ppMatrix.
.
.
.
DeleteMatrix(&l_ppMatrix);

const int nRows = 20;
const int nCols = 10;
int (*name)[nCols] = new int[nRows][nCols];
std::memset(name, 0, sizeof(int) * nRows * nCols); //row major contiguous memory
name[0][0] = 1; //first element
name[nRows-1][nCols-1] = 1; //last element
delete[] name;

Vous devez vous connecter pour publier un commentaire.