Erreur de redefinition

**Treuze** · 30/04/2006, 14h25

Bonjour ,

J ai de nombreuses erreurs de redefinition et je ne sais pas d ou ca peut venir

Le programme est un peu gros pour etre poste entierement , je le mets donc sous pieces jointes. il est compile sous g++ avec un make file que je joins aussi

Merci !

PS : les fichiers cc ont ete renommes en c pour pouvoir etre joint

**Pragmateek** · 30/04/2006, 14h26

On pourrait voir les erreurs de compilation?

**Matthieu Brucher** · 30/04/2006, 15h10

C'est quoi ça :

Code :

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

1
2
3
 // Classe T
class T {
};

??? dans liste.h ?

**Treuze** · 30/04/2006, 19h31

C'est quoi ça :
Code :

// Classe T
class T {
};

??? dans liste.h ?

Euh ...un residu de code erroné...

On pourrait voir les erreurs de compilation?

Bien sur :

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
58
59
60
61
62
63
64
65
66
67
68
69
make: AVERTISSEMENT: fichier « Makefile » a une date de modification 2,4e+06 dans le futur
g++ -I/usr/openwin/include -c -Wno-deprecated -Wall -g personnes.cc
liste.cc: In member function ‘liste<T>& liste<T>::operator-(int)’:
liste.cc:274: attention : statement n'a pas d'effet
liste.cc: In member function ‘liste<T>& liste<T>::operator-(int) [with T = personne*]’:
personnes.cc:160:   instantiated from here
liste.cc:274: attention : statement n'a pas d'effet
g++ -I/usr/openwin/include -c -Wno-deprecated -Wall -g liste.cc
liste.cc: In member function ‘liste<T>& liste<T>::operator-(int)’:
liste.cc:274: attention : statement n'a pas d'effet
g++ -I/usr/openwin/include -c -Wno-deprecated -Wall -g main.cc
liste.cc: In member function ‘liste<T>& liste<T>::operator-(int)’:
liste.cc:274: attention : statement n'a pas d'effet
liste.cc: At global scope:
liste.cc:7: erreur: redefinition of ‘maillon<T>::maillon()’
liste.cc:7: erreur: ‘maillon<T>::maillon()’ previously declared here
liste.cc:14: erreur: redefinition of ‘maillon<T>::maillon(const maillon<T>&)’
liste.cc:14: erreur: ‘maillon<T>::maillon(const maillon<T>&)’ previously declared here
liste.cc:21: erreur: redefinition of ‘maillon<T>::maillon(T)’
liste.cc:21: erreur: ‘maillon<T>::maillon(T)’ previously declared here
liste.cc:28: erreur: redefinition of ‘maillon<T>::~maillon()’
liste.cc:28: erreur: ‘maillon<T>::~maillon()’ previously declared here
liste.cc:33: erreur: redefinition of ‘maillon<T>& maillon<T>::operator=(const maillon<T>&)’
liste.cc:33: erreur: ‘maillon<T>& maillon<T>::operator=(const maillon<T>&)’ previously declared here
liste.cc:44: erreur: redefinition of ‘maillon<T>& maillon<T>::operator=(T)’
liste.cc:44: erreur: ‘maillon<T>& maillon<T>::operator=(T)’ previously declared here
liste.cc:51: erreur: redefinition of ‘maillon<T>* maillon<T>::gonext() const’
liste.cc:51: erreur: ‘maillon<T>* maillon<T>::gonext() const’ previously declared here
liste.cc:59: erreur: redefinition of ‘maillon<T>& maillon<T>::modifvaleur(T)’
liste.cc:59: erreur: ‘maillon<T>& maillon<T>::modifvaleur(T)’ previously declared here
liste.cc:67: erreur: redefinition of ‘maillon<T>& maillon<T>::modifpointeur(maillon<T>&)’
liste.cc:67: erreur: ‘maillon<T>& maillon<T>::modifpointeur(maillon<T>&)’ previously declared here
liste.cc:75: erreur: redefinition of ‘maillon<T>& maillon<T>::pointeurnull()’
liste.cc:75: erreur: ‘maillon<T>& maillon<T>::pointeurnull()’ previously declared here
liste.cc:82: erreur: redefinition of ‘T maillon<T>::valeur() const’
liste.cc:82: erreur: ‘T maillon<T>::valeur() const’ previously declared here
liste.cc:88: erreur: redefinition of ‘void maillon<T>::affichemaillon()’
liste.cc:88: erreur: ‘void maillon<T>::affichemaillon()’ previously declared here
liste.cc:94: erreur: redefinition of ‘liste<T>::liste()’
liste.cc:94: erreur: ‘liste<T>::liste()’ previously declared here
liste.cc:102: erreur: redefinition of ‘liste<T>::liste(const liste<T>&)’
liste.cc:102: erreur: ‘liste<T>::liste(const liste<T>&)’ previously declared here
liste.cc:122: erreur: redefinition of ‘liste<T>::~liste()’
liste.cc:122: erreur: ‘liste<T>::~liste()’ previously declared here
liste.cc:131: erreur: redefinition of ‘liste<T>& liste<T>::operator=(const liste<T>&)’
liste.cc:131: erreur: ‘liste<T>& liste<T>::operator=(const liste<T>&)’ previously declared here
liste.cc:155: erreur: redefinition of ‘liste<T>& liste<T>::operator+(T)’
liste.cc:155: erreur: ‘liste<T>& liste<T>::operator+(T)’ previously declared here
liste.cc:177: erreur: redefinition of ‘liste<T>& liste<T>::operator+(const maillon<T>&)’
liste.cc:177: erreur: ‘liste<T>& liste<T>::operator+(const maillon<T>&)’ previously declared here
liste.cc:185: erreur: redefinition of ‘liste<T>& liste<T>::operator+(const liste<T>&)’
liste.cc:185: erreur: ‘liste<T>& liste<T>::operator+(const liste<T>&)’ previously declared here
liste.cc:193: erreur: redefinition of ‘liste<T>& liste<T>::operator-(T)’
liste.cc:193: erreur: ‘liste<T>& liste<T>::operator-(T)’ previously declared here
liste.cc:238: erreur: redefinition of ‘int liste<T>::longueur()’
liste.cc:238: erreur: ‘int liste<T>::longueur()’ previously declared here
liste.cc:254: erreur: redefinition of ‘liste<T>& liste<T>::operator-(int)’
liste.cc:254: erreur: ‘liste<T>& liste<T>::operator-(int)’ previously declared here
liste.cc: In member function ‘liste<T>& liste<T>::operator-(int)’:
liste.cc:274: attention : statement n'a pas d'effet
liste.cc: At global scope:
liste.cc:301: erreur: redefinition of ‘void liste<T>::supprime_tete()’
liste.cc:301: erreur: ‘void liste<T>::supprime_tete()’ previously declared here
liste.cc:323: erreur: redefinition of ‘void liste<T>::affiche() const’
liste.cc:323: erreur: ‘void liste<T>::affiche() const’ previously declared here
main.cc:11: attention : ISO C++ forbids declaration of ‘main’ with no type
liste.cc: In member function ‘liste<T>& liste<T>::operator-(int) [with T = personne*]’:
personnes.cc:160:   instantiated from here
liste.cc:274: attention : statement n'a pas d'effet

Je vous joins le makefile utilise (au cas ou ca puisses venir de la

) :

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
# differents types de fichiers 
.SUFFIXES:.o.cc.ln
 
 
#---------------------------------
# INITIALISATION DES VARIABLES 
#---------------------------------
 
# Indiquer le compilateur
CCC = g++
 
# Les chemins ou se trouvent les fichiers a inclure
INCLUDES= -I/usr/openwin/include
 
# Options de compilation.
CCFLAGS=  ${INCLUDES} -c -Wno-deprecated -Wall -g
 
# Options pour le linker.
LFLAGS=  -o 
 
# Les librairies avec lesquelle on va effectueller l'edition de liens
LIBS= -L/usr/lib -L /usr/X11R6/lib -lm -L.
 
# Les fichiers sources de l'application
FILES= personnes.cc liste.cc main.cc
 
#-----------
# LES CIBLES
#-----------
 
tp:  $(FILES:.cc=.o)
    $(CCC) -o tp $(FILES:.cc=.o) ${LIBS}
 
clean:
    /bin/rm $(FILES:.cc=.o) tp
 
#-----------------------------------------------------------------------------
# LES REGLES DE DEPENDANCE. Certaines sont implicites mais je recommande d'en 
# mettre une par fichier source. 
#-----------------------------------------------------------------------------
 
personnes.o: personnes.cc personnes.h
liste.o : liste.cc liste.h
#---------------------------------
# REGLES DE COMPILATION IMPLICITES
#---------------------------------
 
.cc.o:; ${CCC} ${CCFLAGS} $*.cc

**Laurent Gomila** · 30/04/2006, 19h39

Ta façon de gérer les fichiers pour les templates est mauvaise.
http://c.developpez.com/faq/cpp/?pag...VERS_templates

Par rapport à l'exemple de la FAQ, le mieux est encore de mettre les définitions des fonctions templates dans un fichier non compilable par défaut (.inl, .tpl, .tpp, ...). Ca évitera d'être tenté de les compiler.

**Treuze** · 30/04/2006, 19h44

Vive les cours scolaires

...

Je vais faire ca , je vous tiens au courant ...

merci !

**Matthieu Brucher** · 30/04/2006, 23h06

Dans un de tes fichiers .c, tu inclus un autres et tu inclues le tout dans main.c, faut pas s'étonner des dernières erreurs.

**Treuze** · 01/05/2006, 13h53

J ai mis liste.cc ds liste.h et changé les inclusions comme ceci :

liste.h :

Code :

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

1
2
3
4
5
6
7
 
#include <stdio.h>
#include  <stlib.h> 
#include <iostream>
#include <math.h>
 
using namespace std;

personnes.h

Code :

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

1
2
3
 
include <string.h>
include "liste.h"

personnes.cc

Code :

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

1
2
 
include  "personnes.h"

main.cc

Code :

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

1
2
3
 
 
include "personnes.cc"

est ce que c est correct ?

maintenant le compilo m indique :

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
g++ personnes.h personnes.cc liste.h main.cc
/tmp/ccJV0LuD.o: dans la fonction « personne::get_nom() const»:
main.cc:(.text+0x0): définitions multiples de « personne::get_nom() const»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x0): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « personne::get_prenom() const»:
main.cc:(.text+0x24): définitions multiples de « personne::get_prenom() const»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x24): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « personne::get_etablis() const»:
main.cc:(.text+0x48): définitions multiples de « personne::get_etablis() const»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x48): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « personne::change_nom(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»:
main.cc:(.text+0x6c): définitions multiples de « personne::change_nom(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x6c): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « personne::change_prenom(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»:
main.cc:(.text+0x8c): définitions multiples de « personne::change_prenom(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x8c): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « personne::change_etablis(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»:
main.cc:(.text+0xac): définitions multiples de « personne::change_etablis(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0xac): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « personne::affiche() const»:
main.cc:(.text+0xcc): définitions multiples de « personne::affiche() const»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0xcc): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « etudiant::affiche() const»:
main.cc:(.text+0x1ca): définitions multiples de « etudiant::affiche() const»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x1ca): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « enseignant::get_qualite() const »:
main.cc:(.text+0x25a): définitions multiples de « enseignant::get_qualite() const »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x25a): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « enseignant::affiche() const»:
main.cc:(.text+0x2da): définitions multiples de « enseignant::affiche() const»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x2da): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « administration::affiche() const»:
main.cc:(.text+0x3fc): définitions multiples de « administration::affiche() const»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x3fc): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « etudiant::get_branche() const»:
main.cc:(.text+0x124): définitions multiples de « etudiant::get_branche() const»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x124): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « etudiant::get_filiere() const»:
main.cc:(.text+0x148): définitions multiples de « etudiant::get_filiere() const»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x148): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « etudiant::get_emploitemps() const»:
main.cc:(.text+0x16c): définitions multiples de « etudiant::get_emploitemps() const»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x16c): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « etudiant::change_branche(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»:
main.cc:(.text+0x178): définitions multiples de « etudiant::change_branche(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x178): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « etudiant::change_filiere(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»:
main.cc:(.text+0x198): définitions multiples de « etudiant::change_filiere(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x198): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « etudiant::change_emploitemps(int)  »:
main.cc:(.text+0x1b8): définitions multiples de « etudiant::change_emploitemps(int)  »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x1b8): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « enseignant::get_salaire() const »:
main.cc:(.text+0x27e): définitions multiples de « enseignant::get_salaire() const »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x27e): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « enseignant::get_experience() const »:
main.cc:(.text+0x28a): définitions multiples de « enseignant::get_experience() const »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x28a): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « enseignant::change_qualite(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»:
main.cc:(.text+0x296): définitions multiples de « enseignant::change_qualite(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x296): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « enseignant::change_salaire(int)   »:
main.cc:(.text+0x2b6): définitions multiples de « enseignant::change_salaire(int)   »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x2b6): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « enseignant::change_experience(int)   »:
main.cc:(.text+0x2c8): définitions multiples de « enseignant::change_experience(int)   »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x2c8): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « administration::get_emploi() const »:
main.cc:(.text+0x37c): définitions multiples de « administration::get_emploi() const »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x37c): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « administration::get_salaire() const »:
main.cc:(.text+0x3a0): définitions multiples de « administration::get_salaire() const »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x3a0): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « administration::get_experience() const »:
main.cc:(.text+0x3ac): définitions multiples de « administration::get_experience() const »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x3ac): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « administration::change_emploi(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»:
main.cc:(.text+0x3b8): définitions multiples de « administration::change_emploi(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x3b8): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « administration::change_salaire(int)   »:
main.cc:(.text+0x3d8): définitions multiples de « administration::change_salaire(int)   »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x3d8): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « administration::change_experience(int)   »:
main.cc:(.text+0x3ea): définitions multiples de « administration::change_experience(int)   »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x3ea): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « bddpersonnes::ajout(bddpersonnes)»:
main.cc:(.text+0x49e): définitions multiples de « bddpersonnes::ajout(bddpersonnes)»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x49e): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « bddpersonnes::ajout(personne*)     »:
main.cc:(.text+0x4bc): définitions multiples de « bddpersonnes::ajout(personne*)     »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x4bc): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « bddpersonnes::suppr_tete()      »:
main.cc:(.text+0x59c): définitions multiples de « bddpersonnes::suppr_tete()      »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x4da): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « bddpersonnes::suppr(int)  »:
main.cc:(.text+0x5b6): définitions multiples de « bddpersonnes::suppr(int)  »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x4f4): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « bddpersonnes::suppr(personne*)     »:
main.cc:(.text+0x5d4): définitions multiples de « bddpersonnes::suppr(personne*)     »
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x512): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « bddpersonnes::affiche() const»:
main.cc:(.text+0x5f2): définitions multiples de « bddpersonnes::affiche() const»
/tmp/ccCYhLmG.o:personnes.cc:(.text+0x530): défini pour la première fois ici
/tmp/ccJV0LuD.o: dans la fonction « main »:
main.cc:(.text+0x4ff): référence indéfinie vers « bddpersonnes::bddpersonnes()»
main.cc:(.text+0x55f): référence indéfinie vers « bddpersonnes::~bddpersonnes()»
main.cc:(.text+0x57e): référence indéfinie vers « bddpersonnes::~bddpersonnes()»

**Laurent Gomila** · 01/05/2006, 14h01

include "personnes.cc"

Ne jamais inclure un fichier compilé, puisque du coup tout ce qu'il contient se retrouvera en double dans deux fichiers, d'où les erreurs de redéfinition.

**Treuze** · 01/05/2006, 14h08

merci

!

Je n ai plus d erreurs de redefinitinos par contre j ai tjrs

Code :

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

1
2
3
4
 
main.cc:(.text+0x4ff): référence indéfinie vers « bddpersonnes::bddpersonnes()»
main.cc:(.text+0x55f): référence indéfinie vers « bddpersonnes::~bddpersonnes()»
main.cc:(.text+0x57e): référence indéfinie vers « bddpersonnes::~bddpersonnes()»

Une idee ?

**Laurent Gomila** · 01/05/2006, 15h02

Si bddpersonne est une classe template, alors il ne faut pas mettre son implémentation dans un .cc.
Cf de nouveau le lien vers la FAQ.

**Treuze** · 01/05/2006, 19h24

J ai fait ca mais ca n a absolument rien change

**vdumont** · 01/05/2006, 19h28

Tu as la déclaration et l'implémentation de la classe template dans un même fichier .h n'est-ce pas ?

**Treuze** · 01/05/2006, 19h44

Ok en fait je n avait pas defini le constructeur et le destructeur de bddpersonnes...

Je pensais que le constructeur de bddpersonnes compose d une liste<personnes*> appelait implicitement le constructeur de liste<T> ... est ce que c est faux ou est ce que c est le fait que liste soit un template ?

meme question pour le destructeur

D ailleurs je n arrive aps a faaire un destructeur correct pourr bddpersonnes ... est ce que qq un pourrait me donner une direction a suivre ?

**Treuze** · 01/05/2006, 19h51

Tu as la déclaration et l'implémentation de la classe template dans un même fichier .h n'est-ce pas ?

Oui

**vdumont** · 01/05/2006, 19h53

T'a quoi comme constructeur pour bddpersonnes?

**Treuze** · 01/05/2006, 20h07

heu j ai fait ca :

Code :

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

1
2
3
4
 
bddpersonnes () {
       liste<persones*> l;
}

C est bien ?

**Pragmateek** · 01/05/2006, 20h26

Non.
Ca déclare un objet qui sera détruit à la sortie du constructeur.

**Treuze** · 01/05/2006, 20h34

Le constructeur de liste<T> est pas sense etre appele tt simplement ?

edit : si en fait j ai change mon constructeur en bddpersonnes :: bddpersonnes(); et c bon

Par contre si je declares mo destructeur de la meme facon (cad ss l implementer en esperant qu il appelle implicitement le destructeur de champ)
il me retourne une reference indefinie sur le constructeur puis sur le destructeur...

Erreur de redefinition

C++

Discussions similaires

Partager

Partager