erreur non comprise cherche solution

**debC++** · 15/06/2005, 20h49

Salut à tous,

J'ai un petit un petit soucis de compréhension d'un message d'erreur lors de la compilation de mon programme

J'ai definit un tableau de classe Dynamique.Cette classe possède elle même une variable membre alloué dynamiquement mais petit soucis.

voici mon code :

fichier Dynamique. h :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class Dynamique  
{
public :
	int i;
	int * Tableau;
public:
	Dynamique();
	Dynamique(int j); // contructeur
	Dynamique(const Dynamique &source); // constructeur par copie
	virtual ~Dynamique(); // destructeur
	Dynamique &operator=(const Dynamique &Dyn1); // opérateur d'affectation
};

--------------------------------------------------------------------------------------
fichier Dynamique. 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
#include "Dynamique.h"
 
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Dynamique::Dynamique()
{
 
}
////////////////////////////////////////////////////////////////////////////////////////////////
Dynamique::Dynamique(int j)
{
	int i;
	Tableau=new int[j];
	for(i=0;i<j;i++)
		Tableau[i]=i;
	return;
}
////////////////////////////////////////////////////////////////////////////////////////////////
Dynamique::Dynamique(const Dynamique &source) // Constructeur par copie
{
	int k;
	i=source.i;
	Tableau=new int[source.i];
	for(k=0;k>i;k++)
		Tableau[k]=source.Tableau[k];
	return;
}
////////////////////////////////////////////////////////////////////////////////////////////////
Dynamique::~Dynamique() // Destructeur
{
delete [] Tableau;
return;
}
////////////////////////////////////////////////////////////////////////////////////////////////
Dynamique &Dynamique::operator=(const Dynamique &source) // opérateur d'affectation
{
	int k;
	i=source.i;
	Tableau=new int[source.i];
	for(k=0;k>i;k++)
		Tableau[k]=source.Tableau[k];
	return *this;
}

--------------------------------------------------------------------------------------
le main :

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
#include "Dynamique.h"
#include <stdio.h>
#include <string.h>
 
void main()
{
	Dynamique *pDyn,*Inter; // Inter variable intermediaire
	int i,k=5,j=0;
 
 
	pDyn=new Dynamique[k]; /* déclaration d'un tableau de classe Dynamique de dim 5 */
 
	for(i=0;i<k;i++)
	{
		Inter=new Dynamique(i);
		for(j=0;j<i;i++) printf(" Inter : %d element : %d \n",i,Inter->Tableau[j]);
		pDyn[i]=Inter;
	}
// liberation de la mémoire
delete [] Inter;
for(i=0;i<k;i++) { delete [] pDyn;};
return;
 
}

enfin voici le message d'erreur :

... \main.cpp(17) : error C2679 : binary '=' : no operator defined which takes a right-hand operand of type 'class Dynamique *' (or there is no acceptable conversion).

si je comprend bien, il n'arrive pas a voir la surchage de l'opérateur = que j'ai définit dans le classe Dynamique ...

Merci pour vos explications et critiques de ce bout de code (et pour vos suggestions).

[Balises CODE rajoutées par Loulou24, merci d'y penser à l'avenir]

**Mac LAK** · 15/06/2005, 20h56

Et indique la ligne de l'erreur dans ton code (par un commentaire) !!

Pour toi, la ligne 17 c'est très clair, mais je ne pense pas que beaucoup de personnes ici aient envie de recompter les lignes à la main...

Edite ton message, stp.

**amaury pouly** · 15/06/2005, 21h30

Code :

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

1
2
 
Dynamique &Dynamique::operator=(const Dynamique &source)

->ici cet opérateur ressemble à çà:
Dynamique->operator=Dynamique
or toi tu fais:

Code :

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

1
2
 
pDyn[i]=Inter;

avec

Code :

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

1
2
 
 Dynamique *pDyn,*Inter

donc Inter est du type
Dynamique *
donc tu fais une affectation de ce type:
Dynamique->operator=Dynamique *
or cet opérateur n'est pas défini donc faut déférencer Inter pour l'affecter:

Code :

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

1
2
 
pDyn[i]=*Inter;

Ce que je ne comprend pas c'est que Inter, tu l'alloue où ???????
tu fais

Code :

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

1
2
 
delete []Inter;

mais je vois pas le new !!!!????[/code]

**debC++** · 16/06/2005, 08h54

voici le code avec un peu plus de lisibilté

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
 
 
Fichier Dynamique.h
 
class Dynamique 
{ 
public : 
int i; 
int * Tableau; 
public: 
Dynamique(); 
Dynamique(int j); // contructeur 
Dynamique(const Dynamique &source); // constructeur par copie 
virtual ~Dynamique(); // destructeur 
Dynamique &operator=(const Dynamique &Dyn1); // opérateur d'affectation 
}; 
-------------------------------------------------------------------------------------- 
fichier Dynamique. cpp : 
 
#include "Dynamique.h" 
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
Dynamique::Dynamique() 
{ 
 
} 
//////////////////////////////////////////////////////////////////////////////////////////////// 
Dynamique::Dynamique(int j) 
{ 
int i; 
Tableau=new int[j]; 
for(i=0;i<j;i++) 
Tableau[i]=i; 
return; 
} 
//////////////////////////////////////////////////////////////////////////////////////////////// 
Dynamique::Dynamique(const Dynamique &source) // Constructeur par copie 
{ 
int k; 
i=source.i; 
Tableau=new int[source.i]; 
for(k=0;k>i;k++) 
Tableau[k]=source.Tableau[k]; 
return; 
} 
//////////////////////////////////////////////////////////////////////////////////////////////// 
Dynamique::~Dynamique() // Destructeur 
{ 
delete [] Tableau; 
return; 
} 
//////////////////////////////////////////////////////////////////////////////////////////////// 
Dynamique &Dynamique::operator=(const Dynamique &source) // opérateur d'affectation 
{ 
int k; 
i=source.i; 
Tableau=new int[source.i]; 
for(k=0;k>i;k++) 
Tableau[k]=source.Tableau[k]; 
return *this; 
} 
-------------------------------------------------------------------------------------- 
le main : 
 
#include "Dynamique.h" 
#include <stdio.h> 
#include <string.h> 
 
void main() 
{ 
Dynamique *pDyn,*Inter; // Inter variable intermediaire 
int i,k=5,j=0; 
 
 
pDyn=new Dynamique[k]; /* déclaration d'un tableau de classe Dynamique de dim 5 */ 
 
for(i=0;i<k;i++) 
{ 
Inter=new Dynamique(i); 
for(j=0;j<i;i++) printf(" Inter : %d element : %d \n",i,Inter->Tableau[j]); 
pDyn[i]=Inter; 
} 
// liberation de la mémoire 
delete [] Inter; 
for(i=0;i<k;i++) { delete [] pDyn;}; 
return; 
 
}

la ligne 17 qui génère l'erreur \main.cpp(17) : error C2679 : binary '=' : no operator defined which takes a right-hand operand of type 'class Dynamique *' (or there is no acceptable conversion). est pDyn[i]=Inter;

en fait j'alloue Inter lign5 Inter=new Dynamique(i); dans la boucle for du main.

le but de la manoeuvre est de créer un tableau dynamique d'instance de classe Dynamique. Cette classe ayant comme donnée membre un tableau d'entier alloué dynamiquement.
Je me mélange les pinceaux entre la déclaration du tableau d'instance de classe Dynamique :

Dynamique *pDyn

son allocation dynamique de la mémoire
pDyn=new Dynamique[k];

et l'allocation du tableau d'entier dans chaque membre de pDyn.

En fait, je ne sais pas comment spécifier la taille du tableau d'entier de chaque instance de pDyn. Ca doit être dans le constructeur mais je ne vois pas ou et comment (c'est pour cela que je passe par une variable intermédiaire Inter).

j'espère avoir été plus clair (c'est pas gagné)

merci.

**amaury pouly** · 16/06/2005, 10h20

il y a des trucs qui vont pas dans ton code:
tu alloue pDyn ainsi:

Code :

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

1
2
 
pDyn=new Dynamique[k];

mais tu le libère ainsi:

Code :

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

1
2
3
 
for(int i=0;i<k;i++)
    delete []pDyn;

or çà ne sert à rien de faire un for, il faut faire:

Code :

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

1
2
 
delete []pDyn

et puis c'est tout et la ligne 17 doit devenir:

Code :

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

1
2
 
pDyn[i]=*Inter:// note que l'ont déférence Inter .

**debC++** · 16/06/2005, 14h38

Merci pour tes réponses. Effectivement si je comprend bien :

Concernant

Code :

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

1
2
3
delete []pDyn //au lieu de 
for(int i=0;i<k;i++) 
    delete []pDyn;

il n'y a pas besoin de boucle for pour libérer pDyn car c'est un pointeur sur une instance Dynamique et non un tableau de pointeur.

Pour

Code :

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

pDyn[i]=*Inter;

*Inter est un pointeur sur un objet de classe Dynamique.
En faisant

Code :

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

Inter=new Dynamique(i);

Inter contient une adresse mémoire pouvant "acceuillir" un objet Dynamique.
avec for(j=0;j<i;i++) printf(" Inter : %d element : %d \n",i,Inter->Tableau[j]);, on affecte des valeurs au tableau membre de Inter.

avec

Code :

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

pDyn[i]=*Inter;

on appelle la fonction de surcharge de l'opérateur d'affectation

Code :

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

Dynamique &Dynamique::operator=(const Dynamique &source)

Cette fonction renvoie l'adresse d'un objet Dynamique &Dynamique
et prend comme argument une adresse const Dynamique &source

ce que je ne pige pas c'est qu'en faisant

Code :

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

pDyn[i]=*Inter;

*Inter est une valeur et pas une adresse (valeur que contient l'adresse du pointeur), alors que l'opérateur = attend une adresse comme argument.

J'ai donc pas encore tout compris au C++ , merci pour vos réponses.

**amaury pouly** · 16/06/2005, 17h32

Code :

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

1
2
 
Dynamique &Dynamique::operator=(const Dynamique &source)

tu n'as pas compris ceci en fait:
ici on passe un object de type dynamique constant par référence: çà veut dire qu'on le passe en tant qu'object(en pas par valeur) mais que le compilo lui traduit par une adresse .
donc en fait il faut déférencer Inter pour obtenir l'object(et pas sont adresse) .
Si tu voulais faire la même chose avec l'adresse il faudrait écrire:

Code :

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

1
2
 
Dynamique &Dynamique::operator=(const Dynamique *source)

**debC++** · 17/06/2005, 07h52

Oui, je commence a comprendre, par contre je ne comprends pas bien la signification de déférencer Inter pour obtenir l'object ?

Sinon ca compile (VC++) par contre ca renvoie 2 erreurs à priori si je comprend bien c'est l'édition des liens qui marche pas.

compiling...
main.cpp
Linking...
LIBCD.lib(wincrt0.obj) : error LNK2001: unresolved external symbol _WinMain@16
Debug/test2.exe : fatal error LNK1120: 1 unresolved externals
Error executing link.exe.

test2.exe - 2 error(s), 0 warning(s)

Meric pour tes réponses

**hamster** · 17/06/2005, 10h06

ça ressemble à une erreur de projet win32

as tu par hasard voulu créer un projet win32 avec une fonction main comme point d'entrée ?

**amaury pouly** · 17/06/2005, 10h16

Oui, je commence a comprendre, par contre je ne comprends pas bien la signification de déférencer Inter pour obtenir l'object ?

quand on a un pointeur:

Code :

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

1
2
 
int *a=new int;

et bien quand tu utilise a, cela représente l'ADRESSE .
donc si tu fais:

Code :

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

1
2
 
printf("%u\n",a);

tu vas obtenir comme 2454245441: c'est l'adresse .

évidemment çà n'intéresse pas bcp de monde l'adresse(encore que moi je m'en sert): ce qui sert, c'est ce que pointe cette adresse .
pour obtenir la valeur pointée par un pointeur, on déférence ce pointeur:

Code :

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

1
2
 
printf("%u\n",*a);

et là çà affichera la valeur de a .
Ceci est valable pour tout type(on doit même pourvoir redéfini l'opérateur) .
Dans ton cas on fait

Code :

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

1
2
 
*Inter;

pour obtenir la valeur de Inter(cad l'object Inter) et non pas son adresse puisque dans ta déclaration de l'opérateur = tu veux l'objet Dynamique et pas son adresse .

j'espère que j'ai été assez clair[/quote]