toString() et operator<<

Version imprimable

Bonjour,

J'aimerais savoir s'il est possible en C++ de faire quelque chose d'équivalent à la fonction toString() en Java.

En Java, lorsqu'un objet est additionné à une String, la fonction toString de l'objet est automatiquement appelée et la String reçue concaténée à la première String.

Exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 public class Personne { private String nom, prenom; public Personne(String nom, String prenom) { this.nom = nom; this.prenom = prenom; } public String getNom() { return nom; } public String getPrenom() { return prenom; } public String toString(){ return this.nom + " " + this.prenom; } }
Code:

1 2 3 4 5 6 7 8 9 public class Main { public static void main(String[] args) { Personne p = new Personne("Simpson", "Homer"); //initialisation de personne System.out.println(p); // affichage de la personne String s = "Il s'appelle : " + p; //concaténation System.out.println(s); // affichage de la chaine concaténée } }
Cela affichera "Il s'appelle : Simpson Homer"

Est-il possible en C++ d'écrire quelque chose dans la classe Personne qui permette d'écrire dans les autres classes
Code:

1 2 3 cout << p // affichage de la personne String s = "Il s'appelle : "+ p; //concaténation cout << s // affichage de la chaine concaténée

Lu

Pourquoi tu n'implémentes pas la fonction "string Personne::toString()", comme ca tu appelles "cout << p.toString();" ?

Sinon, j'ai lu un cours la semaine dernière et je peux faire marcher ton "int main()", ca ne consiste pas à un appel implicite à une méthode "toString()", mais en faisant surcharger 2 fonctions de la librairie standard C++.

Ton problème est donc de faire compiler et fonctionner ces 2 lignes:

Code:

1
2
3
 
Ton cout << p // affichage de la personne
String s = "Il s'appelle : "+ p; //concaténation

Voici un code complet qui fonctionne, à tout mettre en le "main.cpp"

Code:

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
45
46
47
48
49
 
 
#include <iostream>
#include <string>
 
using namespace std;
 
class Personne {
	private:
		string nom, prenom;
 
	public:
		Personne(string monNom, string monPrenom) : nom(monNom), prenom(monPrenom){}
 
        string toString()
        {
            return nom + " " + prenom + "\n";
        }
 
        void toString(ostream &out)
        {
            out << toString();
        }
        void toString(string &str)
        {
            str = str + toString();
        }
};
 
ostream &operator<<( ostream &out, Personne &p )
{
	p.toString(out) ;
	return out;
}
 
string &operator+( string str, Personne &p )
{
	p.toString(str) ;
	return str;
}
 
int main()
{
	Personne p("Simpson", "Homer");
	cout << p ; // affichage de la personne
	string s = "Il s'appelle : " + p; //concaténation
	cout << s; // affichage de la chaine concaténée
	return 0;
}

17/05/2010, 12h45
3DArchi

Bonjour et bienvenu,
La réponse est dans la F.A.Q. : Comment utiliser les flux pour afficher ou saisir mes objets ?

Salut, et bienvenue sur le forum.

Le principe sera sensiblement le même qu'en java:
1- Créer une fonction membre toString dans ta classe, sous une forme proche de :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Person { public: Person(std::string const & firstName_, std::string const & name_): name_(name_),firstName_(firstName_){} std::string const & name() const{return name_;} std::string const & firstName() const{return firstName_;} std::string const toString() const{return firstName_+" "+name_;} private: std::string name_; std::string firstName_; };
2- redéfinir l'opérateur << pour la classe Person, l'un des moyen le plus simple étant d'utiliser la fameuse fonction toString précédemment définie :D:
Code:

1 2 3 4 5 std::ostream & operator<<(std::ostream & ofs, Person const & p) { ofs<<p.toString(); return ofs; }
Ensuite, tu reste donc totalement libre de l'utilisation de la fonction toString ou de l'opérateur << (fais cependant attention au fait que, tel que je l'ai définis, il sera aussi bien utilisé pour un affichage console que pour l'écriture dans un fichier :aie:):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 int main() { Person homer("Homer","Simpson"); /* on peut utiliser toString pour l'affichage */ std::cout<<homer.toString()<<std::endl; /* ou pour s'assurer que l'on dispose de la bonne personne */ if(homer.toString()!="Marge Simpson") { cout<<"la personne n'est pas Marge"<<std::endl; } /* et on peut directement utiliser n'importe quelle instance de * Person avec l'opérateur << */ std::cout<< homer<<std::endl; /* comme indiqué, cela fonctionne avec tous les flux: */ std::ofstream ofs("fichier.txt"); ofs<<homer<<endl; /* créera un fichier texte nommé "fichier.txt" et contenant * "Homer Simpson" ;) */ return 0; }
[EDIT]Alternativement, il sera peut être intéressant de prévoir également l'opérateur >> afin de pouvoir créer une instance au départ d'un flux entrant :aie:.

Il prendrait la forme de
Code:

1 2 3 4 5 6 7 8 std::istream & operator>>(std::istream & ifs, Person & p) { std::string n; std::string f; ifs>>f>>n; p=Person(f,n); return ifs; }
et serait utilisé sous une forme proche de
Code:

1 2 3 4 5 6 7 int main() { Person p("",""); std::cin>>p; /* l'affichage pour bien montrer que ca a fonctionné :D */ std::cout<<p<<std::endl; }