allocation de mémoire dynamique

Bonjour,
Quelle différence y a t il entre

Code:

---

1 2	int* tableau=0; tableau = new int [x*y];

---

et

Code:

---

1 2	int ** tableau =0; tableau = new int* [x][y];

---

Y a t il des différences au niveau de la mémoire ?

Merci

Ton code est mauvais :aie: il y a 1 différence entre 0, NULL (qui vaut 0L) et nullptr.

Et ensuite ton code tableau = new int* [x][y]; ne compile pas error: cannot convert 'int* (*)[2]' to 'int**' in assignment.

Et ensuite ce genre de pointeur de pointeur int** tableau, il faut le contexte pour répondre :aie: :aie: SURTOUT EN C++ QUI A LA STL ET LES CONTAINERS
Parce que pour moi ce pointeur permet de manipuler 1 tableau ou 1 autre pointeur de type int*, et notamment son allocation.

Mais je pense aussi aux exercices :whistle:, où on demande la différence entre 1 tableau 2d classique, et 1 autre tableau 1d et chaque pointeur est 1 tableau pour simuler 1 ligne (<- ce qui revient à 1 tableau 2d)

Merci Fœtus de t'être penché sur ma question.
Oui mon code ne compile pas parce que j'avais complètement zappé que la seconde dimension ne peut pas être une variable dans les tableaux dynamiques.

En fait mon problème est que je me retrouve à devoir créer un nombre de tableaux encore inconnu au moment de la compilation.
Par contre en fonction d'une variable qui apparaît au milieux du programme on peut savoir combien de tableaux on aura besoin AU MAXIMUM.
Mais le nombre final de tableaux ne se précise qu'au fur et à mesure du déroulement du programme...

Alors j'ai pense créer un mega grand tableau de la taille maximale possible, et m'y promener en utilisant les références x,y,z (x pour numéro de tableau, y et z pour les colonnes et les lignes)
Le problème c'est la TAILLE de ce tableau... Qui nécessite de trouver dans la mémoire un espace libre consécutif énorme!
C'est pourquoi je cherchais à savoir si en faisant un tableau de pointeurs sur pointeurs, peur être que chaque tableau prendrait alors une place à part...

Sinon je n'ai pas bien compris

Code:

---

int* tableau=0;

---

n'est pas une bonne formule ?

Citation:

---

Envoyé par Legro

Code:

---

1 2	int* tableau=0; tableau = new int [x*y];

---

---

Ce code est mauvais, mais compile.

Citation:

---

Envoyé par Legro

Code:

---

1 2	int ** tableau =0; tableau = new int* [x][y];

---

---

Ce code est encore plus mauvais et ne compile même pas.

La différence au niveau de la mémoire ? En quoi ça te concerne quand tu débutes clairement ? Tu veux économiser 2 octets pour ...?
Apprends donc à utiliser std::vector et std::array.

Citation:

---

Envoyé par Legro

Code:

---

int* tableau=0;

---

n'est pas une bonne formule ?

---

Il faut utiliser la macro NULL parce qu'en fonction de la plateforme tu n'es pas sûr que 0 fasse 32bits (4 octets) ou 64bits (8 octets), la taille d'1 pointeur.
Et ensuite depuis C+11, nullptr parce qu'il y a ambiguïté parce NULL reste 1 entier :mrgreen:

Code:

---

1 2 3 4

void func(int n); void func(char* s);   func(NULL); // guess which function gets called?

---

Merci encore Fœtus.
Je ne savais pas du tout qu'il pouvait y avoir un problème avec un pointeur sur zero. Je note bien.

Pour mon problème j'ai enfin trouvé une solution toute simple : utiliser des pointeurs de vector.

Code:

---

1 2 3 4

vector<int>* tableau=nullptr; tableau=new vector<int>[nombreMaximalDeTableaux]; tableau[x].push_back(variable); delete [] tableau; tableau=nullptr;

---

Ca compile et ça marche!

Citation:

---

Envoyé par Bousk

La différence au niveau de la mémoire ? En quoi ça te concerne quand tu débutes clairement ? Tu veux économiser 2 octets pour ...?

---

Je comprends ton étonnement; en fait ça me concerne dans la mesure où en ayant besoin d'utiliser des tableaux à plusieurs dimensions j'arrive très très vite à une des (nombreuses) limites de la mémoire.

Citation:

---

Envoyé par Bousk

Apprends donc à utiliser std::vector et std::array.

---

Merci, je les utilise depuis pas mal de temps, mais là j'étais coincé...
Du coup j'ai fait un petit "mix" pointeur/vector, comme je l'ai écris à Fœtus, et pour cette fois ça à l'air de marcher.
Merci à tous.

Ce mix est la pire solution possible.:arf:
Le pointeur n'a strictement rien à faire ici et absolument aucune utilité.
std::vector::resize

Citation:

---

Envoyé par Bousk

Le pointeur n'a strictement rien à faire ici et absolument aucune utilité.

---

Dans l'absolu tu as certainement raison, mais dans mon cas le pointeur a une fine utilité :
Je me retrouve dans certains cas extremes avec des tableaux qui contiennent 1024000000 éléments, ou plus. Si en plus je me mets à réunir plusieurs de ces tableaux dans un seul vector ça dépasse la capacité du PC non par manque de mémoire, mais par incapacité de donner une adresse tellement élevée à la suite du tableau (eh oui l'ordi ne sait pas compter jusqu'à l'infini). En faisant un pointeur de vector, et donc en séparant chaque tableau, j'évite tout simplement cet écueil.

Le principe du vector c'est de gérer le pointeur interne. Que le vector soit lui aussi un pointeur n'a absolument aucun intérêt dans ton cas - et dans l'immense majorité des cas. :weird:

De toute évidence tu as des lacunes pour ce qui concerne la mémoire, les pointeurs et vector.
Cadeau:

Code:

---

1 2 3

vector<vector<int>> tableau; tableau.resize(nombreMaximalDeTableaux); tableau[x].push_back(variable);

---

Merci Bousk, là tu m'as bien éclairé !
J'avais bien entendu essayé de créer un vector de vector comme tu viens de le faire, mais avec une grosse erreur de conception! Voici le code erroné :

Code:

---

1 2 3

vector<vector<int>> tableau; tableau.reserve(nombreMaximalDeTableaux); tableau[x].push_back(variable);

---

L'échec de cet essai m'a conduit à hâtivement abandonner la piste, et à me tourner vers les pointeurs "tout crus".
Mais en fait vector.reserve ne fait que prévoir un espace mémoire sans réellement l'allouer, et donc impossible d'utiliser cet espace comme j'ai bêtement voulu le faire :(
En utilisant vector.resize comme tu le préconise le problème est résolu, et il s'agit bien là de la meilleure solution!
(dans mon esprit l’intérêt de vector.resize se résumait à diminuer la taille d'un vector qui avait consommé trop de mémoire, sans plus, mais en fait voilà un exemple notable de son utilisation dans l'autre sens).
Encore une fois merci!
En espérant que ce petit post servira un jour à en éclairer d'autres comme moi :)

Bonjour,
J'ajoute ici une petite remarque suite à mes essais, et qui pourra peut être servir :
certains compilateurs refusent la forme

Code:

---

vector<vector<int>> tableau;

---

à cause de l'ambiguité avec l'opérateur ">>"
Il faudra donc coder

Code:

---

vector<vector<int> > tableau;

---

avec un espace entre les deux ">", ce qui règle le problème.
Bonne journée.

Bonjour

Cette ambiguïté (le >> pour les templates) est résolue en C++11.