Discussion :

[méphistopheles]

Bonjour.

je vient de lire que l'opérateur new devait-être redéfini si on voulait l'utiliser pour une classe personalisée.
Cependant, je ne vois pas quelle adresse memoire il faudrais renvoyer pour pointer sur l'objet ainsi créé...

et puis pour créer un tableau .... je me pert dans la forme des opérateurs....


merci

[Laurent Gomila]

je vient de lire que l'opérateur new devait-être redéfini si on voulait l'utiliser pour une classe personalisée

Mais encore (quelle est ta source) ? Parce que là tel que tu le dis c'est très faux. La redéfinition de l'opérateur new, c'est seulement si on a des trucs louches à faire avec les allocations, ce n'est en rien une nécessité.

Cependant, je ne vois pas quelle adresse memoire il faudrais renvoyer pour pointer sur l'objet ainsi créé...

L'adresse renvoyée par la fonction d'allocation que tu auras utilisée dans ton opérateur new (malloc, HeapAlloc, ...) -- et non, ce n'est pas toi qui alloue la mémoire à la main

et puis pour créer un tableau .... je me pert dans la forme des opérateurs....

Il suffit de surcharger l'opérateur new[], après c'est la même chose.

[FabaCoeur]

Toutes les réponses que j'ai vu concernant ce sujet sont vagues.
C'est toujours quand on a des "allocations particulières" à faire ou dans des "cas particulier" mais je n'ai jamais eu la vision d'un cas concret. Quoiqu'il en soit, faut quand même avoir du cran pour gérer la gestion de la mémoire à la main alors que dans 99% des cas tout se fera très bien avec l'opérateur par défaut ^^

[lun4t1k]

A part si l'on surcharge les opérateurs new pour détecter les fuites mémoires...
La ca fait partie des 1%!

[millie]

Ca peut servir si le code est susceptible d'effectuer énormement d'allocation de classe très petite.

Du genre, tu veux pouvoir stocker un tableau de 20000 d'objets polymorphiques.

Tu vas pouvoir te retrouver à faire un truc du genre :

Code :

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

1
2
3
4
5
6
7
8
9
 
 
vect.resize(50000);
 
for(unsigned int i = 0; i<vect.size(); i++)
  Machin * m = machin.clone();
  m->setValue(i);
  vect[i] = m;
}

Et bien, la vitesse risque d'en prendre un coup. Tu peux redéfinir l'opérateur new pour faire un malloc ou un HeapMalloc tous les 500 blocs par exemples.


Il y a un autre cas intéressant, c'est si tu te retrouves à devoir instancier une classe plein de fois de suite.

Par exemple, (ça va paraitre artificiel) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
for(int j = 0; j< matrice.getHeigh(); j++)
 for(int i = 0; i< matrice.getWidth(); i++) {
   compute(matriceout, i,j);
 };
 
.....
void compute(Matrice & matriceout, int i, int j)
{
 Buffer de grosse taille pour faire le calcul qui utilise new
 
 ... calcul
}

Pour une matrice par exemple de taille 1000*1000, tu vas te retrouver à faire tout un tas de new, ce qui peut porter préjudice à la vitesse d'exécution du programme. Si le buffer utilise quelque chose qui permet d'être optimisé au niveau de l'appel à new, alors il est possible de gagner en vitesse.

Maintenant, ça dépend également des implémentations normales de new. Je sais comment est implémenté malloc (du moins des implémentations simples), mais pas new, donc, je ne peux pas en dire plus.

[méphistopheles]

Mais encore (quelle est ta source) ? Parce que là tel que tu le dis c'est très faux. La redéfinition de l'opérateur new, c'est seulement si on a des trucs louches à faire avec les allocations, ce n'est en rien une nécessité.

ha ben ça me rassur alors (j'avais pas envie de le faire). remarque: je redéfinissait déjà l'opérateur "=" à chaque fois alors que c'est utile que s'il y as des allocations dynamiques à faire.

L'adresse renvoyée par la fonction d'allocation que tu auras utilisée dans ton opérateur new (malloc, HeapAlloc, ...) -- et non, ce n'est pas toi qui alloue la mémoire à la main

Non, je me demandais juste, s'il fallait faire pleins de new dans la redéfinition du new, quelle adresse mémoire renvoyer (puisque new renvoie un pointeur).


millie-> hu ? heu... pas compris désolé, je crois que j'ai pas le niveau

merci à tous

[smashy]

en fait, tu peux meme passer des parametre supplementaires a ton new ....

ex (syntaxe a verifier)

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
27
28
29
class machin {
 
public:
 
  void * operator new (size_t t){
 
    return malloc(t);
  }
 
  void * operator new (size_t t,void * buffer){
 
    return buffer;
  }
 
  void * operator new [] (size_t t){
 
    ...
  }
 
  void operator delete (void * p){
 
    free(p);
  }
 
  void operator delete [] (void * p){
 
    free(p);
  }
};

apres, tu peux faire:


A * a = new A();

delete(a);


A * a = new A[10];

delete [] (a);


char buffer[sizeof(A)];

A * a = new (buffer) (A); /* ce que l on appel allocation 'inplace' ... */

a.~A(); /* tu fournis toi meme le buffer ... */
/* ca lance alors les constructeurs necessaires. */
/* il faut finir alors par une destruction explicite */
/* de l objet. */
/* ca permet d eviter une couteuse allocation */
/* memoire. */


note :

-si tu redefinis l'allocateur inplace, il te faut definir l'allocateur normal et de tableau sous peine de ne plus y avoir acces

--> c'est la meme chose que quand tu definis un constructeur avec parametres... tu perds le constructeurs par defaut que le compilateur t avais gracieusement offert

[Laurent Gomila]

Non, je me demandais juste, s'il fallait faire pleins de new dans la redéfinition du new, quelle adresse mémoire renvoyer (puisque new renvoie un pointeur).

Pourquoi plein ? Une seule suffit.

ex (syntaxe a verifier)

Les surcharges de new et delete à l'intérieur d'une classe doivent être des fonctions membres statiques.

[smashy]

Les surcharges de new et delete à l'intérieur d'une classe doivent être des fonctions membres statiques.

il me semblait que non justement (et presque bizarement) .... car sinon l allocation devrait ce faire comme suit :

Code :

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

1
2
3
4
 
class A {};
 
A * a = A::new A();

[méphistopheles]

Pourquoi plein ? Une seule suffit.

si je dois créer plusieurs variables qui appartiennent à ma classe: je dois faire plusieurs new non ?