Discussion :

[webshaker]

Le C++ c'est chaud...

J'ai un petit programme que j'ai essayé de simplifier au maximum

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
using namespace std;
#include <string>
#include <vector>
#include <stdio.h>
 
class ebovar
{
public:
      union {
          int i;
          float f;
          bool b;
          string *s;
          void *o;
      };
 
// var is null
	ebovar() : i(0) {
		printf("++ create NULL\n");
	}
	~ebovar()
	{
		printf("-- delete ebovar %d\n", i);
	}
 
// integer function
	ebovar(int v) {
		i = v;
		printf("++ create int %d\n", i);
	}
	operator int() { return i; }
};
 
/********************************************************************
**
** Operateur +
**
********************************************************************/
 
ebovar operator+(ebovar left_op, ebovar right_op)
{
	return (ebovar)((int)left_op + (int)right_op);
}
 
int main(int _argc, char **_argv)
{
	ebovar _a = 10;
	ebovar _b = 12;
	ebovar _result = _b + _a;
}

il affiche

Code :

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

1
2
3
4
5
6
7
8
++ create int 10
++ create int 12
++ create int 22
-- delete ebovar 12
-- delete ebovar 10
-- delete ebovar 22
-- delete ebovar 12
-- delete ebovar 10

Comment puis-je avoir 3 appels au constructeur de ma classe et 5 appels au destructeur ?
Qu'est ce que j'ai manqué ?

[Ehonn]

Bonjour

C'est à cause des copies des paramètres par l'opérateur + :

ebovar operator+(ebovar left_op, ebovar right_op)

Tu n'as pas l'affichage des créations car tu n'as pas écrit le constructeur par copie de ta classe (le compilateur l'a fait pour toi).

[webshaker]

Ah ouais!!!

comme ce sont des classes j'ai remplacer par

Code :

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

ebovar operator+(ebovar &left_op, ebovar &right_op)

Ca ne pourra qu'alle plus vite !
Merci.

[Ehonn]

Pas besoin de pouvoir modifier les opérandes :

Code :

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

ebovar operator+(ebovar const & left_op, ebovar const & right_op)

Il faudra corriger l'opérateur de conversion en entier de ta classe :

Code :

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

int operator int() const { return i; }

Ca ne pourra qu'alle plus vite !

Pour les types qui font la taille des types primitifs, ça ne va pas plus vite.
Les deux codes (ebovar operator+(ebovar const & left_op, ebovar const & right_op) et ebovar operator+(ebovar const left_op, ebovar const right_op)) sont acceptables ici.

[webshaker]

Merci.

Tu peux vaguement m'expliquer à quoi sert le const ?
Si je le met, il ne m'est plus possible d'utiliser d'appeler les méthode de l'object dans la fonction qui surcharge le +

Ca me dit

Code :

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

error: passing 'const ebovar' as 'this' argument of 'float ebovar::getFloat()' discards qualifiers

Ca change quoi de ne pas le mettre ?

[Bousk]

Les deux codes (ebovar operator+(ebovar const & left_op, ebovar const & right_op) et ebovar operator+(ebovar const left_op, ebovar const right_op)) sont acceptables ici.

Sauf que faire un passage par copie constante n'a aucun intérêt. Donc ebovar operator+(ebovar const left_op, ebovar const right_op) est à oublier.
Et je vois pas pour quelle raison tu crois ça acceptable ?

[ternel]

Les fonctions d'une classes (aussi appelées méthodes) sont liées à une variable automatique, this, qui est un pointeur vers l'objet sur lequel la fonction est appelée.
Ainsi, si f est un ebovar, f.getFloat()provoque l'appel de la fonction ebovar::getFloat() avec this=&f.

Or, il n'est pas possible de prendre un pointeur modifiant sur une valeur constante.
Il faut donc un moyen de définir this non pas comme un ebovar* mais comme un ebovar const*.
L'astuce, c'est de placer un const sur la fonction elle-même.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class ebovar {
//je passe les détails...
public:
    //déclaration
    float getFloat() const;

    //déclaration en place
    float getFloat() const {/* ... */}
};

//définition en dehors d'une fonction membre.
float ebovar::getFloat() const {/* ... */}

[Ehonn]

Sauf que faire un passage par copie constante n'a aucun intérêt. Donc ebovar operator+(ebovar const left_op, ebovar const right_op) est à oublier.
Et je vois pas pour quelle raison tu crois ça acceptable ?

Le passage par copie constante a un intérêt sémantique (mais pas plus).

Remplace ton :

operator float() { return f; }

par :

Code :

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

float operator float() const { return f; }

Les const te permettent d'interdire les modifications et donc peuvent permettent d'éviter des erreurs d'étourderies.