IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

new et delete, mais où?


Sujet :

C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Profil pro
    Inscrit en
    Août 2007
    Messages
    25
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2007
    Messages : 25
    Par défaut new et delete, mais où?
    Bonjour a tous,
    pour commencer je voudrais remercier ceux qui m'ont aidés avec mes pointeurs, j'ai réglé le problème en adoptant le même architecture qu'une liste chaînée.
    --------------------------------------------------------------------------
    Toujours dans l'implémentation de l'A*, j'ai un autre problème.
    J'ai une class Noeud. Or chaque instance de cette class est créée grâce à new.
    Or je ne sais pas où placer l'opérateur delete.

    Je vous donne le shéma du fichier source :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    class Noeud
    {
     
    };
     
    class A_star
    {
    //Dans une fonction quelconque.
     C = new Noeud();
    };
    Quand je mets delete dans le destructeur de A_star, ça plante, quand je le mets dans le destructeur de Noeud, ça plante...

  2. #2
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    Septembre 2007
    Messages
    7 477
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 477
    Par défaut
    Citation Envoyé par juloss Voir le message
    Je vous donne le shéma du fichier source :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    class Noeud
    {
     
    };
     
    class A_star
    {
    //Dans une fonction quelconque.
     C = new Noeud();
    };
    Attention : tu ne programmes pas en Java, là. Le code ne se met pas dans la déclaration de la classe A_star, sauf si tu veux qu'il soit inline.

    Ensuite, new n'est nécessaire que pour faire l'allocation d'un objet persistant. Si tu veux créer un objet au sein d'un bloc, tu le déclares, tout simplement. Il sera initialisé tout seul (comme les types natifs du Java) et disparaîtra quand tu sortiras de ton bloc.

    En plus, on ne voit même pas ton delete(), ici.

  3. #3
    Membre émérite
    Avatar de Spout
    Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Février 2007
    Messages
    904
    Détails du profil
    Informations personnelles :
    Âge : 40
    Localisation : France, Val d'Oise (Île de France)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Février 2007
    Messages : 904
    Par défaut
    Citation Envoyé par juloss Voir le message
    quand je le mets dans le destructeur de Noeud, ça plante...
    Une classe ne peut pas appeler un delete d'elle-même !
    Raisonnement par l'absurde: admettons que le delete fonctionne, où le code va aller chercher la suite à exécuter vu que l'objet qui a appelé le delete vient d'être détruit ?

    Après, je rejoins Obsidian, à savoir qu'il faut que tu vérifies l'utilité de ton pointeur par rapport à une instance pure et simple de l'objet Noeud.

    Enfin, pour te répondre, sache qu'un pointeur et l'objet pointé sont deux choses différentes. Une fois le new fait, l'espace mémoire alloué existera tant qu'il ne sera pas libéré par le fameux delete. Donc tu peux faire un new à peu près partout et idem pour le delete.
    Pense seulement à vérifier lors du delete que l'espace alloué existe toujours et que le pointeur pointe bien dessus.

    Et garde bien à l'esprit que l'utilisation de pointeurs pose souvent des problèmes lorsqu'ils sont mal gérés...

  4. #4
    Rédacteur

    Avatar de ram-0000
    Homme Profil pro
    Consultant en sécurité
    Inscrit en
    Mai 2007
    Messages
    11 517
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Consultant en sécurité
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : Mai 2007
    Messages : 11 517
    Par défaut
    Citation Envoyé par spoutspout Voir le message
    Une classe ne peut pas appeler un delete d'elle-même !
    Raisonnement par l'absurde: admettons que le delete fonctionne, où le code va aller chercher la suite à exécuter vu que l'objet qui a appelé le delete vient d'être détruit ?
    Si si, une classe peut appeler elle même son delete car seules les données de la classe sont détruite/désallouées, le code de la classe continue lui à exister.

    Par contre, et c'est là le piège, il faut être sûr qu'une fois que le delete est appelé, le code n'utilise plus les données membres de la classe, sinon c'est le crash assuré.
    Raymond
    Vous souhaitez participer à la rubrique Réseaux ? Contactez-moi

    Cafuro Cafuro est un outil SNMP dont le but est d'aider les administrateurs système et réseau à configurer leurs équipements SNMP réseau.
    e-verbe Un logiciel de conjugaison des verbes de la langue française.

    Ma page personnelle sur DVP
    .

  5. #5
    Membre averti
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    40
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 40
    Par défaut
    Si tu veux de l'aide pour A*, un tutoriel avec une implémentation en C++ se trouvent ici.

    PS:
    Citation Envoyé par coyotte507
    Citation Envoyé par spoutspout
    Une classe ne peut pas appeler un delete d'elle-même !
    Raisonnement par l'absurde: admettons que le delete fonctionne, où le code va aller chercher la suite à exécuter vu que l'objet qui a appelé le delete vient d'être détruit ?
    Si si, une classe peut appeler elle même son delete car seules les données de la classe sont détruite/désallouées, le code de la classe continue lui à exister.
    C'est vrai ! Sans la possibilité qu'un objet appelle delete sur lui-même, comment faire un singleton ?

  6. #6
    Membre émérite
    Avatar de Spout
    Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Février 2007
    Messages
    904
    Détails du profil
    Informations personnelles :
    Âge : 40
    Localisation : France, Val d'Oise (Île de France)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Février 2007
    Messages : 904
    Par défaut
    Citation Envoyé par thms92 Voir le message
    Sans la possibilité qu'un objet appelle delete sur lui-même, comment faire un singleton ?
    Citation Envoyé par Jean-Marc.Bourguet
    Des objets qui decident de se detruire en reponse a des evenements exterieurs (exemple canonique une fenetre). A noter que parfois il y a quand meme interet a retarder la destruction.
    Convaincu !
    (le pire c'est que j'en ai déjà utilisé... )

  7. #7
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Par défaut
    Dans windows/MFC, les fenêtres utilisent souvent un delete this sur DestroyWindow(). Je crois que wxWidget fait de même mais c'est à prendre avec réserve. En fait, c'est souvent utile (outre le singleton), quand un objet n'a pas vraiment de raison d'appartenir à un autre et d'être managé par lui , par conséquent il s'autodétruit quand il le juge nécessaire. Bien sûr, le plus prudent est que le delete this soit le dernier appel de la méthode.

  8. #8
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 741
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 741
    Par défaut basiques?
    Il faut d'abord se poser des questions sur le type d'association qui existe entre un objet de type "A_star" et un objet de type "Noeud".

    1. est ce que toutes les instances de A_star "contiennent" une instance spécifique de Noeud qui lui est associée?
    2. est ce que certaines instances de A_star font référence à une instance d'objet noeud qui peut être identique à plusieurs instances?

    Dans le cas 2, il me semblerait préférable de réaliser l'association via un boost::shared_ptr.

    Dans le premier cas, A_star pourra contenir la valeur d'un Noeud ou une référence.

    Si A_star contient la valeur:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    class A_star
    {
         Noeud C; // on déclare Noeud dans les données de la classe.
         A_star() // comment le constructeur initialise C?
         ~A_star() // qui y a t-il de spécifique à faire dans le dtor?
    }
    Dans ce cas, le structure incluse a la meme durée de vie que l'objet de type A_star qui le contient. Pas besoin d'allouer ou de libérer quoi que ce soit d'autre que le contenant A_star.

    Si A_star contient une référence...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    class A_star
    {
         Noeud* C; // on déclare un pointeur vers Noeud.
         A_star() // ici, on va faire l'allocation
         ~A_star() // ici, on va faire le delete.
    }
    Allocation et libération doivent se faire avec la création et la destruction de l'objet... Dans les méthode correspondantes.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  9. #9
    Expert confirmé

    Inscrit en
    Novembre 2005
    Messages
    5 145
    Détails du profil
    Informations forums :
    Inscription : Novembre 2005
    Messages : 5 145
    Par défaut
    Citation Envoyé par spoutspout Voir le message
    Une classe ne peut pas appeler un delete d'elle-même !
    Mince... j'ai quelques delete this; dans mon code, et ca me semble parfaitement conforme, et utile. Naturellement, on ne peut rien faire utilisant les membres de this apres, mais c'est la seule contrainte.

  10. #10
    Membre Expert
    Avatar de coyotte507
    Profil pro
    Inscrit en
    Octobre 2006
    Messages
    1 327
    Détails du profil
    Informations personnelles :
    Âge : 35
    Localisation : France

    Informations forums :
    Inscription : Octobre 2006
    Messages : 1 327
    Par défaut
    Citation Envoyé par spoutspout Voir le message
    Une classe ne peut pas appeler un delete d'elle-même !
    Raisonnement par l'absurde: admettons que le delete fonctionne, où le code va aller chercher la suite à exécuter vu que l'objet qui a appelé le delete vient d'être détruit ?
    Je ne vois pas le problème, le programme continue la fonction.

    En effet, en créant plusieurs instances d'une classes, on duplique les données membres, mais pas les méthodes qui ne sont qu'à un seul endroit dans le programme.

    Après, c'est sûr qu'une classe doit éviter d'utiliser/modifier un de ses membres/méthodes après s'être auto-supprimée, et c'est sûr que s'auto-supprimer dans son propre destructeur est une mauvaise idée.

    Edit: grillé

  11. #11
    Membre émérite
    Avatar de Spout
    Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Février 2007
    Messages
    904
    Détails du profil
    Informations personnelles :
    Âge : 40
    Localisation : France, Val d'Oise (Île de France)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Février 2007
    Messages : 904
    Par défaut
    Décidément, j'en apprendrais tous les jours...
    Vous pouvez me donner une application concrète de ce cas, pour que ça me parle un peu plus sur son utilité?

  12. #12
    Expert confirmé

    Inscrit en
    Novembre 2005
    Messages
    5 145
    Détails du profil
    Informations forums :
    Inscription : Novembre 2005
    Messages : 5 145
    Par défaut
    Citation Envoyé par spoutspout Voir le message
    Décidément, j'en apprendrais tous les jours...
    Vous pouvez me donner une application concrète de ce cas, pour que ça me parle un peu plus sur son utilité?
    Des objets qui decident de se detruire en reponse a des evenements exterieurs (exemple canonique une fenetre). A noter que parfois il y a quand meme interet a retarder la destruction.

  13. #13
    Expert confirmé

    Inscrit en
    Novembre 2005
    Messages
    5 145
    Détails du profil
    Informations forums :
    Inscription : Novembre 2005
    Messages : 5 145
    Par défaut
    juloss, a priori l'endroit ou detruire devrait etre A_star... mais il peut y avoir de bonnes raisons de faire autrement, et de bonne raisons de remettre en cause meme l'allocation dynamique. Tu ne donnes pas assez de renseignements pour faire autre chose que de jouer aux devinettes. On tombe parfois juste, parfois pas a ce jeu.

  14. #14
    Membre Expert
    Avatar de poukill
    Profil pro
    Inscrit en
    Février 2006
    Messages
    2 155
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France

    Informations forums :
    Inscription : Février 2006
    Messages : 2 155
    Par défaut
    Citation Envoyé par juloss Voir le message
    Toujours dans l'implémentation de l'A*, j'ai un autre problème.
    J'ai une class Noeud. Or chaque instance de cette class est créée grâce à new.
    Or je ne sais pas où placer l'opérateur delete.
    Ce que tu veux, c'est que quand tu détruits un noeud, tous les enfants soient détruits!
    Donc le delete d'un noeud doit appeler un delete sur tous ses enfants, ce qui va détruire tous les noeuds après ton noeud courant !

    Conséquence: si tu appelles le destructeur de ton noeud de base, alors tout ton arbre sera détruit !

  15. #15
    Expert éminent
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 395
    Par défaut
    Lors d'un comptage de références intrusif, il est d'usage que le Release() de l'objet fasse un delete this lorsqu'on relâche la dernière référence.

    C'est également dans ce genre de circonstances, qu'on peut tirer profit de la possibilité de deleter un pointeur const, si l'on offre la possibilité d'obtenir des pointeurs const sur l'objet:
    • Nombre de références stocké dans une variable membre mutable.
    • Fonctions membres AddRef() et Release() déclarées const.
    • delete this dans le Release() quand le compteur atteint zéro...
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  16. #16
    Membre averti
    Profil pro
    Inscrit en
    Août 2007
    Messages
    25
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2007
    Messages : 25
    Par défaut
    Je sais bien que mon code n'est pas exhaustif. Mais je peux pas vous donnez tous le code, il est trop long et inutile pour mon problème.
    Pour essayer d'être plus précis, imaginez une liste chainée d'instance d'une class A.
    Le class B possède un pointeur sur l'une des extrémités de la liste chainée.
    Ainsi B peut utiliser la liste chainée.
    Mais toutes les instances de A ont été créées avec new (à part la première).
    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
     
    class A
    {
    A * Pointeur_Sur_Parent;
    };
     
    class B
    {
    // Définition : 
     A *Pointeur_Sur_Tete;  
     A Depart;                    //relation HAS_A
     
    //Constructeur :
     B () :Depart
     {
     Pointeur_Sur_Tete=&Depart;
     }
     
    //Liste chainée
     void Fonction()
     {
     A *Courant;
     Courant = new A;
     A.Pointeur_Sur_Parent = Pointeur_Sur_Tete;
     Pointeur_Sur_Tete = Courant;
     }
     
    };
    Et mon problème est que qhand j'ai finit d'utiliser ma liste chainée je veux desallouer le mémoire dediée à ma liste. Or je n'y arrive pas, le programme plante à l'appel de delete et entre dans une boucle infine
    Donc ma question est : Comment désallouer la liste?

  17. #17
    Membre éprouvé
    Profil pro
    Inscrit en
    Août 2003
    Messages
    159
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2003
    Messages : 159
    Par défaut
    Pour dés allouer une liste chainée,
    il faut supprimer les éléments en commençant par la tête.
    exemple:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    while (NULL !=tete)
    {
    A * tmpTete = tete;
    tete = tete->next(); 
    delete tmpTete;
    }

  18. #18
    Expert confirmé

    Inscrit en
    Novembre 2005
    Messages
    5 145
    Détails du profil
    Informations forums :
    Inscription : Novembre 2005
    Messages : 5 145
    Par défaut
    Citation Envoyé par juloss Voir le message
    Je sais bien que mon code n'est pas exhaustif. Mais je peux pas vous donnez tous le code, il est trop long et inutile pour mon problème.
    Pour essayer d'être plus précis, imaginez une liste chainée d'instance d'une class A.
    Le class B possède un pointeur sur l'une des extrémités de la liste chainée.
    Ainsi B peut utiliser la liste chainée.
    Mais toutes les instances de A ont été créées avec new (à part la première).
    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
     
    class A
    {
    A * Pointeur_Sur_Parent;
    };
     
    class B
    {
    // Définition : 
     A *Pointeur_Sur_Tete;  
     A Depart;                    //relation HAS_A
     
    //Constructeur :
     B () :Depart
     {
     Pointeur_Sur_Tete=&Depart;
     }
    Et mon problème est que qhand j'ai finit d'utiliser ma liste chainée je veux desallouer le mémoire dediée à ma liste. Or je n'y arrive pas, le programme plante à l'appel de delete et entre dans une boucle infine
    Donc ma question est : Comment désallouer la liste?
    Tu essaies vraisemblablement -- sans voir le code on ne peut jouer qu'aux devinettes -- de faire un delete du membre Depart de B.

  19. #19
    Membre Expert
    Avatar de poukill
    Profil pro
    Inscrit en
    Février 2006
    Messages
    2 155
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France

    Informations forums :
    Inscription : Février 2006
    Messages : 2 155
    Par défaut
    A base de boost, j'avais fait un truc comme ça, je sais pas si ça peut t'aider...

    Node.h :
    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
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
     
    #pragma once
     
    #include <list>
    #include <iostream>
    #include <fstream>
    #include <boost/ptr_container/ptr_list.hpp>
    #include "constantes.h"
    #include <algorithm>
     
     
    class Node
    {
    public:
    	typedef float									value_type;
    	typedef boost::ptr_list <Node>					Arbre;
    	typedef boost::ptr_list <Node>::const_iterator	const_child_iterator;
    	typedef boost::ptr_list <Node>::iterator		child_iterator;
     
    	Node(value_type val, int pos, Node * parent): m_Value(val), m_Level(pos), m_Parent(parent)
    	{
    		FindChilds();
    	}
    	~Node() {}
     
    	void	FindChilds();
    	bool	HasChilds()  const;
    	void	AddNode(value_type value);
    	void	WritePath(Node *) const;
     
    	Node *	GetParent() {return m_Parent;}
    	Node *	GetParent() const {return m_Parent;}
    	Arbre	GetChilds() {return m_Childs;}
    	Arbre	GetChilds() const {return m_Childs;}
     
    	value_type	GetValue() const {return m_Value;}
    	int			GetLevel() const {return m_Level;}
     
    	static	int GetNbSolutions() {return nbSolutions; }
     
     
    private:
    	Arbre		m_Childs;
    	Node *		m_Parent;
    	int			m_Level;
    	value_type	m_Value;
     
    	static int nbSolutions;
    	static std::ofstream file;
    };
    Node.cpp:
    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
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
     
    #include "node.h"
     
    std::ofstream	Node::file("output.txt");
    int				Node::nbSolutions = 0;
     
    void Node::AddNode(value_type value)
    {
    	m_Childs.push_back( new Node(value, m_Level + 1, this) );
    }
     
    bool Node::HasChilds() const
    {
    	return m_Childs.empty();
    }
     
    void Node::WritePath(Node * node) const
    {
    	++nbSolutions;
    	std::vector<value_type> vect;
    	vect.push_back (node->GetValue() );
     
    	Node * node_parent = node ;
    	while (node_parent->GetLevel() != 0)
    	{
    		node_parent = node_parent->GetParent();
    		vect.push_back(node_parent->GetValue() );
    	}
     
    	std::reverse(vect.begin(), vect.end() );
    	std::copy(vect.begin(), vect.end(), std::ostream_iterator<value_type>(file, "\t") );
    	file << "\n";
    }
     
     
     
     
    void Node::FindChilds()
    {
    	if (m_Level + 1 < m_Rows)
    	{
    		std::vector<value_type> & vect = m_Matrix[m_Level + 1];
    		std::vector<value_type>::const_iterator iter = std::find_if(vect.begin(), vect.end(), std::bind2nd(std::greater_equal<float>(), m_Value) );
     
    		if (iter != vect.end() )
    		{
    			for (; iter != vect.end(); ++iter) {
    				AddNode(*iter);
    			}
    		}
    	}
    	else
    	{
    		WritePath(this);
    	}
     
    }
    Bonne continuation,

    Poukill

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 18
    Dernier message: 07/10/2010, 02h18
  2. Redéfinition opérateurs new et delete globaux
    Par bolhrak dans le forum C++
    Réponses: 8
    Dernier message: 30/07/2007, 11h34
  3. surdefinition operateur new et delete
    Par johjoh dans le forum C++
    Réponses: 23
    Dernier message: 08/12/2006, 10h10
  4. intrigue sur la surcharge du new et delete
    Par swirtel dans le forum C++
    Réponses: 12
    Dernier message: 07/09/2006, 15h23
  5. Segmentation fault sur new[] et delete[]
    Par Don ViP dans le forum C++
    Réponses: 4
    Dernier message: 30/04/2006, 00h29

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo