Discussion :

[Arson]

Je suis débutant (j'ai commencé en 2007) en c++. Mon problème est : J'aimerai pouvoir ecrire un truc du genre "montype = int".

voici un petit example:

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
struct entier
{ int n;
void operator=(int);
};
void operator=(int a)
{entier.n=a;
};
main()
{entier aze; aze = 3; //sinon, ça marche pas !
//alors que j'aimerai que aze soit déclaré : entier aze=3;:cry:
};

[loicounet]

je sais pas ce que vous en pensez mais je trouve ce code un peu "crado"

tu devrais peut être revoir ta conception, un truc simple serait de créer une classe MonType avec en attribut ton entier et redéfinir l'opérateur =...

[stillman]

Ce que tu cherches à faire en faisant

Code :

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

Entier aze = 3;

n'est pas une affectation mais une initialisation (grosso modo, l'affectation se fait en même temps que la déclaration). Cette écriture est donc équivalente à celle-ci :

Code :

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

Entier aze(3);

Il faut donc que tu définisses un constructeur prenant en paramètre un int, et le tour est joué.

Pour ta classe, je te conseillerais d'écrire également un constructeur de copie, afin de pouvoir écrire quelque chose comme ça :

Code :

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

1
2
Entier a = 3;
Entier b = a;

et un opérateur d'affectation prenant un Entier comme membre droit, pour pouvoir faire :

Code :

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

1
2
3
Entier a = 5;
Entier b = 3;
a = b;

[JolyLoic]

Pour ta classe, je te conseillerais d'écrire également un constructeur de copie, afin de pouvoir écrire quelque chose comme ça :
[...]
et un opérateur d'affectation prenant un Entier comme membre droit, pour pouvoir faire :

En l'occurrence, dans sa classe, les constructeur par copie et opérateur d'affectation générés par défaut font le bon travail. Pas l peine donc de les redéfinir.

[Arson]

stillman:"Il faut donc que tu définisses un constructeur prenant en paramètre un int, et le tour est joué."

Justement, c'est celà que je ne connais pas. Je sais pas le définir. la notion de surcharge d'opérateur est l'une des choses que je ne domine pas encore.
Pourais-tu me donner la définition de ce constructeur ?

[agamitsudo]

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
// défintion de la classe 
class entier
{ 
protected:
	int n;
 
public:
 
	// accesseurs de l'attribut n
	void setN(int v) {n = v;};
	int getN() { return n;};
 
	// contructeur
	entier(int v = 0){ n=v;};// par défaut 
};
 
// le main
int main()
{
	entier monEntier(4);
	return 0;
}

A+,
Agamitsudo

[stillman]

En l'occurrence, dans sa classe, les constructeur par copie et opérateur d'affectation générés par défaut font le bon travail. Pas l peine donc de les redéfinir.

Effectivement, j'avais oublié que le compilateur créait par défaut une copie "naÏve", qui convient très bien ici.

[Arson]

Je tiens à remercier tous ce qui ont participé. Grâce à vous je peux maintenant continuer mon proget. En fait, je voulai créer un type "bin" (0,1,10,11,100...).
bin a = 10101;a++;cout<<"a = "<<a; //sortie: a = 10110

Le code dont AgamitSudo a posté marche trés bien mais je ne comprend pas
très bien : D'après ce que je pense, on a surchargé opérateur "=" alors que ton code ne présente aucun signe de surcharge (du genre...operato=(int)).

J'aimerai bien aussi (si possible) savoir comment avoir le même résultat mais en utilisant operator= parce que je crois que j'en aurais besoin lorsque je désire incrémenter a (ecrire a++).

[JolyLoic]

C'est ce que stillmann a tenté de t'expliquer.

Quand tu écris

Code :

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

1
2
3
entier a;
a = 1;
entier b = 1;

Tu as écrit deux choses très différentes. Dans le premier cas, tu as construit un objet de type "entier" avec le constructeur par défaut. Puis tu as appelé l'opérateur= sur ton objet pour lui affecter une autre valeur.

Dans le second cas, tu as construit un objet de type "entier" avec un constructeur qui accepte un int en paramètre. Il n'y a pas du tout d'opératuer = dans la ligne concernant b.

Ensuite, sans que tu fasses rien, le compilateur défini automatiquement des fonctions à ta place, dont l'opérateur=. Dans ton cas, cette version fait ce qu'il faut, donc pas besoin de faire quoi que ce soit : Même sans rien faire, ta classe a déjà un opérateur =.

[Emmanuel Deloget]

Je reprends le code (pédantisme, quand tu nous tiens...)

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
// défintion de la classe 
class entier
{ 
// non, pas protected. protected ne protège rien.
private:
	int n;
 
public:
// pas de set, parce que ça ne sert à rien ici 
// (l'opérateur= s'en charge fort bien)
	// accesseurs de l'attribut n
	// void setN(int v) {n = v;};
// le get() ne modifiant pas l'objet, on le définit en méthode const
	int get() const { return n;};
 
// on survit à la tentation de définir un opérateur de cast vers int
// pour se sauvegarder des cast implicites qui peuvent poser plus
// de problème que nous donner de solution. 
 
	// contructeur
	// entier(int v = 0){ n=v;};// par défaut
// utiliser une liste d'initialiseur plutôt:
        entier(int v = 0) : n(v) { }
 
// manque l'opérateur d'assignation
        entier& operator=(int v)
        {
           n = v;
// on retourne l'objet pour pouvoir chainer les appels si besoin.
           return *this;
        }
};
 
// le main
int main()
{
        entier e1;    // ok
	entier e2(4); // ok
 
        e1 = 5;       // ok
        e2 = e1;      // ok aussi, plus par chance que par réel désir...
 
	return 0;
}