Je n'arrive pas à remplir un tableau

Version imprimable

bonjour à tous, quand j'essaie de remplir le tableau suivant dans le main

Code:

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
 
#include <iostream>
using namespace std;
#include <conio.h>
 
 
class tableau
{
    private:
    int *a;
    int taille;
 
    public:
    tableau();
    tableau(int);
    tableau(const tableau &);
    ~tableau();
 
    tableau operator=(const tableau &);
    tableau operator+(const tableau &);
    bool operator==(const tableau &);
    int operator[](const tableau &);
    bool operator +=(const tableau &);
    void getchaine();
    void aff();
 
 
};
 
tableau::tableau()
{
    a=NULL;
    taille=0;
}
 
 tableau::tableau(int dim)
{
    taille=dim;
    a=new int[taille+1];
 
 
 
}
 
 
 
tableau::tableau(const tableau &tab)
{
    taille=tab.taille;
    for(int i=0;i<taille;i++)
    {
        a[i]=tab.a[i];
    }
}
 
tableau::~tableau()
{
    delete[] a;
}
 
tableau tableau::operator=(const tableau &tab)
{
 
    for(int i=0;i<taille;i++)
    {
        a[i]=tab.a[i];
    }
    return *this;
}
 
void tableau::aff()
{
    for(int i=0;i<taille;i++)
    {
        cout<<*(a+i);
    }
    cout<<endl;
}
 
int main()
{
 
tableau t1(4),t2,t3(4);
for(int i=0;i<4;i++)
{
t1[i]=10;
}
 
t2=t1;
    getch();
    return 0;
}

je reçois le msg d'erreur suivant:
non-lvalue in assigment
est-ce que quelqu'un peut m'aider
merci

operator[] doit retourner son entier par référence et non par valeur.
Et aussi, prendre un size_t en paramètre, pas un tableau.

Edit: Tiens, voici comment la classe devrait être déclarée:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 class tableau { private: int *a; int taille; public: tableau(); explicit tableau(int); tableau(const tableau &); ~tableau(); tableau & operator=(const tableau &); tableau operator+(const tableau &); bool operator==(const tableau &) const; int & operator[](size_t); int operator[](size_t) const; tableau & operator +=(const tableau &); void getchaine(); void aff() const; };
Et getchaine() devrait peut-être aussi être const.

29/01/2009, 17h27
phenix1988

d'accord , merci
29/01/2009, 17h28
Médinoc

Puis-je voir la dernière version de ton code?

quand je l'ai corrigé j'ai reçu une dizaine d'erreurs

Code:

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
#include <iostream>
using namespace std;
#include <conio.h>
 
 
class tableau
{
    private:
    int *a;
    int taille;
 
    public:
    tableau();
    explicit tableau(int);
    tableau(const tableau &);
    ~tableau();
 
    tableau & operator=(const tableau &);
    tableau & operator+(const tableau &);
    bool   operator==(const tableau &) const ;
    int & operator[](const tableau &);
    tableau & operator +=(const tableau &);
    void getchaine();
    void aff();
 
 
};
 
tableau::tableau()
{
    a=NULL;
    taille=0;
}
 
 tableau::tableau(int dim)
{
    taille=dim;
    a=new int[taille+1];
 
 
 
}
 
 
 
tableau::tableau(const tableau &tab)
{
    taille=tab.taille;
    for(int i=0;i<taille;i++)
    {
        a[i]=tab.a[i];
    }
}
 
tableau::~tableau()
{
    delete[] a;
}
 
tableau tableau::operator=(const tableau &tab)
{
    if(taille!=tab.taille)
    {
        cout<<"ne peut pas egaliser deux tableaux de taille differente";
    }
        else
        {
 
    for(int i=0;i<taille;i++)
    {
        a[i]=tab.a[i];
    }
    return *this;
        }
}
 
tableau tableau::operator+(const tableau &tab)
{
    tableau somme(taille);
    if(taille!=tab.taille)
    {
        cout<<"ne peut pas quoi";
    }
    else
    {
        for(int i=0;i<taille;i++)
        {
            somme.a[i]=a[i];
        }
        //somme=a;
        somme+=tab;
    }
    return *this;
}
 
tableau tableau::operator+=(const tableau & tab)
{
    if(taille!=tab.taille)
    cout<<"ne peut pas";
    else
    {
        for(int i=0;i<taille;i++)
        {
            a[i]+=tab.a[i];
        }
    }
}
void tableau::aff()
{
    for(int i=0;i<taille;i++)
    {
        cout<<*(a+i);
    }
    cout<<endl;
}
 
int main()
{
 
tableau t1(4),t2(4),t3(4);
for(int i=0;i<4;i++)
{
t1[i]=10;
}
t2=t1;
t2.aff();
 
t3=t1+t2;
t3.aff();
    getch();
    return 0;
}

ps: j'utilise codeblocks

29/01/2009, 17h37
Médinoc

Je n'ai posté que la déclaration de classe, parce que j'avais la flemme de corriger les implémentations en conséquence: C'est à toi de le faire.

Et aussi: S'il te plait, utilise http://www.developpez.net/forums/images/editor/code.gif au lieu de http://www.developpez.net/forums/ima...itor/quote.gif pour tes balises...
29/01/2009, 17h43
phenix1988

ben si j'aurai su le faire , je ne viendrais pas poser la question ici ,et j'ai passé toute la matinée à essayer de le corriger
et merci

Citation:

ben si j'aurai su le faire , je ne viendrais pas poser la question ici ,et j'ai passé toute la matinée à essayer de le corriger

Sois pas si agressif :P.

Médinoc te disais juste qu'il fallait changer en conséquence la définition de tes fonctions. Exemple il t'a changé un prototype par ça :

Code:

tableau & operator=(const tableau &);

Et bien il faut que tu changes la définition pour qu'elle ait la même signature :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 tableau & tableau::operator=(const tableau &tab) { if(taille!=tab.taille) { cout<<"ne peut pas egaliser deux tableaux de taille differente"; } else { for(int i=0;i<taille;i++) { a[i]=tab.a[i]; } return *this; } }

Code:

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include <iostream>
#include <exception>
#include <conio.h>
using namespace std;
 
class tableau
{
private:
	int *a;
	size_t taille;
 
public:
	tableau();
	explicit tableau(int);
	tableau(const tableau &);
	~tableau();
	void Swap(tableau &);
 
	tableau & operator=(const tableau &);
	tableau operator+(const tableau &);
	bool operator==(const tableau &) const ;
	int & operator[](size_t);
	int operator[](size_t) const;
	tableau & operator +=(const tableau &);
	//void getchaine() const;
	void aff() const;
 
};
 
tableau::tableau()
 : a(NULL), taille(0)
{
}
 
tableau::tableau(int dim)
 : taille(dim)
{
	a = new int[taille];
}
 
 
 
tableau::tableau(const tableau &tab)
 : taille(tab.taille)
{
	a = new int[taille];
	for(size_t i=0 ; i<taille ; i++)
	{
		a[i] = tab.a[i];
	}
}
 
tableau::~tableau()
{
	delete[] a;
}
 
void tableau::Swap(tableau &tab)
{
	{	int* aTmp = tab.a;
		tab.a = a;
		a = aTmp; }
	{	int tailleTmp = tab.taille;
		tab.taille = taille;
		taille = tailleTmp; }
}
 
tableau &tableau::operator=(const tableau &tab)
{
	if(tab.taille != taille)
		throw exception("On ne peut pas affecter deux tableaux de tailles differentes");
	//On utilise l'idiome copy-and-swap pour faire l'affectation
	tableau copieTemp(tab);
	copieTemp.Swap(*this);
	return *this;
}
 
tableau &tableau::operator+=(const tableau & tab)
{
	if(tab.taille != taille)
		throw exception("L'addition est membre a membre, donc on ne peut pas ajouter deux tableaux de tailles differentes");
	else
	{
		for(size_t i=0 ; i<taille ; i++)
		{
			a[i] += tab.a[i];
		}
	}
	return *this;
}
 
tableau tableau::operator+(const tableau &tab)
{
	//On fait une copie et on réutilise l'opérateur +=
	tableau resultat(*this);
	resultat += tab;
	return resultat;
}
 
void tableau::aff() const
{
	for(size_t i=0 ; i<taille ; i++)
	{
		if(i!=0)
			cout << ' ';
		cout << a[i];
	}
	cout<<endl;
}
 
int & tableau::operator[](size_t i)
{
	if(i >= taille)
		throw std::out_of_range("On deborde du tableau");
	return a[i];
}
int tableau::operator[](size_t i) const
{
	if(i >= taille)
		throw std::out_of_range("On deborde du tableau");
	return a[i];
}
 
int main()
{
	tableau t1(4), t2(4), t3(4);
	for(size_t i=0 ; i<4 ; i++)
	{
		t1[i]=10;
	}
	t2=t1;
	t2.aff();
 
	t3 = t1+t2;
	t3.aff();
	getch();
	return 0;
}

29/01/2009, 18h12
JolyLoic

[Edit : Désolé si je dis des choses déjà dites, il y avait eu un multipost que je n'avais pas vu]

Comment est sensé marcher l'opérateur [] sur ton tableau ? Pourquoi prend-il en paramètre une référence vers un tableau, et non pas un int (ou un size_t) ?

A part ça : Pourquoi le taille+1 dans le constructeur ? Que se passe-t-il si tu fais t2 = t1 mais que t2 a été créé pour 2 éléments, et t1 en a 4 ?
29/01/2009, 20h54
phenix1988
ça y est j'ai trouvé
au lieu de remplir le tableau directement dans le main:
Code:

1 2 3 4 5 for(int i=0 ; i<4 ; i++) { t1[i]=10; }
il faut que je passe par une fct remplissage:
Code:

1 2 3 4 5 6 7 void tableau::remplir(int k) { for(int i=0;i<taille;i++) a[i]=k; }
invocation:
Code:

1 2 t1.remplir(3); //par exemple
merci à tous :D
29/01/2009, 20h57
phenix1988

aaaa, j'ai pas vu le code de médinoc
merci pour votre aide :yaisse2:

mais est-ce que je peux savoir pourquoi on doit ajouter un "&" avant chaque fonction, je suis encore débutant :D
29/01/2009, 21h52
Bakura

Code:

tableau & operator=(const tableau &);

Le & signifie que tu renvois une référence de ton objet (il devrait y avoir quelque chose sur les références sur la FAQ). Ça permet d'éviter que ton objet soit copié.
29/01/2009, 21h56
wakan

Bonjour,

Citation:

mais est-ce que je peux savoir pourquoi on doit ajouter un "&" avant chaque fonction, je suis encore débutant

En faite "tableau &" est le type de retour de ta fonction on dit simplement que la fonction retourne l'adresse mémoire de ta fonction.
En générale, lorsque l'on surcharge des opérateurs comme par exemple ici le = (operator=). On renvoie l'adresse de la valeur de retour et non pas la valeur de retour. Pour des raisons propres au langage.
J'espère que cela aura pu d'aider.
A bientôt