Constructeur de copie et opperateur d'affectation en c++

L’auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

bonjour,j’aurai besoin d’un peu d’aide svp . j’ai une classe d’ensemble dans la quel j’ai écrit un constructeur de copie et un opérateur d’affectation et je rencontre cette erreur(plus bas) je pense que l’erreur provient de la spécification et j’aimerai savoir si c’est le cas et ce qu’il faudrait que je modifie pour ne plus rencontrer ps : dans le main je fais qu’une affectation voici l’erreur

ld: warning: ignoring file programme, file was built for unsupported file format ( 0x7F 0x45 0x4C 0x46 0x02 0x01 0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 ) which is not the architecture being linked (x86_64): programme

bout de code de mon hpp

 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
template < typename T=std::string>

class Ensemble
    {

        private :

            struct Maillon_T {
                    T elt;
                    Maillon_T * suiv;
            };

            Maillon_T *tete; 
            int nb;// nb elements


        public :
        Ensemble();//constructeur initialise
        ~Ensemble();//destructeur tue
        Ensemble(Ensemble<T> const&);****//probleme ici!!!!!!!!!!!****
        Ensemble<T> operator=(Ensemble<T> const& );****//et la !!!!!!!!!!****
        bool estVide();
        bool contient(T);
        void ajouter(T);
        void retirer(T);

mon implementation pour l’operateur d’affectation

 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
template<typename T>
Ensemble<T> Ensemble::operator=(Ensemble<T> const& old){
    Ensemble<T> nouve;
    Maillon_T *cour;
    Maillon_T *tmp;
    Maillon_T *nouvp;
    nouvp= new Maillon_T();
    cour=old.tete;
    if(cour!=NULL){
        (*nouvp).elt=(*cour).elt;
        nouve.tete=nouvp;
        tmp=nouve.tete;
        cour=(*cour).suiv;

        while(cour!=NULL){//
            Maillon_T *nouvp;
            nouvp=new Maillon_T();
            (*nouvp).elt=(*cour).elt;
            (*tmp).suiv=nouvp;//
            cour=(*cour).suiv;
            tmp=nouvp;//(*tmp).suiv;
        }
    }
    return *this;

}

mon implémentation pour le constructeur de copie

 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
template<typename T>
Ensemble<T>::Ensemble(Ensemble<T>  const& old){
    Ensemble<T> nouve;
    Maillon_T *cour;
    Maillon_T *tmp;
    Maillon_T *nouvp;
    nouvp= new Maillon_T();
    cour=old.tete;
    if(cour!=NULL){
        (*nouvp).elt=(*cour).elt;
        nouve.tete=nouvp;
        tmp=nouve.tete;
        cour=(*cour).suiv;

        while(cour!=NULL){//
            Maillon_T *nouvp;
            nouvp=new Maillon_T();
            (*nouvp).elt=(*cour).elt;
            (*tmp).suiv=nouvp;//
            cour=(*cour).suiv;
            tmp=nouvp;//(*tmp).suiv;
        }
    }

}

merci d’avance pour vos réponses :D :D

+0 -0

Cette réponse a aidé l’auteur du sujet

Salut !

Tu n’aurais pas un fichier objet que tu aurais compilé sur une autre machine par hasard ? Essaie de rebuild entierement le projet (supprimer l’exécutable et les .o)

+0 -0
Auteur du sujet

Merciiii, oui je l’ai deja executé sur une autre machine

mais j’ai toujours une erreur du a ma spécification

./Ensa2.tpp:101:13: error: ’Ensemble’ is not a class, namespace, or enumeration Ensemble<T> Ensemble::operator=(Ensemble<T> const& old){ ./Ensa.hpp:6:7: note: 'Ensemble' declared here class Ensemble

c’est comme si le Ensemble que j’ai mit juste avant les deux points dérangeait pourtant je ne sais pas comment il faudrait les spécifier autrement.

+0 -0

Cette réponse a aidé l’auteur du sujet

Lu’!

Ne gère pas manuellement ta mémoire. Dans un langage à exception comme C++ c’est la plaie. Et le résultat, c’est qu’ici ton constructeur de copie est nécessairement buggé. Si un new échoue et jette une exception, qui libère la mémoire allouée ?

./Ensa2.tpp:101:13: error: ’Ensemble’ is not a class, namespace, or enumeration Ensemble<T> Ensemble::operator=(Ensemble<T> const& old){ ^

naomi

C’est parce que la classe est Ensemble<T> et pas Ensemble. Donc la fonction membre que tu définis est dans le scope de Ensemble<T>.

Auteur du sujet

Merciii :D:D en suivant tes conseils j’ai mis ça, et cela fonctionne ^^ c++ Ensemble<T> Ensemble<T>::operator=(Ensemble<T> const& old){...}c++

ps: je prends note pour l’allocation manuelle je vais me renseigner plus sur ce sujet et voir comment je pourrai procéder autrement.

+0 -0

Cette réponse a aidé l’auteur du sujet

Dès qu’une classe doit gérer une ressource, tu dois alors suivre la règle Rule of Three, qui devrait même être appelée Rule of Three and a half. Pour l’implémentation de l’opérateur d’affectation, tu vas devoir suivre l’idiome du copy-and-swap.

Ces deux réponses sur StackOverflow contiennent également des liens qui te donneront une foule d’informations. Il faut du temps pour digérer tout ça, mais c’est la technique que tu dois utiliser pour écrire un code qui gère tous les cas un peu spéciaux.

+1 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte