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.