comment fonctionne l'opérateur new

bonjour à tous,

j'utilise très très souvent l'opérateur new dans mes codes pour faire de l'allocation dynamique, mais je ne comprends pas du tout son implémentation :

Code:

---

MyClass * p1 = new MyClass[5];

---

Par exemple, si je crée une classe MyNew :

Code:

---

1 2 3 4 5 6 7 8 9 10

class MyNew { //blablabla   void* operator[](int size) { //j'alloue une taille de size octet(s) dans le tas return ptr; } };

---

Si alors je veux allouer un pointeur avec ma classe MyNew je dois :

Code:

---

1 2 3 4 5

MyNew myNew; int main() { int* ptr = myNew[10 * sizeof(int) ]; }

---

en aucun cas j'ai la syntaxe : MyClass * p1 = new MyClass[5];.
Comment je peux faire ?

Merci d'avance

Bonjour,

new n'est pas une classe ni une fonction, tu l'a écris toi-même c'est un opérateur. Tout comme le sont +, -, sizeof ou typeid ou delete.
On ne peut donc pas créer un "new". On peut par contre le surcharger comme on peut surcharger + ou - ou delete (évidement sizeof ou typeid eux ne peuvent pas être surchargés).

Et attention, tu dis très souvent utiliser new, il semble donc que tu n'as pas bien compris quand on doit utiliser new (et fait on ne doit normalement JAMAIS l'appeler directement, la bibliothèque nous fournit les objets qui savent l'utiliser intelligemment.)

Je ne comprends pas bien quel est ton besoin.

merci pour ta réponse.

effectivement j'étais à l'ouest en ce qui concerne 'new' je pensais que c'était un objet comme cout ou cin et qu'on avait créé l'operator [] dans la classe.

Mais en faite new est comme un +,-,/,* ce qui peut parraitre un peu déroutant pour un débutant. Pourquoi avoir créer un operator et non une fonction comme en C qui parait plus simple à premiere vu pour la compréhension.

alors le besoin c'est uniquement de comprendre l'operateur new, c'est juste pour la curiosité

Salut,

Citation:

---

Envoyé par cosmoff

Mais en faite new est comme un +,-,/,* ce qui peut parraitre un peu déroutant pour un débutant. Pourquoi avoir créer un operator et non une fonction comme en C qui parait plus simple à premiere vu pour la compréhension.

---

Attention, les opérateurs sont des fonctions, par nature, même si ce sont des fonctions particulières ;)

La seule chose, c'est que le langage fournit un moyen "plus simple" de les utiliser, correspondant d'avantage ce que l'on a l'habitude de faire ;)

Un petit exemple, avec l'opérateur + : Quand tu veux surcharger ton opérateur + pour un type particulier (mettons un point), tu vas écrire un code ressemblant à

Code:

---

1 2 3 4

Point operator + (Point const & a, Point const & b){ /* toute la logique nécessaire */ return pointTemporaire; }

---

On se rend donc bien compte qu'il s'agit d'une fonction tout à fait classique par la manière dont on en défini le comportement ;)

Et, pourtant, quand tu effectue une addition sur ta feuille de papier, tu vas écrire quelque chose ressemblant à 4 + 3; et non quelque chose ressemblant à add(4, 3).

Ce n'est donc vraiment qu'une possibilité de faire les choses "plus simplement", sans devoir passer par l'appel (fort lourd au demeurant) d'une fonction ;)

Citation:

---

Envoyé par cosmoff

Mais en faite new est comme un +,-,/,* ce qui peut parraitre un peu déroutant pour un débutant. Pourquoi avoir créer un operator et non une fonction comme en C qui parait plus simple à premiere vu pour la compréhension.

---

Ça n'est pas une fonction car c'est impossible de créer une fonction qui joue ce rôle. L'opérateur new reçoit comme donné de travail un type. Et un type ça ne peut pas être un paramètre de fonction. Il nous reste quand même les template-fonctions qui sont paramétrables, ça donnerait :

Code:

---

1 2 3 4 5 6 7 8

template<typename T,typename ...UU> T* monNewTemptative1( UU&& prms... ) { return new T(std::forward<UU>(prms)...); // Ouais mais finalement je triche car je revient à new qui sait créer des types! } template<typename T,typename ...UU> T* monNewTemptative2( UU&& prms... ) { char* buffer = malloc( sizeof (T) ); // j'ai réussi à contourner l'allocation faite par new new(buffer) T(std::forward<UU>(prms)...); // mais Ouais je dois tricher encore en utilisant l'opérateur de new-en-place return reinterpret_cast<T*>( buffer ); }

---

Ces template (surtout sous cette forme) n'existaient pas au début du C++, mais même eux n'arrivent pas à émuler ce que fait l'opérateur new. NOn vraiment new n'est pas du tout une fonction, ni un objet.