Discussion :

[Finroth]

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 de la classe Personne :

Sélectionner tout - Visualiser dans une fenêtre à part

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 de la classe Main :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Sacha999]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[3DArchi]

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

[koala01]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 .

Il prendrait la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}