Salut,

J'ai trouve récemment du code qui initialise les objets de la façon
suivante :

X x = X(...);

Je me suis dit, facile, c'est une initialisation de x par un
temporaire, avec appel du copy-ctor. Eh bien non. Y a pas de
copy-ctor. Si j'en définis un, il n'est pas appelé. Si je le définis
avec X(X &) (c'est-à-dire pas de const), j'ai une erreur de compil (ce
que je conçois avec un temporaire).

Bref : est-une syntaxe reconnue ? recommandée ? ou seulement une
fantaisie de g++ (4.1.3, au fait, avec -W -Wall) ? Y en a-t-il
d'autres comme ça ? Quel est l'intérêt (à part pouvoir mettre des
parenthèses) ?

Merci d'avance pour vos lumières.

-- Alain.

P/S: un bout de code pour ceux qui voudraient essayer :

#include <iostream>
using namespace std;
class X {
public:
X() {cout<<"Normal"<<endl;}
X(const X &) {cout<<"Cpy"<<endl;} // virer const pour voir
};
int main()
{
X x = X();
return 0;
}

Alain Ketterlin <alain@dpt-info.u-strasbg.fr> writes:

> Salut,
>
> J'ai trouve récemment du code qui initialise les objets de la façon
> suivante :
>
> X x = X(...);
>
> Je me suis dit, facile, c'est une initialisation de x par un
> temporaire, avec appel du copy-ctor. Eh bien non. Y a pas de
> copy-ctor. Si j'en définis un, il n'est pas appelé. Si je le définis
> avec X(X &) (c'est-à-dire pas de const), j'ai une erreur de compil (ce
> que je conçois avec un temporaire).

PCQJES, c'est équivalent à : X x(...);

> Bref : est-une syntaxe reconnue ?

Oui.

> recommandée ?

Je l'aime bien. Je la recommenderais.


> ou seulement une
> fantaisie de g++ (4.1.3, au fait, avec -W -Wall) ?

Non, SJMSB, c'est bien dans la syntaxe du standard.


> Y en a-t-il
> d'autres comme ça ?

Tu parie! Il n'y a pas plus immonde que la syntaxe de C++, on y
trouve toutes les horreurs imaginables.


> Quel est l'intérêt (à part pouvoir mettre des
> parenthèses) ?

Je suppose que l'intérêt c'est de pouvoir appeler le constructeur
d'une sous-classe et de faire une projection immédiate.

-*- mode: compilation; default-directory: "~/src/miscellaneous/tests-c++/" -*-
Comint started at Wed Mar 26 22:58:15

cat test-constructor-projection.c++ \
&& g++ -o test-constructor-projection test-constructor-projection.c++ \
&& echo -------------------- \
&& ./test-constructor-projection

#include <iostream>
using namespace std;

class X {
public:
int x;
X(int anX):x(anX){
cout<<"X("<<anX<<");"<<endl;
}
};


class Y:public X {
public:
int y;
Y(int anX,int anY):X(anX),y(anY){
cout<<"Y("<<anX<<","<<anY<<");"<<endl;
}
};

int main(void){
X x=Y(1,2);
return(0);
}

--------------------
X(1);
Y(1,2);

Comint finished at Wed Mar 26 22:58:17


Mais dans ce cas, un Y temporaire est effectivement créé avant d'être
projeté sur x.

--
__Pascal Bourguignon__ http://www.informatimago.com/

COMPONENT EQUIVALENCY NOTICE: The subatomic particles (electrons,
protons, etc.) comprising this product are exactly the same in every
measurable respect as those used in the products of other
manufacturers, and no claim to the contrary may legitimately be
expressed or implied.

On Wed, 26 Mar 2008 22:31:43 +0100, Alain Ketterlin :

> X x = X(...);
>
>Je me suis dit, facile, c'est une initialisation de x par un
>temporaire, avec appel du copy-ctor.

Si je me souviens bien, c'est bien ça, à ceci près que le compilo a le
droit d'optimiser le code en supprimant le temporaire et l'appel au
constructeur de copie.

Donc, si je ne me trompe pas, le non-appel du constructeur est bien
une décision de g++, décision autorisée par la norme.

>Bref : est-une syntaxe reconnue ? recommandée ?

C'est tout à fait autorisé, mais je préfère franchement écrire
X x (...);

On Mar 26, 11:56 pm, Fabien LE LEZ <grams...@gramster.com> wrote:
> On Wed, 26 Mar 2008 22:31:43 +0100, Alain Ketterlin :

> > X x = X(...);

> >Je me suis dit, facile, c'est une initialisation de x par un
> >temporaire, avec appel du copy-ctor.

> Si je me souviens bien, c'est bien ça, à ceci près que le
> compilo a le droit d'optimiser le code en supprimant le
> temporaire et l'appel au constructeur de copie.

C'est à peu près ça. Plus généralement, il y a pas mal de
contextes où le compilateur a le droit de supprimer une copie.
La théorie, c'est qu'une copie, c'est une copie, et que si
l'objet supporte la copie, combien on en fait n'a pas
d'importance. C'est donc une bonne règel de ne pas compter sur
des effets de bord dans les constructeurs de copie.

> Donc, si je ne me trompe pas, le non-appel du constructeur est
> bien une décision de g++, décision autorisée par la norme.

C'est une décision qu'a pris la quasi-totalité des compilateurs,
je crois. Je n'en connais pas qui feront réelement la copie dans
ce cas-ci.

Note bien que la compilateur est censé de vérifier qu'il aurait
pÛ faire la copie, même s'il ne le fait pas. Ce qui même à la
situation que si tu ne fournis pas de constructeur de copie
utilisable, il y aurait une erreur à la compilation, mais si tu
le fournis, il ne serait pas appelé.

> >Bref : est-une syntaxe reconnue ? recommandée ?

> C'est tout à fait autorisé, mais je préfère franchement écrire
> X x (...);

Avec la risque qu'elle soit comprise comme une déclaration de
fonction. (Mais je suis d'accord avec toi -- c'est l'écriture
que j'utilise systèmatiquement pour les types de classe.)

--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

On Mar 26, 11:08 pm, Pascal Bourguignon <p...@informatimago.com>
wrote:
> Alain Ketterlin <al...@dpt-info.u-strasbg.fr> writes:
> > J'ai trouve récemment du code qui initialise les objets de la façon
> > suivante :

> > X x = X(...);

> > Je me suis dit, facile, c'est une initialisation de x par un
> > temporaire, avec appel du copy-ctor. Eh bien non. Y a pas de
> > copy-ctor. Si j'en définis un, il n'est pas appelé. Si je le définis
> > avec X(X &) (c'est-à-dire pas de const), j'ai une erreur de compil (ce
> > que je conçois avec un temporaire).

> PCQJES, c'est équivalent à : X x(...);

Pas tout à fait. C'est l'équivalent à :

X x( X( ... ) ) ;

Avec un droit spécial donné au compilateur de supprimer la copie
(comme c'est souvent le cas).

> > Bref : est-une syntaxe reconnue ?

> Oui.

> > recommandée ?

> Je l'aime bien. Je la recommenderais.

Comme Fabien, je préfère :

X x( ... ) ;

Si le type en question ne supporte pas la copie, de toute façon,
il n'y a pas le choix.

[...]

> SJMSB,

> > Y en a-t-il d'autres comme ça ?

> Tu parie! Il n'y a pas plus immonde que la syntaxe de C++, on
> y trouve toutes les horreurs imaginables.

C'est le prix qu'on paie d'avoid le C à la base.

Et en passant, c'est quoi PCQJES ? (« Pour ce que je », et puis
je seche.)

--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

James Kanze <james.kanze@gmail.com> writes:

> On Mar 26, 11:08 pm, Pascal Bourguignon <p...@informatimago.com>
> wrote:
>> > Y en a-t-il d'autres comme ça ?
>
>> Tu parle! Il n'y a pas plus immonde que la syntaxe de C++, on
>> y trouve toutes les horreurs imaginables.
>
> C'est le prix qu'on paie d'avoid le C à la base.

Eh Oui.


> Et en passant, c'est quoi PCQJES ? (« Pour ce que je », et puis
> je seche.)

Pour Ce Que J'En Sais = PCQJES = AFAIK = As Far As I Know ;-)

On peut aussi faire PAQJES = Pour Autant Que J'En Sache.

--
__Pascal Bourguignon__