c++ - significado - std::cin

Escribe una función simple que funciona como "std:: cout" pero agrega un salto de línea al final

Question

En C ++ hay una función de biblioteca estándar llamada cout , que me permite enviar texto a la consola. Estoy seguro de que lo sabes.

#include <iostream>
using std::cout;
cout << "Some Text " << 15 << " Other Text";

Para hacer un salto de línea al final, necesito usar endl .

cout << "Some Text " << 15 << " Other Text" << endl;

¿Cómo puedo escribir una función llamada coutl que se comporta como cout pero también agrega un likebreak? Quiero usar la misma sintaxis que usa cout , especialmente el operador << .

coutl << "Some Text " << 15 << " Other Text"; // coutl should add a linebreak

Answer 1

Creando un pequeño objeto proxy que agrega << endl en su destructor:

class AddEndl
{
public:
AddEndl(std::ostream& os) : _holder(new Holder(os)) {}
template <class T>
friend std::ostream& operator<< (const AddEndl& l, const T& t)
{
return (l._holder->_os) << t;
}
private:
struct Holder {
Holder (std::ostream& os) : _os(os) {}
~Holder () { _os << std::endl; }
std::ostream& _os;
};
mutable std::shared_ptr<Holder> _holder;
}

Entonces necesitas una función para que obtengas una función temporal:

AddEndl wrap(std::ostream& os)
{
return AddEndl(os);
}

Esto debería funcionar:

wrap(std::cout) << "Hello";

ACTUALIZAR:

Muevo el destructor que agrega un std::endl a un objeto interno propiedad de std::shared_ptr<> para que el ejemplo ya no dependa de Copy Elision.

Answer 2

De hecho, el código

cout << "Some Text " << 15 << " Other Text" << endl;

llama a la (s) función (es) del operador

// (pseudo code)
std::ostream& operator<<(std::ostream, [type] obj);

varias veces para cada uso de los << operadores. Para lograr lo que desea, debe crear una clase que se comporte como std::ostream , pero "mágicamente" sabe cuándo se emite la "última" llamada al operator<< y agrega un salto de línea. Eso no es posible en mi humilde opinión sin otro objeto que haga un seguimiento del alcance de las declaraciones.

Answer 3

No es posible solo con un objeto no temporal creado en la pila y que tiene un alcance de función completo. ¿Cómo sabrá el objeto alguna vez cuál es la última de las llamadas encadenadas al << operator ?

Puedes probar hacks como estos

class coutl
{
public:
~coutl()
{
cout<<endl;
}
template<class T>
coutl &operator<<(const T &x)
{
cout<<x;
return *this;
}
};
int main()
{
coutl()<<"Hello"<<10<<"World";
coutl()<<"Hello"<<20<<"World";
}

Otro truco similar usando el destructor

class myostream
{
public:
~myostream()
{
cout<<endl;
}
template<class T>
myostream &operator<<(const T &x)
{
cout<<x;
return *this;
}
};
int main()
{
{
myostream coutl;
coutl<<"Hello"<<10<<"World";
}
{
myostream coutl;
coutl<<"Hello"<<10<<"World";
}
}

Answer 4

coutl << "Some Text " << 15 << " Other Text"; // coutl should add a linebreak

Tu idea no puede ser consciente. De hecho, cout << str1; es equivalente a cout.operator<<(str1) que devuelve una referencia de cout en sí. Entonces cout << a << b << c; puede resolvd a ((cout << a) << b) << c; No sabe cuándo es la última llamada para insertar un salto de línea.