Comment utilisez-vous un pointeur vide pour générer un tableau dynamique 2D?

Question

Est-ce que quelqu'un sait comment utiliser un pointeur vide pour générer un tableau 2D plutôt qu'un int pointeur?

Pour pointeur entier, je fais comme suit:

int **m; 

m = new int* [row];  
for(int i=0; i< row; i++)  
     m[i] = new int[col]; 

for (int i = 0; i < row; i++) 
     for (int j = 0; j < col; j++) 
      m[i][j] = rand() % 10; 

si le type de pointeur est vide *** m?

Comment puis-je définir le stockage comme int? par exemple. (m = new int * [row];)

Merci pour votre aide.

---

S'il vous plaît permettez-moi de préciser ma question plus claire, je me donne ces:

class Matrix 
{ 
    public: 
      Matrix(); 
      Matrix(int,int); 

      void printMatrix(); 

    private: 
      int row; 
      int col; 
      void***m; 
      void initMatrix();  // Initialize the storage for row and column 
      void generateMatrix(); // construct a 2D array 
} 

Answer 1

Vous ne pouvez pas. Vous devez connaître la taille des éléments si vous êtes responsable de la création du tableau. Avec un void *, vous ne savez rien sur ce qu'il désigne. Vous devriez avoir l'appelant vous fournir un argument de taille ou quelque chose.

Modifier: Peut-être la troisième * est la clé: il vous demande de créer un tableau à deux dimensions de void *, peut-être? Après tout, void * est un type tout autant que int est. Où vous dites new int[col] vous devriez pouvoir dire new void * [col]. Vous n'avez pas montré assez de votre code pour que j'obtienne vraiment comment vous le faisiez, mais si cela fonctionnait avec int**, alors il devrait fonctionner avec void*** presque juste en faisant juste une recherche-et-remplacer sur int =>void * .

Answer 2

Avec l'extrait que vous avez posté dans un commentaire à une autre réponse, c'est un peu plus facile de vous aider.

class Matrix { 
    private: 
    int row; 
    int col; 
    void** m; 
} 

code pour initialiser les lignes de la table pourrait être quelque chose comme ceci:

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

Espérons que vous pouvez utiliser pour résoudre le reste de vos devoirs, vous.

Answer 3

Votre question est probablement mieux répondu par une explication de ce que signifie void.

void indique fondamentalement l'absence d'un type. En conséquence, vous ne pouvez pas demander au compilateur de créer un objet de type void, par ex. avec les énoncés suivants:

• new void
• new void[...]

La signification de ces expressions est à peu près ce qui suit: "créer quelque chose", ou "créer un tableau de somethings" respectivement. Ce n'est clairement pas une déclaration assez précise pour le compilateur.

void* (pointeur vers void) est cependant autorisé car les pointeurs sont fondamentalement toujours la même chose pour le compilateur: une adresse mémoire d'un autre objet.Vous pouvez penser à un pointeur comme une sorte de flèche pointant vers quelque chose. Si vous travaillez avec un pointeur, le compilateur voit cette flèche, et non la chose sur laquelle elle pointe. Par conséquent le compilateur ne se soucie pas que le "type de cible" est void.

La conséquence de cela, cependant, est que vous ne pouvez pas déréférencer un void* (pointeur vers void), car alors vous faites le compilateur regarder efficacement à l'pointé à la chose, ce qui serait une valeur void, qui ne avoir un sens pour le compilateur.

Résumé:

1) Vous ne pouvez pas créer un tableau de type void, comme dans new void[...].

2) Vous pouvez créer un pointeur vers void (void*), ou même un pointeur vers un pointeur vers void* (void**).

3) Vous ne peut déréférencer un pointeur void* (mais vous pouvez déréférencer un pointeur void**).

Conclusions:

4) Vous pouvez créer un tableau int* et laisser un void* s'y réfèrent:

int** m; 
// ... (create the dangling array as in the OP's code and let m point to it) 
void* v = (void*)m; 

(Voir les commentaires ci-dessous pourquoi un void* est utilisé ici au lieu de void**!)

5) En raison de la déclaration n ° 3, tout ce que vous pouvez raisonnablement faire avec un tel pointeur est de le passer, mais vous ne pouvez pas travailler sur le contenu réel de la baie. Pour ce faire, vous devez taper moulé revenir au type de données correct:

int **m2 = (int**)v; 

Answer 4

Puisque chaque type de pointeur est implicitement convertible en void*, vous faites comme vous l'avez fait avec le int* et assignons à le void*.

Où est le problème? Est-ce que je manque quelque chose?

Answer 5

un void * est un pointeur vers un type non spécifié. Bien sûr, il est un heureux hasard que dans le cas d'un commun pointeur est exactement la même taille qu'un int, donc il n'y a vraiment rien qui vous empêche d'écrire:

int **m; 

m = new int* [row];  
for(int i=0; i< row; i++)  
    m[i] = new int[col]; 

for (int i = 0; i < row; i++) 
    for (int j = 0; j < col; j++) 
     m[i][j] = rand() % 10; 

void ***v = (void ***)m; // v is a 2-d array of void* pointers now! 

Bien sûr, je ne suis pas sûr Pourquoi voudriez-vous un tableau vide pour une classe Matrix? peut-être un type de données numérique personnalisé?

Answer 6

La réponse la plus proche que je peux penser est la suivante. Vous pouvez créer un tableau 2D comme vecteur d'ints, puis le transférer comme void *.Ceci est très similaire à la façon dont il est stocké en mémoire.

const unsigned int MaxRow = 10; 
const unsigned int MaxColumn = 10; 

void print(void * m) 
{ 
    int * matrix = (int *) m; 

    for(unsigned int i = 0; i < MaxRow; ++i) { 
     for(unsigned int j = 0; j < MaxColumn; ++j) { 
      std::printf("%03d ", matrix[ (i * MaxColumn) + j ]); 
     } 

     std::printf("\n"); 
    } 
} 

int main() 
{ 
    // Create 
    int * matrix = new int[ MaxRow * MaxColumn ]; 

    for(unsigned int i = 0; i < MaxRow; ++i) { 
     for(unsigned int j = 0; j < MaxColumn; ++j) { 
      matrix[ (i * MaxColumn) + j ] = (i * MaxColumn) + j; 
     } 
    } 

    // Show 
    print(matrix); 

    delete[] matrix; 
    return 0; 
} 

Answer 7

Laissez-moi préciser ma question!

Je me donne

class Matrix 
{ 
    public: 
      Matrix(); 
      Matrix(int,int); 

      void printMatrix(); 

    private: 
      int row; 
      int col; 
      void***m; 
      void initMatrix();  // Initialize the storage for row and column 
      void generateMatrix(); // construct a 2D array 
}