Newsgroup: it.comp.lang.c++
Titolo: string += int;

Problema banale:
Ho
	string s = "pippo ";
	int a = 10;
e vorrei ottenere che 's' dopo la sua creazione vada a contenere il valore
"pippo 10". Qual è la soluzione piu semplice/comoda/elegante proposta dal
c++ ? Andando a leggere qua e là mi è sembrato che la soluzione piu
usata sia quella di creare una funzione apposita tipo:
string foo(int i)
{
	std::stringstream ss;
	ss << i;
	return ss.str();
}
s += foo(a);
E mi chiedevo se non ci fosse qualcosa di piu semplice o una funzione già
pronta..
Grazie
Ciao
M'?

 }
Intanto non sta a me (per fortuna) dire qual'è la più 
semplice/comoda/elegante possibile in C++.
Io poi naturalmente complico anche le cose più semplici (ahìme).
Poi, anche io farei come fa il codice che hai scritto (dato che il 
problema è molto semplice ed è una via immediata) oppure farei una 
funzioncina alla quale passare la stringa per riferimento e l'intero e 
con sprintf ci aggiungo un array di caratteri, non sarà elegante ma 
funziona subito!
Tuttavia vorrei farti vedere un esempio (più complesso e non so dirti se 
elegante o no) a puro titolo d'esempio che visto così sembra una inutile 
complicazione però in certe occasioni (per problemi diversi) potrebbe 
risultare comodo, non per una semplice stringa ma più in generale, 
sfruttando una caratteristica avanzata del C++; per quanto l'idea 
funziona anche per il tuo problema.
Lascia stare l'implementazione, che l'ho fatta in due minuti, ma pensa 
soltanto all'idea: usare il sovraccaricamento degli operatori.
Idea: sarebbe bello poter disporre di qualcosa di simile a
s+=a;
Se non esistesse già un operatore += definito fra stringa e intero 
potremmo crearlo noi.
Purtroppo esiste ma si comporta diversamente da come vorremmo e quindi 
non lo possiamo usare.
Soluzione: creiamo una classe nostra che incapsula un int, anche se non 
fa tutto quello che fa un int non importa, basta che ne conservi il 
valore e creaiamo un sovraccaricamento dell'operatore += con la nostra 
classe, potremmo creare anche altri operatori, tutti quelli che abbiamo 
in mente, ad esempio == != o = (assegnamento).
Ecco l'esempio, anche se non è il modo migliore e l'ho fatto in fretta e 
spero non contenga errori, sia significativo, nel senso che riesca a 
suggerirti qualche idea, che poi realizzarai (magari in diversi 
contesti) anche meglio di come lo faccio io nella mia risposta.
Con il C++ e le sue caratteristiche ci sono sempre tantissimi modi, ed è 
solo il programmatore a decidere come fare.
#include <iostream>
#include <string>
#include <cstdio>
// questa e' una classe che serve soltanto a chiamare un intero in un altro
// modo, in pratica (e' solo uno stralcio... questa lo legge solamente)
class string_int
{
         int integer;
         public:
         string_int() : integer(0) {};
         template<typename T>
         string_int(const T& t) : integer(static_cast<int>(t)) {};
         string_int(const string_int& S) : integer(S.integer) {};
         const int& getInt() const { return integer; }
};
// rinunciando a ridefinire
// string& operator+=(std::string& left,const int& right)
// ci accontentiamo e aggiungiamo invece
// string& operator+=(std::string& left,const string_int& right)
// in questo modo non faremo (string)s+=(int)d ma potremo fare
// (string)s+=(string_int)S;
std::string& operator+=(std::string& left,const string_int& right)
{
         char buf[32];
         std::sprintf(buf,"%d",right.getInt());
         left+=buf;
         return left;
}
using namespace std;
int main()
{
         string s="pippo ";
         int a=10;
         // aggiunge in coda a s la stringa corrispondente all'intero
         s+=string_int(a);
         cout << s << endl;
         return 0;
}
ah... sembra superfluo, io ho usato sprintf ma qualsiasi metodo va 
bene... anche gli sstream, era soltanto per far qualcosa di diverso.
Ciao!

Matic ha scritto:

Credo che la soluzione sia definire operator+= e operator+ per il tipo 
di somma che ti serve :
string &operator+=(string &s, const int i)
{
  	std::stringstream ss;
  	ss << i;
	s += ss.str();
	return s;
}
const string operator+(const string &s, const int i)
{
  	std::stringstream ss;
  	ss << i;
	return s + ss.str();
}
const string operator+(const int i, const string &s)
{
  	std::stringstream ss;
  	ss << i;
	return ss.str() + s;
}
Ne ho definiti 2 per permettere la commutatività dell'operazione :
std::string s = "pippo ";
int i = 10;
s += i;
s = s + i;
s = i + s;
La definizione di operator+= a global scopre + possibile in quanto non 
è necessarrio accedere a membri privati di s.
ciao,
Giulio

 Ciao!
Grazie dei suggerimenti, e della prolissità :)