Discussion :

[Robxley]

Bonjour,

J'ai juste une question sur le fonctionnement de l'opérateur delete[].
Est il possible d'utiliser l'opérateur delete[] sur une variable qui a été alloué par new, (et non l'opérateur tableau new[]).

Un petit exemple de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
int *ptr;
 
if (condition1) ptr = new int;
else ptr = new int[10];
/*j'utilise mon ptr ds mon pogramme*/
 
delete[] ptr;

Donc est ce que dans le cas ou la condition1 est vérifiée il est autorisé d'appeller delete[] sur ptr ?

Alors vous me direz pour régler le problème il suffit de faire ptr = new[1] pour ne plus se poser la question, mais c'est plus une question de curiosité que de solution algorithmique.

[Goten]

delete[] sur un objet alloué avec new donne un comportement indéfinie.

[Robxley]

Oki, merci pour la réponse.

Je me suis un peu renseigné, si j'ai bien compris lors de l'appel à new[] il y a une sauvegarde du nombre n d'éléments lors de l'allocation mémoire, ce même nombre n étant utilisé par delete[] par la suite. Donc il semblerait que lors de l'appel de new[]/delete[] il y a un stockage de ce n qui coute de l'espace mémoire ? ce n est stocker ou et comment ?

et ça voudrait dire que :

int *i = new int; demande moins d'espace mémoire que :
int *i = new int[1];

Certe la différence en espace mémoire doit être minimum mais ceci peut avoir de l'importance dans le cas ou le système est limité en espace mémoire (système embarqué par exemple);

[3DArchi]

Oki, merci pour la réponse.

Je me suis un peu renseigné, si j'ai bien compris lors de l'appel à new[] il y a une sauvegarde du nombre n d'éléments lors de l'allocation mémoire, ce même nombre n étant utilisé par delete[] par la suite. Donc il semblerait que lors de l'appel de new[]/delete[] il y a un stockage de ce n qui coute de l'espace mémoire ? ce n est stocker ou et comment ?

et ça voudrait dire que :

int *i = new int; demande moins d'espace mémoire que :
int *i = new int[1];

Certe la différence en espace mémoire doit être minimum mais ceci peut avoir de l'importance dans le cas ou le système est limité en espace mémoire (système embarqué par exemple);

Ce sont des détails d'implémentations. Tu peux avoir des gestions mémoires complètement différentes où par exemple, n serait stocké tout le temps, ou encore dans lesquels les blocs mémoires ont toujours la même taille, etc. Tu ne peux t'appuyer sur un détail d'implémentation particulier. Ce que te dis le langage entre autre :
new [] -> delete []
new -> delete
si tu croises -> comportement indéfini.
Les garanties de var = new[N] :
-> var[0], var[1], ... var[N-1] sont des objets valides
-> &var[0] + i == &var[i] (i<N)

[ptyxs]

Chez moi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
#include <iostream>
using namespace std;
 
int main()
{
  int tab[]={1};
  cout << sizeof(int) << ' ' << sizeof(tab);
}

donne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

4 4

[3DArchi]

Un tableau statique n'est pas pareil qu'un tableau dynamique. Il n'y a pas de correspondance new/delete. On ne peut pas comparer.

[ptyxs]

Mon exemple n'était pas pertinent car la question portait sur new/delete[] (et sur le surplus de mémoire qu'ils impliquent, pas sur le tableau lui-même), mais il me semble par ailleurs que le tableau créé par new est tout ce qu'il y a de statique non ? (au sens où leur taille est invariable), ou bien je ne comprends pas le sens de "tableau statique" ?

[3DArchi]

Le problème du vocabulaire est qu'on l'emploi parfois un peu rapidement sans en partager la sémantique
J'ai utilisé les termes statiques et dynamiques dans les sens suivants - peut être mal à propos d'une façon générale mais qui m'ont paru approprié dans ce cas :
-> tableau statique : Type var[] ;
-> tableau dynamique : Type var=new[].
Dynamique n'étant pas tant du au fait qu'on peut modifier dynamiquement la taille d'un tableau existant, mais plutôt qu'on définit sa taille au moment de l'exécution et qu'on obtient un emplacement dynamiquement.

[Robxley]

Oki oki, merci pour toutes ces réponses.

Quoi qu'il en soit j'utiliserai new avec delete, et le grand frère du 1er avec le grand frère du 2nd, new[] -> delete[]

[Chatanga]

En pratique, j'ai toujours relevé le même comportement pour l'instruction new[] : un mot mémoire est utilisé en amont du bloc mémoire retourné (par la méthode new[] qui est redéfinissable de différentes manières) pour stocker la taille du tableau ssi la classe instanciée comporte un destructeur. Le seul but de stocker la taille est en effet d'appeler le destructeur pour chaque instance du tableau (et c'est pourquoi appeler delete[] sur un bloc mémoire alloué par new est casse-gueule).

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
tab = new MaClasse[5]; // sizeof(MaClasse) == 4
 
|<------------ new[](5*4+1) ------------->|
 
|5|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
  ^       ^       ^       ^       ^
                  |
                tab[2]

Mais il est sans doute vrai que la norme du C++ ne spécifie pas la manière dont un compilateur doit procéder dans ce domaine.

[3DArchi]

En pratique, j'ai toujours relevé le même comportement pour l'instruction new[] : un mot mémoire est utilisé en amont du bloc mémoire retourné (par la méthode new[] qui est redéfinissable de différentes manières) pour stocker la taille du tableau ssi la classe instanciée comporte un destructeur. Le seul but de stocker la taille est en effet d'appeler le destructeur pour chaque instance du tableau (et c'est pourquoi appeler delete[] sur un bloc mémoire alloué par new est casse-gueule).

Salut,
J'ai travaillé sur des plate-formes embarquées dans lesquelles les allocations fonctionnaient par pool de blocs mémoires de taille fixe (suivant le pool). Donc new T[1] et new T retournait un bloc de même taille. Quand au fait de savoir si le nombre d'éléments est avant, après ou ailleurs, j'avoue ne pas avoir comparé différents compilo pour voir les différences. Cela reste un détail d'implémentation sur lequel il est dangereux de tirer de quelconques conclusions.

[Goten]

Sans compter que new peut être surchargé pour utiliser un autre allocateur. (plus perf pour les petits objets par exemple...)

[Médinoc]

Pire, il y a des implémentations où le comportement de new[] varie selon que le type alloué soit POD ou non...

[koala01]

Chez moi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
#include <iostream>
using namespace std;
 
int main()
{
  int tab[]={1};
  cout << sizeof(int) << ' ' << sizeof(tab);
}

donne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

4 4

Il faut en plus attirer l'attention sur le fait que tab représente en réalité "l'adresse du premier élément du tableau (de tab[0])"...

Or, un pointeur est une variable numérique (non signée) dont la taille (en nombre de bits / bytes) est... suffisante pour représenter l'ensemble des adresses mémoires utilisée.

En fonction du processeur utilisé (32 ou 64 bits), du systeme d'exploitation (idem) et du compilateur (64 bits compliant ou non) utilisé, tu peux très bien avoir des valeurs différentes, un int pouvant toujours être représenté sous la forme de 4 bytes (bien que rien ne l'oblige), mais un pointeur pouvant, par exemple, etre représenté sous la forme de... 8 byte (équivalent à unsigned long ou unsigned long long), toujours, sans obligation aucune.

[Médinoc]

Attention, sizeof(tab) sera toujours sizeof(int) ici:
Le tableau est implicitement convertible en pointeur, mais reste un tableau; tout comme &tab n'est pas de type int**, mais de type int(*)[4]...

[screetch]

new int[] n'a pas besoin de stocker le nombre d'éléments, c'est le cas seulement pour les classes qui ont un destructeur qui doit etre appelé. le role de ce petit nombre est de savoir combien de destructeurs doivent etre appelés.

si l'on redéfinit l'opérateur new[] on peut s'en rendre compte :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <new>
#include <cstdio>
 
class Test1
{
    int m_pad;
public:
    void* operator new[](size_t size) { printf("size : %d\n", size); return ::operator new(size); }
    void  operator delete[](void* ptr) { return ::operator delete(ptr); }
};
 
class Test2 : public Test1
{
public:
    ~Test2() { printf("non trivial\n"); }
};
 
 
int main()
{
    Test1 *tests1 = new Test1[1];
    Test2 *tests2 = new Test2[1];
    delete[] tests2;
    delete[] tests1;
    return 0;
}

renvoie 4 pour un Test1 et 12 pour un Test2 (8 octets sur ma machine 64 bits)


[edit] en fait c'est deja ce qu'a dit chatanga

[ptyxs]

Il faut en plus attirer l'attention sur le fait que tab représente en réalité "l'adresse du premier élément du tableau (de tab[0])"...

Or, un pointeur est une variable numérique (non signée) dont la taille (en nombre de bits / bytes) est... suffisante pour représenter l'ensemble des adresses mémoires utilisée.

En fonction du processeur utilisé (32 ou 64 bits), du systeme d'exploitation (idem) et du compilateur (64 bits compliant ou non) utilisé, tu peux très bien avoir des valeurs différentes, un int pouvant toujours être représenté sous la forme de 4 bytes (bien que rien ne l'oblige), mais un pointeur pouvant, par exemple, etre représenté sous la forme de... 8 byte (équivalent à unsigned long ou unsigned long long), toujours, sans obligation aucune.

En fait tab est ambigu : traité comme pointeur ou tableau selon le contexte, c'est bien un des inconvénients de ce type d'objets.
sizeof(tab) donne bel et bien la taille du tableau et non du pointeur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
#include <iostream>
using namespace std;
 
int main()
{
  int tab[]={1,2,3,4,5,6};
  cout << sizeof(int) << ' ' << sizeof(tab);
}

donne chez moi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

4 24