Bonjour � tous,

Je travaille avec de gros tableaux. Comme il m'arrive fr�quemment d'�tre un peu limite question m�moire, je souhaite pouvoir cr�er des tableaux dans le stack.

Enfin, c'est ce que j'ai compris, mais je n'en suis pas certain ; il semble qu'il y a deux sortes de m�moires. Si l'on cr�e un tableau avec des dimensions connues � la compilation par
Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
 
char table[1000000][2]
par exemple, on utilise une sorte de m�moire. Si au contraire on cr�e le tableau � l'ex�cution par :
Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
5
6
 
char **table_dyn;
...
   table_dyn = new char*[dim1];
   for (int j=0;j<dim1;j++)
      table_dyn[j] = new char[dim2];
on utilise alors une autre sorte de m�moire, qui est moins limit�e que la premi�re, et surtout qui en tous cas vient en compl�ment de la premi�re. Il me semble que c'est celle-l� que l'on appelle le "stack". L'autre avantage est bien entendu d'avoir la possibilit� d'ignorer les dimensions du tableau � la compilation : on peut utiliser une variable pour dimensionner � l'ex�cution.
Mais peut-�tre n'ai-je rien compris ! Suis-je compl�tement � c�t� de la plaque ?

Je connais d�s la compilation les dimensions de mes tableaux, donc cette possibilit� de les dimensionner � l'ex�cution seulement ne m'est pas indispensable.

Ma question concerne la m�moire occup�e, d'une part, les performances du programme, d'autre part.

Avec :
Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
 
char table[1000000][2]
l'occupation m�moire est exactement de 2000000 octets (logique !). sizeof(table) me renvoie bien 2000000. Et la diff�rence d'adresse entre le dernier octet et le premier octet de mon tableau est bien 1999999.

Ce qui me g�ne c'est que dans le cas d'une d�finition dynamique avec "new",
Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
5
6
 
char **table_dyn;
...
   table_dyn = new char*[dim1];
   for (int j=0;j<dim1;j++)
      table_dyn[j] = new char[dim2];
je constate que les deux octets table_dyn[0][0] et table_dyn[0][1] �tant bien dans deux adresses cons�cutives, l'octet suivant (table_dyn[1][0]) est situ� apr�s un saut de 14 octets. De m�me, les octets table_dyn[1][0] et table_dyn[1][1] sont cons�cutifs, et table_dyn[2][0] saute � nouveau 14 octets. Et ainsi de suite (je pense que C++ utilise syst�matiquement une adresse multiple de 16 � chaque utilisation de "new"). Il me semble clair qu'� chaque utilisation de "new" le syst�me place le nouveau tableau l� o� il trouve de la place, ce qui ne me g�ne nullement) mais surtout, qu'il perd syst�matiquement des octets (ici, 14) � vouloir placer les nouveau tableaux � des adresses multiples de 16 (et �a, �a ma g�ne car cela multiplie par 8 (dans mon cas) la place occup�e).

sizeof(table_dyn) me donne 4 !! Bah, cela �a m'est �gal, mais bon !

Le deuxi�me probl�me est qu'avec une telle organisation, les performances du programme risquent fort d'�tre d�grad�es � cause d'une double r�f�rence m�moire pour localiser chaque �l�ment du tableau - ceci �tant d� � la non r�gularit� des emplacements.

Mes questions est donc :

Y-a-t-il moyen de cr�er un tableau � deux dimensions en une seule commande avec new, de mani�re � cr�er un bloc de 2000000 octets cons�cutifs sans gaspillage de m�moire et en optimisant les performances ?

Et :

Y-a-t-il moyen de cr�er un tableau de dimensions connues � la compilation, mais dans cette deuxi�me m�moire utilis�e par "new" (c'est-�-dire dans le "stack, n'est-ce pas ?), possibilit� qui elle aussi r�soudrait mon probl�me ?


Merci d'avance pour vos r�ponses !