Discussion :

[Ekinoks]

Bonjour,

J'ai eu aujourd'hui un résultat surprenant...
Voici un exemple minimal qui reproduit le comportement :

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
#include <iostream>
#include <functional>
 
struct test {
	std::function<int()> fils;
 
	test( std::function<int()> f ) : fils(f) {
	}
 
	test(  ) : fils([](){return 0;}) {
	}
 
	int operator() () {
		return 1+fils();
	}
};
 
int main(int argc, char const *argv[])
{
	std::cout << test(test(test()))() << std::endl;
 
	return 0;
}

Le résultat affiché est 1....
Pourquoi le résultat n'est pas 3 ???
Le compilateur fait il une optimisation non légale ?

Merci pour votre aide

Edit : Je pensai avoir trouvé le bug.... mais en faite non... :^/

[ternel]

Ca ne viendrait pas de la copie?

[Ekinoks]

Ca ne viendrait pas de la copie?

Ho oui ! bien vue ! Il fait une copie plutôt que de convertir test en std::function.
Merci =)

Existe-t-il un moyen pour que la conversion soit prioritaire sur la copie ? Car si je rends la copie privée, alors je ne peux plus faire appelle a std::function<int()>( test() );

[dragonjoker59]

Mettre la copie privée, et ajouter un opérateur de conversion?

[Ekinoks]

Il y a un truc que je ne comprends pas dans le choix de la syntaxe du C++
Pour quoi avoir choisi de spécifier une sémantique spéciale pour ClassA::ClassA(ClassA const & o) comme constructeur de recopie ??
Ça enlève la possibilité de définir un constructeur classique qui prendrait en entrée un objet du même type que lui non ?

[dalfab]

Bonjour,

Un constructeur test( test t ) donnerai : pour créer une copie d'abord commencer par créer une copie que l'on reçoit en paramètre!!!! le constructeur de copie est forcément test( test const& ).

Code :

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

1
2
3
4
5
   test()               // crée un objet temporaire de type test
   test()()             // appelle l'operator()() d'un temporaire de type test
   test::operator()     // désigne les operator() des objets de type test
   &test::operator()()  // est l'adresse de l'operator() qui ne reçoit pas de paramètre.
   test(test(test()))() // crée une copie de copie de copie d'un test et appelle son operator()()

Rien dans cette dernière expression ne désigne test::operator() ou &test::operator()(), encore moins un std::function<int()> et donc a aucun moment on créera un test( std::function<int()> f ).
Même en créant un operator std::function<int()>()const, l'expression continuera de désigner une copie de copie, car la non-conversion est toujours pré-envisagée avant une conversion.

PS: rendre privé ou même détruire un constructeur ou une méthode n'empêchera jamais qu'il ne soit envisagé (si on tente de l'utiliser il y a erreur, mais jamais n'est envisagé un traitement substitutif à cause d'un protection.)

[Ekinoks]

Merci pour ces explications dalfab

Donc cela signifie qu'il est impossible de créer un constructeur qui aura comme argument un objet du même type que la classe en question...
Car le C++ considérera que ce n'est pas un constructeur classique, mais juste la manière de copier les objets...

Pour quoi ne pas avoir créé un mot clé spécifique pour redéfinir la manière de copier les objets ? ça ne choque que moi ?

[dalfab]

Il existe bien une fonction spécifique pour copier un objet c'est l'operator=.
Il existe d'autre moyens pour créer ou copier des objets, on fait ce que l'on veut, mais dans ton exemple, tu utilises test(...) qui correspond à la création d'un objet.

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
test t1;         // utilise le constructeur par défaut test::test()
test t2 = t1;    // utilise le constructeur par copie test::test(test const&)
// tu peux si ça te chante, le ré-écrire et y mettre ce que tu veux, mais ne pas faire 
// la copie donnera un code pour le moins surprenant!
test t3(t1);     // idem
test t4{t1};     // idem
test t5 = test(t1); // idem!
t2 = t1;         // t2 existe déjà, on appelle test::operator=(test const&)
 
extern void fct( test t );
fct( t1 );  // La fonction doit recevoir un objet de type test qui doit être créé à partir de t1. Le constructeur par copie test::test( test const& ) est appelé pour produire l'objet t.
fct( test(t1) ); // idem! C'est cela qui t'embarrasse mais le mot test correspond à créer un test!
 
extern test gct();
t2 = gct();   // on appelle test::operator=(test const&) pour copier le retour de gct()
test gct() {
   return t1; // on doit retourner un objet test, seul moyen en créer un par test::test( test const& ) pour avoir une copie de t1 en retour.
}

[ternel]

operator= ne copie pas un objet, il modifie un objet existant a partir d'un autre.
l'instruction a = b; modifie a, mais a existait déjà.

Le constructeur dit "de copie" est celui qui prend en argument un objet du même type;
Il porte se nom parce que précisément quand on construit un objet d'un type en prenant comme original un autre objet du même type, on en fait une copie.

Les cas rarissimes où ce n'est pas le cas, on doit le contourner.
La syntaxe n'est absolument pas spéciale, c'est le surnom qu'on donne à ce constructeur précis qui l'est.
Ca, et le fait que le compilateur en génère un automatiquement si on ne le fait pas soi-même.

Dans le cas présent, je ne désactiverai pas la copie (qui est appelée si tu écris test t1(f); test t2 = t1;.
Mais je passerai soit par un operateur de conversion et un static_cast, soit une fonction membre normale, par exemple:

Code :

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

std::function<void(void)> as_function() const {return std::function<void(void)>(*this); }

[Ekinoks]

La syntaxe n'est absolument pas spéciale, c'est le surnom qu'on donne à ce constructeur précis qui l'est.

Oui, pardon, ce n'est pas la syntaxe qui est spéciale, c'est la sémantique attachée à ce constructeur précis qui l'est (car c'est un cas particulier).
On ne peut même pas redéfinir ce constructeur en faisant "comme si" c'est un constructeur classique, car par convention c'est un constructeur de copie, donc toutes les bibliothèques, les compilateurs et les utilisateurs utiliseront ce constructeur pour copier les objets...
Ça me fait un peu penser au choix qui avait était fait pour le langage Fortant en disant que certain nom de variable ont des types associés (i, j, k, l, m, n au type integer) et si la première lettre des noms des variables commence par a-h ou o-z alors ce sont des real.
Ça me semble être des fausses bonnes idées, car ça essaye de simplifier le langage à coups de cas particuliers (et c'est toujours pénible à un moment ou un autre les cas particuliers...).

Dans le cas présent, je ne désactiverai pas la copie (qui est appelée si tu écris test t1(f); test t2 = t1;.
Mais je passerai soit par un opérateur de conversion et un static_cast, soit une fonction membre normale

Oui, c'est effectivement les seules solutions que je vois

[Bousk]

En fait c'est ton appel qui est foireux, parce qu'il n'appelle pas du tout les opérateurs comme tu sembles le croire mais se contente de créer et copier 1 objet.
Si tu veux effectivement appeler ton opérateur et voir le résultat de 3 il faudrait à priori faire std::cout << test(test(test()())())() << std::endl;

[jblecanard]

Oui, pardon, ce n'est pas la syntaxe qui est spéciale, c'est la sémantique attachée à ce constructeur précis qui l'est (car c'est un cas particulier).

Quelle autre sémantique pourrais-tu vouloir attendre de ce constructeur ? Quand tu lis:

Code c++ :

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

1
2
A a1;
A a2(a1);

Tu t'attends à autre chose qu'avoir une copie de a1 dans a2 ? Bien au contraire, ce qui serait surprenant, c'est qu'il fasse autre chose qu'une copie ! Concrètement, cette sémantique n'est pas forcée, c'est une convention. Si tu décidais de ne pas la respecter, je pleure d'avance pour les gens qui vont maintenir ton code derrière toi...

[Ekinoks]

En fait c'est ton appel qui est foireux, parce qu'il n'appelle pas du tout les opérateurs comme tu sembles le croire, mais se contente de créer et copier 1 objet.
Si tu veux effectivement appeler ton opérateur et voir le résultat de 3 il faudrait à priori faire std::cout << test(test(test()())())() << std::endl;

Eh... non... Mais c'est ma faute, j'aurai dû utiliser des noms aux classes plutôt que d'utiliser Test pour comprendre ce que je veux coder.
Revoici la même bizarrerie sur un cas un peu plus concret.

Je veux deux classes boites (une avec des parenthèses et une avec des crochets) et une classe Obj.
Et je veux pouvoir emboîter mes boites les une dans les autres.

Voici une proposition pour le faire sans héritage :

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
struct Obj {
 std::string _val;
 
 Obj(std::string val) : _val(val) {
 }
 
 std::string operator()() {
  return _val;
 }
};
 
struct BoiteA {
 std::function<std::string()> _inside;
 
 template <class T>
 BoiteA(T inside) : _inside( inside ) {
 }
 
 std::string operator()() {
  return " ( " + _inside() + " ) ";
 }
};
 
struct BoiteB {
 std::function<std::string()> _inside;
 
 template <class T>
 BoiteB(T inside) : _inside( inside ) {
 }
 
 std::string operator()() {
  return " [ " + _inside() + " ] ";
 }
};
 
 
int main(int argc, char const *argv[])
{
 std::cout << BoiteA( BoiteB( BoiteA( Obj("kado") )))() << std::endl;
 
 std::cout << BoiteA( BoiteA( BoiteA( Obj("kado") )))() << std::endl;
 
 return 0;
}

Si on ne fait pas attention, on peut croire que ce code est correct.
L'affichage de la première ligne donne bien le résultat attendu : ( [ ( kado ) ] )

Mais en fait, un bug peut se produire lorsque l'on essaye de mettre deux fois le même type de boite l'une dans l'autre.
Cela est dû au fait que le constructeur BoiteA::BoiteA(const BoiteA &o) correspond au constructeur de recopie.
Comme ce constructeur est un cas particulier et a une sémantique différente des autres constructeurs, bha ça part en sucette...
On a donc le constructeur par copie qui vient court-circuiter notre constructeur BoiteA::BoiteA(BoiteA inside).
Ainsi le résultat de la seconde ligne est : ( kado )

Quelle autre sémantique pourrait-tu vouloir attendre de ce constructeur ? Quand tu lis:

Code c++ :

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

1
2
A a1;
A a2(a1);

Tu t'attends à autre chose qu'avoir une copie de a1 dans a2 ?

Oui, je m'attendrai à autre chose. Pour rester cohérente avec la sémantique classique des constructeurs, l'instruction A a2(a1); devrais être possible seulement si on a défini le constructeur qui prend un argument A et ne devrais pas forcement faire une recopie (comme les constructeurs classiques quoi...).
Pour faire une recopie j'aurais introduit une nouvelle syntaxe pour ne pas rentrer en confie avec les constructeurs.
Un truc du style :

Code :

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

1
2
A a1;
A a2 <- a1;

Et qui aurait pour conséquence d’appeler une méthode spéciale de copie du type A::operator<-(const A &a).

Si tu décidais de ne pas la respecter, je pleure d'avance pour les gens qui vont maintenir ton code derrière toi...

Oui, on est bien d'accord que maintenant que le choix a était fait de considérer le constructeur A::A(const A &a) comme le constructeur appelé pour faire une recopie, on est obligé de faire avec

[Bousk]

Si on ne fait pas attention, on peut croire que ce code est correct.
L'affichage de la première ligne donne bien le résultat attendu : ( [ ( kado ) ] )

Mais en fait, un bug peut se produire lorsque l'on essaye de mettre deux fois le même type de boite l'une dans l'autre.
Cela est dû au fait que le constructeur BoiteA::BoiteA(const BoiteA &o) correspond au constructeur de recopie.

C'est que ton premier objet est casté implicitement en string via l'opérateur correspondant pour pouvoir trouver un constructeur valable.
Alors qu'avec un objet identique il appelle le constructeur par copie qui ne nécessite aucune conversion.

Oui, je m'attendrai à autre chose. Pour rester cohérente avec la sémantique classique des constructeurs, l'instruction A a2(a1); devrais être possible seulement si on a défini le constructeur qui prend un argument A et ne devrais pas forcement faire une recopie (comme les constructeurs classiques quoi...).

Et bien tu t'attendrais à du faux.
En C++ il n'y a pas grand chose de base, mais toute classe possède un constructeur, destructeur, constructeur de copie et opérateur d'assignation. Maintenant il y a aussi constructeur par mouvement et assignation par mouvement. Qui sont créés de manière trivial par le compilateur si pas explicitement écrits.