Allocation / libération : type de pointeur différent

Bonsoir,

Ce code a t il un comportement défini?

Code:

---

1 2 3 4

double * d = new double[1000];   char * c = reinterpret_cast<char *>(d); delete[] c;

---

Si oui est-ce le même que le suivant, sinon quel est il?

Code:

---

1 2	double * d = new double[1000]; delete[] d;

---

merci

Je viens de tester ton code, cela marche dans le sens où cela ne plante pas (VC++ 2005)

ceci dit, je l'ai tester avec une autre condition :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class Classe { public: Classe() {} ~Classe() {} };   double * d = new double[1000]; Classe * c = reinterpret_cast<Classe *>(d); delete[] c;

---

et là, cela ne marche plus (ce qui est normal). Lors du delete, c'est le destructeur de la classe Classe qui est appelé et l'objet à détruire n'est pas un objet de type "Classe", donc cela part en cacahuetes.

Je pense que ton code initial fonctionne car les types "char" et "double" sont des types de "base" (je ne connais pas le mot en C++ s'il y en a un). Ils n'ont pas de destructeur.

Il n'est pas autorisé d'appeler delete ou delete[] sur un type de pointeur différent de celui utilisé pour le new/new[] correspondant, à moins que le type ait un destructeur virtuel, auquel cas il est possible d'appeler delete/delete[] avec un pointeur vers un type base du type utilisé pour le new/new[].

Après, concrètement, sur une implémentation normale, ça ne doit poser aucun problème avec les PODs.

C'est un comportement indéfini.

Par contre, sous l'implémentation Microsoft, pour des objets dépourvus de destructeur, ça ne change rien.

Citation:

---

Envoyé par loufoque

Après, concrètement, sur une implémentation normale, ça ne doit poser aucun problème avec les PODs.

---

C'est quoi PODs ?

Salut,

Citation:

---

Envoyé par ram_0000

C'est quoi PODs ?

---

Plain Old Data...

Autrement dit, tout type défini par l'utilisateur qui ne fait que regrouper plusieurs valeurs composées de type primitifs.

Concrètement, il s'agit de toute structure "C style" ;)

Et ... si le couple new[]/delete[] est détourné pour un type et pas l'autre?

Merci.

Effectivement je travaille exclusivement sur les types entiers et flottants, définis dans le langage.

Comme a priori ce n'est pas autorisé d'utiliser new et delete dans ce cas, je suis passé par free et malloc pour gérer la mémoire.

Tu aurais pu passer par leur équivalent C++ à la place, operator new et operator delete.

Je ne comprends plus là :?

Citation:

---

Envoyé par loufoque

Il n'est pas autorisé d'appeler delete ou delete[] sur un type de pointeur différent de celui utilisé pour le new/new[] correspondant.

---

Citation:

---

Envoyé par loufoque

Tu aurais pu passer par leur équivalent C++ à la place, operator new et operator delete.

---

Tu sais, à moins que je me trompe grandement, tu peux toujours faire ceci...

Code:

---

1 2 3 4 5 6 7

double * d = new double[1000]; char * c = reinterpret_cast<char *>(d);   ...   double * d2 = reinterpret_cast< double * >(c); delete[] d2;

---

Tu confonds new et operator new.
Ce sont deux choses différentes.

Pourquoi ne fais-tu pas:

Code:

---

1 2 3 4

char * c = new char[1000 * sizeof(double)]; double * d = reinterpret_cast<double *>(c); // si besoin delete[] c;

---

Citation:

---

Envoyé par loufoque

Tu confonds new et operator new.
Ce sont deux choses différentes.

---

Penses-tu pouvoir rediger une petite explication a ce sujet qu'on pourrait ajouter a la FAQ? :D

Effectivement je dois confondre.

Je viens de lire (en partie) ça : http://www.scs.cs.nyu.edu/~dm/c++-new.html.

Si j'ai bien compris, new/new[]/delete/delete[] est toujours un opérateur mais défini de plusieurs façon.

Et donc tu me proposais d'utiliser les versions :

Code:

---

1 2	void *operator new[] (size_t); void operator delete[] (void *);

---

Est ce que ce ne sont pas déjà ces version qui sont utilisées dans mon cas?

Sinon ce code serait valide ? :

Code:

---

1 2 3 4

double * d = ::operator new double[1000];   char * c = reinterpret_cast<char *>(d); ::operator delete[] c;

---

En fait j'ai maintenant lu l'item 8 de "more effective c++" de Scott Meyers, et tout est plus clair :D.

Il faut donc bien voir la différence entre :
- "new expression" (new operator dans mec++);
- et la fonction "operator new";

La seconde permet de trouver une zone mémoire pour stocker les données.
La première est une expression retravaillée par le compilateur pour appeler la seconde puis initialiser la mémoire à l'aide du constructeur.

Seule la seconde est surchargeable.

Donc cette fois ci je pense avoir compris ce que tu me proposes :

Code:

---

1 2 3 4

double * d = static_cast<double *>(operator new(sizeof(double) * 1000));   char * c = reinterpret_cast<char *>(d); operator delete(c);

---

Cependant je me repose la question initiale :
"Ce code a t il un comportement défini?"

Vu qu'il n'y a jamais d'appel destructeur avec les opérateurs, je dirais que oui.
Ce code se comporte juste comme un code avec malloc() et free().