Fichier Test.h:
class Test
{
public:
friend ostream& toto(ostream &, const Test &);
friend ostream& operator<<(ostream&, const Test &);
int main()
{
return 0;
}
Fichier Test.h:
class Test
{
public:
friend ostream& toto(ostream &, const Test &);
friend ostream& operator<<(ostream&, const Test &);
int main()
{
return 0;
}
Fichier Test.h:
class Test
{
public:
friend ostream& toto(ostream &, const Test &);
friend ostream& operator<<(ostream&, const Test &);
int main()
{
return 0;
}
class Test;
ostream& operator<<(ostream &, const Test &);
class Test
{
public: ...
- Troisième point : je n'aime pas la technique "friend operator <<".
J'ai toutefois noté l'objection de James (était-ce bien lui ?) : en
gros, operator<< est sensé afficher l'état public d'un objet, et ne
devrait donc pas avoir besoin d'être friend, ni d'une fonction membre
du style "Print()". Si ta classe n'accepte aucun accès à "_nb", sa
valeur est uniquement la cuisine interne de la classe, et n'a pas à
être affiché (sauf à des fins de débogage).
class Test;
ostream& operator<<(ostream &, const Test &);
class Test
{
public: ...
- Troisième point : je n'aime pas la technique "friend operator <<".
J'ai toutefois noté l'objection de James (était-ce bien lui ?) : en
gros, operator<< est sensé afficher l'état public d'un objet, et ne
devrait donc pas avoir besoin d'être friend, ni d'une fonction membre
du style "Print()". Si ta classe n'accepte aucun accès à "_nb", sa
valeur est uniquement la cuisine interne de la classe, et n'a pas à
être affiché (sauf à des fins de débogage).
class Test;
ostream& operator<<(ostream &, const Test &);
class Test
{
public: ...
- Troisième point : je n'aime pas la technique "friend operator <<".
J'ai toutefois noté l'objection de James (était-ce bien lui ?) : en
gros, operator<< est sensé afficher l'état public d'un objet, et ne
devrait donc pas avoir besoin d'être friend, ni d'une fonction membre
du style "Print()". Si ta classe n'accepte aucun accès à "_nb", sa
valeur est uniquement la cuisine interne de la classe, et n'a pas à
être affiché (sauf à des fins de débogage).
- Troisième point : je n'aime pas la technique "friend operator <<".
Et pourquoi donc ?
Je sais, j'aurais pu mettre des GetMachin() et des SetTruc()...
- Troisième point : je n'aime pas la technique "friend operator <<".
Et pourquoi donc ?
Je sais, j'aurais pu mettre des GetMachin() et des SetTruc()...
- Troisième point : je n'aime pas la technique "friend operator <<".
Et pourquoi donc ?
Je sais, j'aurais pu mettre des GetMachin() et des SetTruc()...
- Troisième point : je n'aime pas la technique "friend operator <<".
Et pourquoi donc ?
Je sais, j'aurais pu mettre des GetMachin() et des SetTruc()...
- Troisième point : je n'aime pas la technique "friend operator <<".
Et pourquoi donc ?
Je sais, j'aurais pu mettre des GetMachin() et des SetTruc()...
- Troisième point : je n'aime pas la technique "friend operator <<".
Et pourquoi donc ?
Je sais, j'aurais pu mettre des GetMachin() et des SetTruc()...
On Sat, 10 Apr 2004 20:06:44 +0200, "Etienne Rousee"
wrote:Fichier Test.h:
class Test
{
public:
friend ostream& toto(ostream &, const Test &);
friend ostream& operator<<(ostream&, const Test &);
Bon, je sais que c'est courant comme méthode, mais j'aime pas :
- d'une part, les lignes "friend os..." ne déclarent pas de fonctions.
On a généralement moins d'erreurs bizarres en déclarant les fonctions
avant :
class Test;
ostream& toto(ostream &, const Test &);
class Test
{
public: ...
- d'autre part, ton .h n'est pas autosuffisant. En d'autres termes, un
.cpp ne contenant rien d'autre qu'un #include "test.h" ne compilerait
pas.
Il faudrait mettre le "#include <iostream>" et le "using namespace
std;" également dans le .h... sauf qu'on ne met pas de directive
"using" dans un .h.
Jusqu'ici, le .h devient :
--- début de test.h
#include <iostream> /* En théorie, je crois que cet #include ne suffit
pas, mais pour l'instant les compilos sont tellement en désaccord les
uns avec les autres que je préfère ne rien changer ici ;-) */
class Test;
std::ostream& toto (std::ostream &, const Test &);
std::ostream& operator<<(std::ostream&, const Test &);
class Test
{
public:
friend std::ostream& toto(std::ostream &, const Test &);
friend std::ostream& operator<<(std::ostream&, const Test &);
private:
int _nb;
};
--- fin de test.h
- Troisième point : je n'aime pas la technique "friend operator <<".
Je préfère largement la technique suivante (je mélange .h et .cpp pour
raccourcir mon post) :
class Test
{
public:
void Print (std::ostream &os) { os << _nb; }
private:
int _nb;
};
std::ostream << (std::ostream& os, Test const& t)
{
t.Print (os);
return os;
}
J'ai toutefois noté l'objection de James (était-ce bien lui ?)
: en gros, operator<< est sensé afficher l'état public d'un objet, et
ne devrait donc pas avoir besoin d'être friend, ni d'une fonction
membre du style "Print()". Si ta classe n'accepte aucun accès à "_nb",
sa valeur est uniquement la cuisine interne de la classe, et n'a pas à
être affiché (sauf à des fins de débogage).
On Sat, 10 Apr 2004 20:06:44 +0200, "Etienne Rousee"
<etienne.rousee@wanadoo.fr> wrote:
Fichier Test.h:
class Test
{
public:
friend ostream& toto(ostream &, const Test &);
friend ostream& operator<<(ostream&, const Test &);
Bon, je sais que c'est courant comme méthode, mais j'aime pas :
- d'une part, les lignes "friend os..." ne déclarent pas de fonctions.
On a généralement moins d'erreurs bizarres en déclarant les fonctions
avant :
class Test;
ostream& toto(ostream &, const Test &);
class Test
{
public: ...
- d'autre part, ton .h n'est pas autosuffisant. En d'autres termes, un
.cpp ne contenant rien d'autre qu'un #include "test.h" ne compilerait
pas.
Il faudrait mettre le "#include <iostream>" et le "using namespace
std;" également dans le .h... sauf qu'on ne met pas de directive
"using" dans un .h.
Jusqu'ici, le .h devient :
--- début de test.h
#include <iostream> /* En théorie, je crois que cet #include ne suffit
pas, mais pour l'instant les compilos sont tellement en désaccord les
uns avec les autres que je préfère ne rien changer ici ;-) */
class Test;
std::ostream& toto (std::ostream &, const Test &);
std::ostream& operator<<(std::ostream&, const Test &);
class Test
{
public:
friend std::ostream& toto(std::ostream &, const Test &);
friend std::ostream& operator<<(std::ostream&, const Test &);
private:
int _nb;
};
--- fin de test.h
- Troisième point : je n'aime pas la technique "friend operator <<".
Je préfère largement la technique suivante (je mélange .h et .cpp pour
raccourcir mon post) :
class Test
{
public:
void Print (std::ostream &os) { os << _nb; }
private:
int _nb;
};
std::ostream << (std::ostream& os, Test const& t)
{
t.Print (os);
return os;
}
J'ai toutefois noté l'objection de James (était-ce bien lui ?)
: en gros, operator<< est sensé afficher l'état public d'un objet, et
ne devrait donc pas avoir besoin d'être friend, ni d'une fonction
membre du style "Print()". Si ta classe n'accepte aucun accès à "_nb",
sa valeur est uniquement la cuisine interne de la classe, et n'a pas à
être affiché (sauf à des fins de débogage).
On Sat, 10 Apr 2004 20:06:44 +0200, "Etienne Rousee"
wrote:Fichier Test.h:
class Test
{
public:
friend ostream& toto(ostream &, const Test &);
friend ostream& operator<<(ostream&, const Test &);
Bon, je sais que c'est courant comme méthode, mais j'aime pas :
- d'une part, les lignes "friend os..." ne déclarent pas de fonctions.
On a généralement moins d'erreurs bizarres en déclarant les fonctions
avant :
class Test;
ostream& toto(ostream &, const Test &);
class Test
{
public: ...
- d'autre part, ton .h n'est pas autosuffisant. En d'autres termes, un
.cpp ne contenant rien d'autre qu'un #include "test.h" ne compilerait
pas.
Il faudrait mettre le "#include <iostream>" et le "using namespace
std;" également dans le .h... sauf qu'on ne met pas de directive
"using" dans un .h.
Jusqu'ici, le .h devient :
--- début de test.h
#include <iostream> /* En théorie, je crois que cet #include ne suffit
pas, mais pour l'instant les compilos sont tellement en désaccord les
uns avec les autres que je préfère ne rien changer ici ;-) */
class Test;
std::ostream& toto (std::ostream &, const Test &);
std::ostream& operator<<(std::ostream&, const Test &);
class Test
{
public:
friend std::ostream& toto(std::ostream &, const Test &);
friend std::ostream& operator<<(std::ostream&, const Test &);
private:
int _nb;
};
--- fin de test.h
- Troisième point : je n'aime pas la technique "friend operator <<".
Je préfère largement la technique suivante (je mélange .h et .cpp pour
raccourcir mon post) :
class Test
{
public:
void Print (std::ostream &os) { os << _nb; }
private:
int _nb;
};
std::ostream << (std::ostream& os, Test const& t)
{
t.Print (os);
return os;
}
J'ai toutefois noté l'objection de James (était-ce bien lui ?)
: en gros, operator<< est sensé afficher l'état public d'un objet, et
ne devrait donc pas avoir besoin d'être friend, ni d'une fonction
membre du style "Print()". Si ta classe n'accepte aucun accès à "_nb",
sa valeur est uniquement la cuisine interne de la classe, et n'a pas à
être affiché (sauf à des fins de débogage).
En
revanche, je n'ai jamais eu de problèmes avec des fonctions friend.
Est-ce que tu es en train de me dire qu'il y a encore des surprises qui
m'attendent ici aussi ?
En
revanche, je n'ai jamais eu de problèmes avec des fonctions friend.
Est-ce que tu es en train de me dire qu'il y a encore des surprises qui
m'attendent ici aussi ?
En
revanche, je n'ai jamais eu de problèmes avec des fonctions friend.
Est-ce que tu es en train de me dire qu'il y a encore des surprises qui
m'attendent ici aussi ?