Discussion :

[swirtel]

bonjour,

quelques questions se posent lorsque je pense à la surcharge du new et delete.

je vois dans la majorité des exemples que le new et delete sont substitués par un malloc et un free.

problème, comment peut-on faire en sorte que le constructeur de la classe ou le destructeur soient bien appelés avec la surcharge des deux opérateurs ?

merci

[Médinoc]

Le langage appelle le constructeur après le retour de operator new.

[swirtel]

Je reprend l'exemple que Loulou24 a donné dans son tutorial sur la création d'un moteur 3D en C++.
http://loulou.developpez.com/tutorie...artie1/#L2.2.1

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
inline void * operator new( size_t ) {
    void * p = malloc( size );
    /// je fais des choses :d
    return p;
}
 
inline void operator delete( void * p ) {
    /// je fais des choses :d
    free( p );
}

Est-ce que le langage va directement appeler le constructeur ou le destructeur lorsque je ferai appel à ces opérateurs surchargés ?

Merci

[Jean-Marc.Bourguet]

Si tu fais:

Code :

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

X* x = new X;

oui, si tu fais

Code :

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

X* x = operator new(sizeof X);

non.

[dabeuliou]

Oui.

[swirtel]

je viens de vite faire un test avec l'exemple suivant, et il semblerait qu'effectivement mon constructeur et destructeur sont bien appelés.

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
 
#include <iostream>
#include <memory>
 
inline void * operator new( size_t t ) {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    return malloc( t );
}
 
inline void operator delete( void * p ) {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    free( p );
}
 
struct Test {
    Test() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
    ~Test() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};
 
int main()
{
    std::auto_ptr< Test > ( new Test() );
	return 0;
}

confirmation de votre part ? et est-ce qu'il y a possibilité d'utiliser autre chose que le malloc ?




merci

[Laurent Gomila]

confirmation de votre part ?

Pour la troisième fois... Oui.

et est-ce qu'il y a possibilité d'utiliser autre chose que le malloc ?

Tout ce que tu veux du moment que tu renvoies un pointeur sur un espace mémoire valide pour la taille demandée.
Tu peux utiliser les fonctions de ton OS (mais de toute façon les malloc et compagnies finissent par y passer) ; ou encore dans des cas plus particulier tu peux utiliser des pools (mémoire pré-allouée dans laquelle tu ne fais que piocher).

[swirtel]

Bon, je viens de tester et effectivement cette technique ( celle donnée par Loulou24 ) semble intéressante.

Je rappel que la technique expliquée par Loulou24 donne la possibilité de tracer les (dés)allocations à l'aide d'un gestionnaire de mémoire.

Par contre, elle ne me semble pas appropriée avec l'utilisation de pointeur intelligent et surtout lorsque l'on réalise un release du pointeur encapsulé.

[loufoque]

Je rappel que la technique expliquée par Loulou24 donne la possibilité de tracer les (dés)allocations à l'aide d'un gestionnaire de mémoire.

Pas besoin de ça pour tracer les allocations mémoire.