ejemplos - c++ online

C++ equivalente de java.toString?

Question

Me gustaría controlar lo que está escrito en una secuencia, es decir, cout , para un objeto de una clase personalizada. ¿Es eso posible en C ++? En Java, puede anular el método toString() para fines similares.

Answer 1

Como una extensión de lo que dijo John, si desea extraer la representación de cadena y almacenarla en una std::string haga lo siguiente:

#include <sstream>
// ...
// Suppose a class A
A a;
std::stringstream sstream;
sstream << a;
std::string s = sstream.str(); // or you could use sstream >> s but that would skip out whitespace

std::stringstream está ubicado en el encabezado <sstream> .

Answer 2

En C ++ 11, to_string finalmente se agrega al estándar.

http://en.cppreference.com/w/cpp/string/basic_string/to_string

Answer 3

En C ++, puede sobrecargar el operator<< for ostream y su clase personalizada:

class A {
public:
int i;
};
std::ostream& operator<<(std::ostream &strm, const A &a) {
return strm << "A(" << a.i << ")";
}

De esta forma, puede generar instancias de su clase en transmisiones:

A x = ...;
std::cout << x << std::endl;

En caso de que su operator<< quiera imprimir las partes internas de la clase A y realmente necesite acceder a sus miembros privados y protegidos, también podría declararlo como una función amiga:

class A {
private:
friend std::ostream& operator<<(std::ostream&, const A&);
int j;
};
std::ostream& operator<<(std::ostream &strm, const A &a) {
return strm << "A(" << a.j << ")";
}

Answer 4

La pregunta ha sido respondida. Pero quería agregar un ejemplo concreto.

class Point{
public:
Point(int theX, int theY) :x(theX), y(theY)
{}
// Print the object
friend ostream& operator <<(ostream& outputStream, const Point& p);
private:
int x;
int y;
};
ostream& operator <<(ostream& outputStream, const Point& p){
int posX = p.x;
int posY = p.y;
outputStream << "x="<<posX<<","<<"y="<<posY;
return outputStream;
}

Este ejemplo requiere la comprensión de la sobrecarga del operador.

Answer 5

También puedes hacerlo de esta manera, permitiendo el polimorfismo:

class Base {
public:
virtual std::ostream& dump(std::ostream& o) const {
return o << "Base: " << b << "; ";
}
private:
int b;
};
class Derived : public Base {
public:
virtual std::ostream& dump(std::ostream& o) const {
return o << "Derived: " << d << "; ";
}
private:
int d;
}
std::ostream& operator<<(std::ostream& o, const Base& b) { return b.dump(o); }