Discussion :

[yan]

Bonjour,
est il propre de re-utiliser le constructeur pour modifier une class non mutable lors d'un operation. Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
struct Point
{
    Point(float x,float y)
        :x(x),y(y)
    {}
    Point & operator+=(const Point &p)
    {
        this->Point::Point(x+p.x,y+p.y);
        return *this;
    }
    const float x;
    const float y;
};

L'operateur += utilise le constructeur pour modifier x et y.

[Obsidian]

Bonjour,
est il propre de re-utiliser le constructeur pour modifier une class non mutable lors d'un operation. Par exemple :

Non, c'est dégueu ! :-)

Déjà, il me semble que l'opérateur de portée est superflu puisque « this » appartient à ta classe. Ensuite, je crois me souvenir qu'appeler directement un constructeur crée une nouvelle instance, donc ça ne servira à rien dans le cas qui t'intéresse.

Par contre, tu peux effectivement créer un nouvel objet et l'affecter à l'objet courant, repéré par this.

Code :

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

*this=Point(x+p.x,y+p.y);

M'enfin, bon. Si tes membres sont const, ce n'est pas pour rien. Si, en revanche, ils ne sont constants que pour être read-only vis-à-vis de l'utilisateur et que tu ne veux pas passer par une méthode pour y accéder (ce que je comprends), moi j'initialise des références constantes publiques sur des objets volatiles privés.

[yan]

Non, c'est dégueu ! :-)

En quoi c'est degueu?(j'arrive pas à comprendre pourquoi)

Déjà, il me semble que l'opérateur de portée est superflu puisque « this » appartient à ta classe. Ensuite, je crois me souvenir qu'appeler directement un constructeur crée une nouvelle instance, donc ça ne servira à rien dans le cas qui t'intéresse.

C'est pour cela qu'il faut le this. En tout cas sous visual ça marche.

Code :

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

1
2
3
4
5
6
7
8
9
Par contre, tu peux effectivement créer un nouvel objet et l'affecter à l'objet courant, repéré par this.


	

	
Code  :
	
Sélectionner tout -
	Visualiser dans une fenêtre à part
	
*this=Point(x+p.x,y+p.y);

comme x et y sont const, comment fait tu l'operateur =?

M'enfin, bon. Si tes membres sont const, ce n'est pas pour rien. Si, en revanche, ils ne sont constants que pour être read-only vis-à-vis de l'utilisateur et que tu ne veux pas passer par une méthode pour y accéder (ce que je comprends), moi j'initialise des références constantes publiques sur des objets volatiles privés.

En fin c'est un peu un fork de ce thread http://www.developpez.net/forums/d58...-constructeur/

[yan]

Bon ca y est j'ai trouvé pourquoi c'est dégeu :

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
 
struct Point
{
    Point(float x,float y)
        :x(x),y(y),vect(10000000)
    {}
    Point & operator+=(const Point &p)
    {
        this->Point::Point(x+p.x,y+p.y);
        return *this;
    }
    const float x;
    const float y;
    const std::vector<float> vect;
};

dû au vector, à chaque apel de this->Point:: Point(x+p.x,y+p.y); ca va initialiser un vect(10000000) mais il n'y as pas eu destruction de la memoire précédente. Superbe fuite memoire

dsl pour le derangement

[Obsidian]

En quoi c'est degueu?(j'arrive pas à comprendre pourquoi)

C'est pour cela qu'il faut le this. En tout cas sous visual ça marche.

Ben, déjà, ça ne compile pas sous GCC.
En fait, tu ne peux pas réappeler directement le constructeur puisqu'il n'est par définition valable qu'à la construction d'un objet. Dans cette optique, il faudrait détruire puis recréer x et y pour pouvoir les réinitialiser.

Code :

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

*this=Point(x+p.x,y+p.y);

[/CODE]
comme x et y sont const, comment fait tu l'operateur =?

Je viens de vérifier et c'est une erreur de ma part ! Désolé. Il me semblait que l'objet lui-même étant volatile, rien n'empêchait de le réécraser entièrement à partir d'une source construite de la même façon, comporterait-elle des membres constants, mais gcc n'est pas d'accord.

Par contre, comme je disais au-dessus, tu peux très bien faire ce genre de choses :

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
 
class Point
{
    public:
               Point (float,float);
 
       const float & x;
       const float & y;
 
    private:
       float priv_x;
       float priv_y;
};
 
Point::Point (float px,float py) :
   x(priv_x), y(priv_y), priv_x(px), priv_y(py)
{
}

dû au vector, à chaque apel de this->Point:: Point(x+p.x,y+p.y); ca va initialiser un vect(10000000) mais il n'y as pas eu destruction de la memoire précédente. Superbe fuite memoire

C'est l'idée mais ce n'est pas le cas. Ton vecteur n'est pas créé dans le tas. Lorsque le précédent objet cessera d'être référencé, il sera détruit, et avec lui tout ses membres, en appelant récursivement tous les destructeurs.

[yan]

Ben, déjà, ça ne compile pas sous GCC.
En fait, tu ne peux pas réappeler directement le constructeur puisqu'il n'est par définition valable qu'à la construction d'un objet. Dans cette optique, il faudrait détruire puis recréer x et y pour pouvoir les réinitialiser.

Je viens d'essayer sous code::block, ça ne marche pas. J'était persuadé que c'est ce que fait un pool de memoire.....

Par contre, comme je disais au-dessus, tu peux très bien faire ce genre de choses :

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
 
class Point
{
    public:
               Point (float,float);
 
       const float & x;
       const float & y;
 
    private:
       float priv_x;
       float priv_y;
};
 
Point::Point (float px,float py) :
   x(priv_x), y(priv_y), priv_x(px), priv_y(py)
{
}

ha ok, pas bête

C'est l'idée mais ce n'est pas le cas. Ton vecteur n'est pas créé dans le tas. Lorsque le précédent objet cessera d'être référencé, il sera détruit, et avec lui tout ses membres, en appelant récursivement tous les destructeurs.

J'ai pas tout compris... Mais avec visual, ca compile et ca me fait une jolie fuite memoire avec ce code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int main()
{
    Point p(2,3);
 
    while(1)
    {
        p+=Point(3,2);
    }
 
    return 0;
}

[edit]
voila comment faire la même chose avec gcc

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
 
struct Point
{
    Point(float x,float y)
        :x(x),y(y),vect(10000000)
    {}
    Point & operator+=(const Point &p)
    {
        new(this) Point(x+p.x,y+p.y);
        return *this;
    }
    const float x;
    const float y;
    const std::vector<float> vect;
};

[Médinoc]

C'est plutôt ton code avec gcc qui contient une fuite! Le destructeur de vect n'est jamais appelé!

[yan]

C'est plutôt ton code avec gcc qui contient une fuite! Le destructeur de vect n'est jamais appelé!

sous visual ceci compile

Code :

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

 this->Point::Point(x+p.x,y+p.y);

et fait aussi une fuite memoire.

[Médinoc]

Le problème de faire des classes avec des membres const, c'est que tu ne peux pas les affecter ni les swapper. Résultat, tu n'as plus trop le choix: Tu dois faire des membres non-constants, même si ton interface publique est constante.

Code C++ :

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
#include <vector>
#include <algorithm>
 
class Point
{
public:
	Point (float,float);
	//On laisse constructeur de copie et opérateur d'affectation par défaut
	void Swap(Point &);
 
	float x() const { return priv_x; }
	float y() const { return priv_y; }
	std::vector<float> const & vect() const { return priv_vect; }
 
private:
	float priv_x;
	float priv_y;
	std::vector<float> priv_vect;
};
 
namespace std
{
 
template<>
inline void swap< Point, Point >(Point &a, Point &b)
{
	a.Swap(b);
}
 
}

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include "Point.hpp"
 
Point::Point (float px,float py) :
 priv_x(px), priv_y(py), priv_vect(10000000)
{
}
 
void Point::Swap(Point &other)
{
	std::swap(priv_x, other.priv_x);
	std::swap(priv_y, other.priv_y);
	std::swap(priv_vect, other.priv_vect);
}

[yan]

Le problème de faire des classes avec des membres const, c'est que tu ne peux pas les affecter ni les swapper. Résultat, tu n'as plus trop le choix: Tu dois faire des membres non-constants, même si ton interface publique est constante.

C'est ce que j'ai compris.
J'aime bien l'astuce de Obsidian.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class Point
{
    public:
               Point (float,float);
 
       const float & x;
       const float & y;
 
    private:
       float priv_x;
       float priv_y;
};

[Médinoc]

Mais la présence de références ne rend-elle pas l'objet non-assignable de toute façon?

[Jean-Marc.Bourguet]

Si tu veux faire ce genre de choses, il faut faire

Code :

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

1
2
3
4
5
6
    Point & operator+=(const Point &p)
    {
        this->~Point();
        new(this) Point(x+p.x,y+p.y);
        return *this;
    }

mais cela n'est pas du bon style. En particulier, c'est fragile dans les cas ou le constructeur peut jeter des exceptions (on se retrouve avec un objet detruit qui le sera une deuxieme fois).

[yan]

Mais la présence de références ne rend-elle pas l'objet non-assignable de toute façon?

Comme les ref pointe sur des variables privé non const, elle se retrouve être assignable non?

[Jean-Marc.Bourguet]

Comme les ref pointe sur des variables privé non const, elle se retrouve être assignable non?

Pourquoi?

[yan]

car les variables privé son mutable

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
class Point
{
    public:
    Point (float xx,float yy)
     :priv_x(xx),priv_y(yy),x(priv_x),y(priv_y)
     {}
 
    Point & operator =(const Point & p)
   {
      priv_x = p.x;
      priv_y = p.y;
      return *this;
   }
 
       const float & x;
       const float & y;
 
    private:
       float priv_x;
       float priv_y;
};

[Jean-Marc.Bourguet]

car les variables privé son mutable

Le probleme n'est pas les membres prives mais la presence de references. Ce a quoi elles sont initialisees, c'est du detail d'implementation et n'influence pas la validite du code (imagine que les constructeurs ne soient pas inline par exemple).

[yan]

imagine que les constructeurs ne soient pas inline par exemple.

J'ai du mal à comprendre.
Si le constructeur n'est pas inline, c'est sensé changé quelque chose??

[Jean-Marc.Bourguet]

J'ai du mal à comprendre.
Si le constructeur n'est pas inline, c'est sensé changé quelque chose??

Tu veux que la validite de quelque chose depende du code qui n'est pas visible? Ou alors j'ai mal devine pourquoi tu voudrais pouvoir assigner alors qu'il y a des membres qui sont des references.

[loufoque]

Construire un objet à une adresse où un objet existe déjà est un comportement indéfini.
Il ne peut y avoir qu'un seul objet à une adresse.

[loufoque]

Si tu veux faire ce genre de choses, il faut faire

Code :

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

1
2
3
4
5
6
    Point & operator+=(const Point &p)
    {
        this->~Point();
        new(this) Point(x+p.x,y+p.y);
        return *this;
    }

mais cela n'est pas du bon style. En particulier, c'est fragile dans les cas ou le constructeur peut jeter des exceptions (on se retrouve avec un objet detruit qui le sera une deuxieme fois).

Code :

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

1
2
3
4
5
6
    Point & operator+=(const Point &p)
    {
        Point tmp(x+p.x, y+p.y);
        std::swap(*this, tmp);
        return *this;
    }

Problème résolu.