namespace Beatles {
class Virtual_Beatle {
public:
virtual void hello();
friend std::ostream & operator << (std::ostream & os,
Virtual_Beatle v);
};
};
std::ostream & operator << (std::ostream & os, Virtual_Beatle::Virtual_Beatle v) {
os << "Unknown Beatle";
return os;
}
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 !
namespace Beatles {
class Virtual_Beatle {
public:
virtual void hello();
friend std::ostream & operator << (std::ostream & os,
Virtual_Beatle v);
};
};
std::ostream & operator << (std::ostream & os, Virtual_Beatle::Virtual_Beatle v) {
os << "Unknown Beatle";
return os;
}
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 !
namespace Beatles {
class Virtual_Beatle {
public:
virtual void hello();
friend std::ostream & operator << (std::ostream & os,
Virtual_Beatle v);
};
};
std::ostream & operator << (std::ostream & os, Virtual_Beatle::Virtual_Beatle v) {
os << "Unknown Beatle";
return os;
}
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 !
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,
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,
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,
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,
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,
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,
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,
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,
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,
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_Be atle 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::Virtu al_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 !
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_Be atle 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::Virtu al_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 !
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_Be atle 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::Virtu al_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 !
