Difficulte de comprehension des streams et de l'operateur <<

Version imprimable

02/07/2012, 17h55
Logan5

Difficulte de comprehension des streams et de l'operateur <<
Bonjour a tous,

Je viens vers vous car j'ai une difficulté a comprendre les streams et l'utilisation de l'operateur <<.

J'ai saisi que ostream se base sur le type char, or lorsque je fais
Code:

1 2 3 4 5 6 7 Person p; p.name = "martin"; p.firstname = "philippe"; p.age = 29; char * c; c << p;
ca ne fonctionne pas. sachant que la classe Person possède
Code:

1 2 3 4 5 std::ostream& operator<<(std::ostream& out, Person & p){ out << p.name << p.firstname << p.age; return out; }
Est-il possible de récupérer mon ostream pour utiliser via ios::rdbuf la méthode streambuf::sgetc. Qui me permettrait de récupérer en mémoire les les caractères/bytes de mon objet.

Merci d'avance pour vos reponses.

Je ne comprends pas trop ce que tu veux faire avec ton char* c.

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
 
#include <iostream>
#include <sstream>
 
struct Person { std::string name, firstname; int age; };
std::ostream& operator<<(std::ostream& out, Person & p) {
	out << p.name << p.firstname << p.age;
	return out;
}
 
int main()
{
 Person p;
 p.name = "martin";
 p.firstname = "philippe";
 p.age = 29;
 
 std::stringstream ss;
 ss << p;
 
 std::cout << ss.str() << std::endl;
 
 return 0;
 
}

Citation:

Affiche : martinphilippe29

Peut-être préfèrera-t-il ceci :

Code:

1
2
3
4
5
6
7
char * operator<<( (char *) & retour, Person & p){
         char * retour = new char[strlen(p.name) + strlen(p.firstname) + 1] ;
	strcpy(retour, p.name);
        char * tmp = retour + strlen(p.name);
        strcpy(tmp, p.firstname);
	return retour;
}

Mais pourquoi utiliser un char * et non un string ?

Code:

1
2
3
4
5
6
const std::string & operator<<(std::string & retour, Person & p){
         retour = "";
         retour += p.name;
          retour += p.firstname;
	return retour;
}

Salut,

En fait, l'opérateur << est un opérateur binaire comme il y en a tant d'autres (+, -, *, /, leurs équivalents d'affectation, <, >, == et ceux que j'oublie ;)).

C'est à dire qu'il faut juste lui fournir deux opérandes : le premier à gauche, le second à droite.

Comme tous les autres opérateurs du même type, il fera exactement ce que tu pourras lui demander de faire en fonction des deux arguments qu'il obtiendra ;)

Il faut savoir que ce n'est pas l'opérateur << qui est responsable du comportement des flux, mais bien que c'est justement le fait qu'on lui passe, en tant que premier paramètre, un flux de sortie qui sera responsable du comportement que l'on observe sur la sortie standard ou dans un fichier.

Ceux qui ont choisi l'opérateur << comme opérateur pour les flux auraient tout aussi bien pu choisir n'importe quel autre, comme le montre l'utilisation de l'opérateur & dans boost::serialization ;)

Ensuite, il faut savoir que ce n'est pas avec un char * que l'opérateur << est spécialisé pour les flux, mais... avec la std::string (qui est un typedef de std::basic_string<char>) et que l'on profite "simplement" d'un comportement de conversion implicite de const char * en std::string grâce au constructeur qui va bien (en gros, basic_string::basic_string(charType *) )

Quand tu écris un code proche de
Code:

1 2 3 4 std::ostream& operator<<(std::ostream& out, Person & p){ out << p.name << p.firstname << p.age; return out; }
tu indiques que l'opérateur << doit prendre une référence sur un flux de sortie comme premier paramètre et une référence (qui devrait d'ailleurs être déclarée constante, vu que l'objet ne sera pas modifié par la fonction ;) ) sur un objet de type Person et qui renvoie... une référence sur le flux de sortie (de manière à pouvoir chainer les opérations de sorties vers le flux).

std::ostream n'a strictement rien à voir avec un quelconque char * car d'un coté tu as bel et bien une classe, c'est à dire une structure complexe composée de données (en gros, un buffer + une série d'informations particulière) et de fonctions membres, alors que char * représente... un pointeur sur un caractère, et qu'un caractère n'est jamais qu'une valeur numérique codée sur un certain nombre de bits (et devant donc se trouver dans une fourchette de valeurs particulières) ;)

En outre, il est fortement déconseillé d'utiliser des char * pour la représentation de chaines de caractères en C++, essentiellement parce que leur gestion est particulièrement délicate (respect du nombre de caractères que l'on peut utiliser, utilisation des fonctions comme strcpy, strcmp, strlen et autres, gestion dynamique de la mémoire allouée à la chaine de caractères, et j'en passe).

En C++, il existe une classe qui prend tout cela en charge pour toi, et qui est bien plus fiable que tout ce que tu pourras coder dans un délais raisonnable si tu n'est pas excessivement bon en C++ : la classe string, disponible dans l'espace de noms std (comme tout ce qui est fourni par le standard) par inclusion du fichier d'en-tête <string>.

Parmi les flux de sortie qui héritent de std::ofstream, il y en a cependant un qui devrait t'intéresser au plus haut point, surtout que tu voudrais sans doute arriver à convertir l'age de ta personne en chaine de caractères :D

Le flux dont je te parle est std::ostringstream qui permet, à condition de fournir l'opérateur << adéquat (exactement comme tu l'as fait, en plus) de convertir "n'importe quoi" en chaine de caractères :D

Ce flux dispose, entre autres, d'une fonction membre str() qui a pour effet de... renvoyer une std::string ;)

Tu pourrais donc parfaitement avoir quelque chose qui prendrait une forme proche de
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 /* soit la structure "Person" ressemblant à */ struct Person { std::string name; std::strintg firstname; int age; }; /* et l'opérateur << "qui va bien" ressemblant à */ std::ostream& operator<<(std::ostream& out, Person & p) { out << p.name << p.firstname << p.age; return out; } /* tu pourais très bien utiliser le tout sous une forme proche de */ int main() { Person p; p.name = "martin"; p.firstname = "philippe"; p.age = 29; std::stringstream ss; /* on introduit la personne dans le flux de conversion * mais ss pourrait, grace à l'opérateur << utilisant un ostream, * tout aussi bien être la sortie standard (cout) ou un fichier (ofstream) */ ss<<p; /* il est possible de récupérer une chaine de caractères au départ du * flux si c'est un std::(o)stringstream : */ std::string str = ss.str(); /* et, en cas de besoin, il est possible (pour la compatibilité avec C uniquement ;) * de récupérer une chaine de caractères "C style" grace à la fonction * membre de la classe string c_str() */ const char * charPtr = str.c_str(); /* ... */ return 0; }
Hope it helps ;)

03/07/2012, 19h41
Logan5

Merci pour toutes ces informations.

J'ai choisis de ne pas utiliser std::stringstream car je n'etais pas sur de pouvoir recuperer mes donnees en utilisant std::istream par la suite.

si jai un string avec "martinphilippe29", en effet comment faire pour recupere le prenom et le nom separement ? J'ai donc pense qu'avec un char* j'aurai plus de chance :?
03/07/2012, 20h12
Logan5
il y a encore une grosse zone d'ombre dans mon esprit.

Dans ce code :
Code:

1 2 3 4 std::ostream& operator<<(std::ostream& out, Person & p){ out << p.name << p.firstname << p.age; return out; }
Que se passe-t-il a ce niveau : out << p.name & out << p.age

p.name est du type std::string, out est un ostream et p.age est lui un int.
Quelle conversion s'execute ? Aucune pour p.name ? Une conversion de p.age en std::string ? Aussi out conserve-t-il le \0 de fin de string ?

Lorsque j'utilise la methode str() sur le stringstream, comment la nouvelle string peut conserver la "connaissance" des trois elements qui la compose ?

je suis encore un peu dans le flou :(
03/07/2012, 20h20
Neckara

Il ne me semble pas que ostream fasse une distinction entre les éléments qui le composent.
L'opérateur '<<(std::ostream & out, Type x)" est défini pour chaque type.
Je ne sais pas vraiment comment sont implémentés les flux mais théoriquement on n'a pas besoin de savoir ce qui se cache derrière.

EDIT :

Citation:

Envoyé par http://www.cplusplus.com/reference/iostream/ostream/

Formatted output
These member functions interpret and format the data to be written as sequences of characters. These type of operation is performed using member and global functions that overload the insertion operator (operator<<)

Fin Edit.

Par contre, je suis sûr que lors du .str(), tu obtiendras un string qui sera la concaténation de tous ces éléments. Tu n'auras donc plus de distinctions entre les différents éléments.

Après il faut savoir ce que tu cherches à faire ensuite avec ce que tu obtiendras.

Il va de soi que tu peux séparer les trois éléments à ta guise dans ta str, par exemple pour les séparer par une espace tu peux modifier ta surcharge du flux ainsi :
Code:

1 2 3 4 5 6 /* et l'opérateur << "qui va bien" ressemblant à */ std::ostream& operator<<(std::ostream& out, Person & p) { out << p.name << " " << p.firstname << " " << p.age; return out; }

Citation:
Envoyé par ptyxs
Il va de soi que tu peux séparer les trois éléments à ta guise dans ta str, par exemple pour les séparer par une espace tu peux modifier ta surcharge du flux ainsi :
Code:

1 2 3 4 5 6 /* et l'opérateur << "qui va bien" ressemblant à */ std::ostream& operator<<(std::ostream& out, Person & p) { out << p.name << " " << p.firstname << " " << p.age; return out; }
Je ne suis pas d'accord.
Et si la personne s'appelle De La Fontaine ?

Il faudrait donc utiliser un caractère comme '\t' pour séparer les différents éléments.

Ou alors créer sa propre classe contenant un nom, un prénom et un âge.
On redéfini les opérateurs de flux, on fait des getters pour le nom, le prénom et l'âge.
En membres privé on pourra avoir :
- un string contenant le nom, prénom et âge.
- l'âge en int.
- la taille du nom
- la taille du prénom

Et avec ceci on pourra pratiquement tout faire :
- obtenir un string ou un char * contenant toutes les informations ;
- obtenir les différents éléments séparément.

04/07/2012, 09h06
Bousk
Citation:

Envoyé par Logan5

Merci pour toutes ces informations.

J'ai choisis de ne pas utiliser std::stringstream car je n'etais pas sur de pouvoir recuperer mes donnees en utilisant std::istream par la suite.

si jai un string avec "martinphilippe29", en effet comment faire pour recupere le prenom et le nom separement ? J'ai donc pense qu'avec un char* j'aurai plus de chance :?

Que tu utilises un string, stream ou char* est strictement identique : il est absolument impossible de découper une chaîne dont on a pas définit de séparateur (un caractère particulier, un nombre de caractères, ...). Ce qui est ton cas dans ce que tu présentes.

Si tu veux pouvoir les redécouper, tu dois définir une règle de découpage, et la règle inverse sera celle utilisée pour la concaténation.
Citation:
il y a encore une grosse zone d'ombre dans mon esprit.

Dans ce code :

Code:

1 2 3 4 std::ostream& operator<<(std::ostream& out, Person & p){ out << p.name << p.firstname << p.age; return out; }

Que se passe-t-il a ce niveau : out << p.name & out << p.age

p.name est du type std::string, out est un ostream et p.age est lui un int.
Quelle conversion s'execute ? Aucune pour p.name ? Une conversion de p.age en std::string ? Aussi out conserve-t-il le \0 de fin de string ?
Honnêtement, je ne sais pas, mais la bonne nouvelle c'est : on en a rien à faire !
L'opérateur << est déjà surchargé correctement pour concaténer string, char* et int (entre autre).
Tout ce dont tu as à te soucier c'est de l'utiliser.
04/07/2012, 10h15
ptyxs

Citation:

Envoyé par Neckara

Je ne suis pas d'accord.
Et si la personne s'appelle De La Fontaine ?

Il faudrait donc utiliser un caractère comme '\t' pour séparer les différents éléments.

Bien entendu ! J'ai bien précisé qu'il pourrait modifier à sa guise et que ceci n'était qu'un exemple : à lui ensuite d'opérer en fonction de ses données et de ce qu'il souhaite en faire !!
05/07/2012, 08h36
Logan5

Ça m'aide beaucoup de savoir que ostream a besoin d'une regle de decoupage entre les elements qu'on lui transmet. Je pensais que chaque appelle a << etait flagué :aie:

Par le passe j'ai utilise Qt avec QDataStream et je n'avais pas a me soucier de cette separation. Je suppose que c'est intégré !
05/07/2012, 09h38
Bousk

J'ignore ce que fait QDataStream, mais std::ostream ne fait rien d'autre que ce qu'on lui demande : enregistrer un flux.
Ce n'est pas à lui de décider de séparer chaque enregistrement consécutif avec un flag, caractère spécial ou quoi que ce soit d'autre.
10/07/2012, 07h50
Joel F

cout << x << y << z:

s'evalue comme

((cout << x) << y) << z:

et comme cout << x renvoit cout , je te laisse faire 1+1