Erreur avec Visual Studio 2005

Le
Philip K. Dick
Hello

J'ai le petit programme suivant qui compile nickel avec G++ sous Linux
mais pas avec Visual Studio 2005 :

// <virtual_beatle.h>

#ifndef _VIRTUAL_BEATLE
#define _VIRTUAL_BEATLE

#include <iostream>

namespace Beatles {

class Virtual_Beatle {
public:
virtual void hello();
friend std::ostream & operator << (std::ostream & os, Virtual_Beatle v);
};

};

#endif // _VIRTUAL_BEATLE

// <virtual_beatle.cpp> -

#include "virtual_beatle.h"

namespace Beatles {

void Virtual_Beatle::hello() {
std::cout << "Hello, I am an unknown Beatle" << std::endl;
}

std::ostream & operator << (std::ostream & os, Virtual_Beatle::Virtual_Beatle v) {
os << "Unknown Beatle";
return os;
};
};


Le compilo me sort :
"virtual_beatle.cpp(9) : error C2061: erreur de syntaxe : identificateur '{ctor}'"
"virtual_beatle.cpp(9) : error C2805: nombre de paramètres insuffisant pour l'opérateur binaire 'operator <<'"

Je ne vois pas où est l'erreur : l'exemple est tiré d'un bouquin
et je le répète avec G++ je n'ai aucun problème !

Merci pour toute aide !

PKD
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Michel Decima
Le #306141
Philip K. Dick wrote:

namespace Beatles {

class Virtual_Beatle {
public:
virtual void hello();
friend std::ostream & operator << (std::ostream & os,
Virtual_Beatle v);
};
};


D'apres son nom, et la presence de la fonction virtuelle hello(), il
semblerait que la classe Virtual_Beatle est destinée a etre derivée
et utilisée de maniere polymorphe. Ca serait une bonne idee de lui
declarer un destructeur virtuel.
Concernant l'operateur de formattage, il prend en parametre un
Virtual_Beatle par valeur, ca va donner des resultats étranges avec des
classes derivées. Le bon prototype serait

std::ostream& operator << (std::ostream & os, Virtual_Beatle const& v );

(concernant le point-virgule, il est necessaire apres l'accolade qui
ferme la declaration de la classe, mais inutile pour le namespace).

std::ostream & operator << (std::ostream & os, Virtual_Beatle::Virtual_Beatle v) {
os << "Unknown Beatle";
return os;
}


La notation Virtual_Beatle::Virtual_Beatle n'est pas correcte ici. Elle
devrait etre employee pour définir un constructeur, pas pour déclarer un
argument de fonction, et c'est bien ce que te signale le compilateur en
te distant qu'il y a une "erreur de syntaxe: identificateur {ctor}".

Si tu remplaces par

std::ostream&
operator << ( std::ostream & os,
Virtual_Beatle const& v)
{
os << "Unknown Beatle";
return os;
}

Ca devrait aller mieux.

Je ne vois pas où est l'erreur : l'exemple est tiré d'un bouquin
et je le répète avec G++ je n'ai aucun problème !


Les bouquins, il y en a des bons et des mauvais. Dans le cas present, on
s'oriente vers la deuxieme option...
Et j'ai l'impression que g++ devrait protester sur le deuxieme parametre
de la definition de operator<<, parce que la notation employee ne
represente pas un type, mais je ne sais pas pourquoi il ne le fait
pas... (y a t'il un spécialiste de g++ dans la salle ?).

M.

Philip K. Dick
Le #306140
Michel Decima wrote:
Philip K. Dick wrote:

namespace Beatles {

class Virtual_Beatle {
public:
virtual void hello();
friend std::ostream & operator << (std::ostream & os,
Virtual_Beatle v);
};
};


D'apres son nom, et la presence de la fonction virtuelle hello(), il
semblerait que la classe Virtual_Beatle est destinée a etre derivée
et utilisée de maniere polymorphe. Ca serait une bonne idee de lui
declarer un destructeur virtuel.
Concernant l'operateur de formattage, il prend en parametre un
Virtual_Beatle par valeur, ca va donner des resultats étranges avec des
classes derivées. Le bon prototype serait

std::ostream& operator << (std::ostream & os, Virtual_Beatle const& v );

(concernant le point-virgule, il est necessaire apres l'accolade qui
ferme la declaration de la classe, mais inutile pour le namespace).

std::ostream & operator << (std::ostream & os,
Virtual_Beatle::Virtual_Beatle v) {
os << "Unknown Beatle";
return os;
}


La notation Virtual_Beatle::Virtual_Beatle n'est pas correcte ici. Elle
devrait etre employee pour définir un constructeur, pas pour déclarer un
argument de fonction, et c'est bien ce que te signale le compilateur en
te distant qu'il y a une "erreur de syntaxe: identificateur {ctor}".

Si tu remplaces par

std::ostream&
operator << ( std::ostream & os,
Virtual_Beatle const& v)
{
os << "Unknown Beatle";
return os;
}

Ca devrait aller mieux.

Je ne vois pas où est l'erreur : l'exemple est tiré d'un bouquin
et je le répète avec G++ je n'ai aucun problème !


Les bouquins, il y en a des bons et des mauvais. Dans le cas present, on
s'oriente vers la deuxieme option...
Et j'ai l'impression que g++ devrait protester sur le deuxieme parametre
de la definition de operator<<, parce que la notation employee ne
represente pas un type, mais je ne sais pas pourquoi il ne le fait
pas... (y a t'il un spécialiste de g++ dans la salle ?).

M.

Super, merci beaucoup Michel,


Franchement j'ai des progrès à faire ... et pour moi
il n'était pas évident que 'ctor' = constructor ;-)

PKD


Philip K. Dick
Le #306139
Michel Decima wrote:
Philip K. Dick wrote:

namespace Beatles {

class Virtual_Beatle {
public:
virtual void hello();
friend std::ostream & operator << (std::ostream & os,
Virtual_Beatle v);
};
};


D'apres son nom, et la presence de la fonction virtuelle hello(), il
semblerait que la classe Virtual_Beatle est destinée a etre derivée
et utilisée de maniere polymorphe. Ca serait une bonne idee de lui
declarer un destructeur virtuel.
Concernant l'operateur de formattage, il prend en parametre un
Virtual_Beatle par valeur, ca va donner des resultats étranges avec des
classes derivées. Le bon prototype serait

std::ostream& operator << (std::ostream & os, Virtual_Beatle const& v );

(concernant le point-virgule, il est necessaire apres l'accolade qui
ferme la declaration de la classe, mais inutile pour le namespace).

std::ostream & operator << (std::ostream & os,
Virtual_Beatle::Virtual_Beatle v) {
os << "Unknown Beatle";
return os;
}


La notation Virtual_Beatle::Virtual_Beatle n'est pas correcte ici. Elle
devrait etre employee pour définir un constructeur, pas pour déclarer un
argument de fonction, et c'est bien ce que te signale le compilateur en
te distant qu'il y a une "erreur de syntaxe: identificateur {ctor}".

Si tu remplaces par

std::ostream&
operator << ( std::ostream & os,
Virtual_Beatle const& v)
{
os << "Unknown Beatle";
return os;
}

Ca devrait aller mieux.

Je ne vois pas où est l'erreur : l'exemple est tiré d'un bouquin
et je le répète avec G++ je n'ai aucun problème !


Les bouquins, il y en a des bons et des mauvais. Dans le cas present, on
s'oriente vers la deuxieme option...
Et j'ai l'impression que g++ devrait protester sur le deuxieme parametre
de la definition de operator<<, parce que la notation employee ne
represente pas un type, mais je ne sais pas pourquoi il ne le fait
pas... (y a t'il un spécialiste de g++ dans la salle ?).

M.

Super, merci beaucoup Michel,


Franchement j'ai des progrès à faire ... et pour moi
il n'était pas évident que 'ctor' = constructor ;-)

PKD


Philip K. Dick
Le #306138
Michel Decima wrote:
Philip K. Dick wrote:

namespace Beatles {

class Virtual_Beatle {
public:
virtual void hello();
friend std::ostream & operator << (std::ostream & os,
Virtual_Beatle v);
};
};


D'apres son nom, et la presence de la fonction virtuelle hello(), il
semblerait que la classe Virtual_Beatle est destinée a etre derivée
et utilisée de maniere polymorphe. Ca serait une bonne idee de lui
declarer un destructeur virtuel.
Concernant l'operateur de formattage, il prend en parametre un
Virtual_Beatle par valeur, ca va donner des resultats étranges avec des
classes derivées. Le bon prototype serait

std::ostream& operator << (std::ostream & os, Virtual_Beatle const& v );

(concernant le point-virgule, il est necessaire apres l'accolade qui
ferme la declaration de la classe, mais inutile pour le namespace).

std::ostream & operator << (std::ostream & os,
Virtual_Beatle::Virtual_Beatle v) {
os << "Unknown Beatle";
return os;
}


La notation Virtual_Beatle::Virtual_Beatle n'est pas correcte ici. Elle
devrait etre employee pour définir un constructeur, pas pour déclarer un
argument de fonction, et c'est bien ce que te signale le compilateur en
te distant qu'il y a une "erreur de syntaxe: identificateur {ctor}".

Si tu remplaces par

std::ostream&
operator << ( std::ostream & os,
Virtual_Beatle const& v)
{
os << "Unknown Beatle";
return os;
}

Ca devrait aller mieux.

Je ne vois pas où est l'erreur : l'exemple est tiré d'un bouquin
et je le répète avec G++ je n'ai aucun problème !


Les bouquins, il y en a des bons et des mauvais. Dans le cas present, on
s'oriente vers la deuxieme option...
Et j'ai l'impression que g++ devrait protester sur le deuxieme parametre
de la definition de operator<<, parce que la notation employee ne
represente pas un type, mais je ne sais pas pourquoi il ne le fait
pas... (y a t'il un spécialiste de g++ dans la salle ?).

M.

Super, merci beaucoup Michel,


Franchement j'ai des progrès à faire ... et pour moi
il n'était pas évident que 'ctor' = constructor ;-)

PKD


James Kanze
Le #306136
Philip K. Dick wrote:

J'ai le petit programme suivant qui compile nickel avec G++ sous Linux
mais pas avec Visual Studio 2005 :

//
#ifndef _VIRTUAL_BEATLE
#define _VIRTUAL_BEATLE

#include <iostream>

namespace Beatles {

class Virtual_Beatle {
public:
virtual void hello();
friend std::ostream & operator << (std::ostream & os, Virtual_Be atle v);
};
};

#endif // _VIRTUAL_BEATLE

//
#include "virtual_beatle.h"

namespace Beatles {

void Virtual_Beatle::hello() {
std::cout << "Hello, I am an unknown Beatle" << std::endl;
}

std::ostream & operator << (std::ostream & os, Virtual_Beatle::Virtu al_Beatle v) {


C'est quoi, Virtual_Beatle::Virtual_Beatle ?

Selon la norme, je crois que c'est bien un synonym pour
Virtual_Beatle, tout court, mais je ne suis pas 100% sûr, et
d'après le message d'erreur, il semble que VC++ le considère
comme le nom du constructeur.

Ce que tu veux, sans doute, c'est :

std::ostream&
operator<<(
std::ostream& dest,
Virtual_Beatle const& source )
{
}

C-à-d :

-- tu utilises le nom de la classe, et non quelque chose dans
la classe, comme nom du type,

-- tu passes le paramètre par référence -- sinon, il n'y a pas
de sens à utiliser les virtual, et

-- tu le passes par référence const, parce que tu n'as pas
l'intention de le modifier (j'espère).

os << "Unknown Beatle";
return os;
};
};

Le compilo me sort :
"virtual_beatle.cpp(9) : error C2061: erreur de syntaxe : identificateur '{ctor}'"
"virtual_beatle.cpp(9) : error C2805: nombre de paramètres insuffisant pour l'opérateur binaire 'operator <<'"


Le deuxième erreur, c'est un « knock on » -- une conséquence
de la première.

Je ne vois pas où est l'erreur : l'exemple est tiré d'un bouquin
et je le répète avec G++ je n'ai aucun problème !


Je serais intéressé à savoir quel bouquin. Si c'est le code
exact du bouquin, je te conseille de le jeter. En plus des
problèmes que j'ai cité ci-dessus :

-- l'utilisation d'un nom qui commence par _ et un majuscule
(c-à-d _VIRTUAL_BEATLE), même comme garde d'inclusion, a un
comportement indéfini, et

-- il faut sans doute un destructeur virtuel à Virtual_Beatle.

--
James Kanze (GABI Software) email:
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

Publicité
Poster une réponse
Anonyme