Discussion :

[cosmoff]

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 :

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

MyClass * p1 = new MyClass[5];

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

Code :

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

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 :

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

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

[dalfab]

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.

[cosmoff]

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é

[koala01]

Salut,

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 :

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

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

[dalfab]

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 :

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

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.