Manipulador personalizado para C++ iostream

Question

Me gustaría implementar un manipulador personalizado para que ostream pueda manipular el siguiente elemento que se inserta en la transmisión. Por ejemplo, digamos que tengo una costumbre manipulador cita:

std::ostringstream os; 
std::string name("Joe"); 
os << "SELECT * FROM customers WHERE name = " << quote << name; 

El manipulador cita citarán nombre para producir:

SELECT * FROM customers WHERE name = 'Joe' 

¿Cómo hago para lograr eso? Gracias.

Answer 1

Resulta especialmente difícil añadir un manipulador de flujo de un C++, ya que uno no tiene control de cómo se utiliza el manipulador. Uno puede imbuir una nueva configuración regional en una secuencia, que tiene una faceta instalada que controla cómo se imprimen los números, pero no cómo se envían las cadenas. Y entonces el problema sería cómo almacenar el estado de cotización de manera segura en la transmisión.

Las cadenas se envían utilizando un operador definido en el espacio de nombres std. Si desea cambiar la forma en que las personas se imprimen, pero manteniendo el aspecto de manipuladores, puede crear una clase de proxy:

namespace quoting { 
struct quoting_proxy { 
    explicit quoting_proxy(std::ostream & os):os(os){} 

    template<typename Rhs> 
    friend std::ostream & operator<<(quoting_proxy const& q, 
            Rhs const& rhs) { 
     return q.os << rhs; 
    } 

    friend std::ostream & operator<<(quoting_proxy const& q, 
            std::string const& rhs) { 
     return q.os << "'" << rhs << "'"; 
    } 

    friend std::ostream & operator<<(quoting_proxy const& q, 
            char const* rhs) { 
     return q.os << "'" << rhs << "'"; 
    } 
private: 
    std::ostream & os; 
}; 

struct quoting_creator { } quote; 
quoting_proxy operator<<(std::ostream & os, quoting_creator) { 
    return quoting_proxy(os); 
} 
} 

int main() { 
    std::cout << quoting::quote << "hello" << std::endl; 
} 

que sería adecuado para ser utilizado para ostream. Si desea generalizar, también puede convertirlo en una plantilla y aceptar basic_stream en lugar de simplemente string. Tiene comportamientos diferentes a los manipuladores estándar en algunos casos.Debido a que funciona mediante la devolución del objeto proxy, no va a funcionar para casos como

std::cout << quoting::quote; 
std::cout << "hello"; 

Answer 2

[EDIT:. "TRUE semántica manipulador" (es decir, un estado citando persistente) también podría lograrse mediante envolver un std::ostream en lugar de derivados de ella, como se ha señalado por Benôit en los comentarios]

Por lo que yo sé, esto no se puede hacer directamente sin derivar una nueva clase de std::ostream o similar, o envolviendo dicha clase en otra clase que reenvía la mayoría de los métodos a su objeto std::ostream contenido. Esto se debe a que, para el ejemplo de código que proporcione al trabajo, deberá modificar de alguna manera el comportamiento de std::ostream& operator<<(std::ostream&, std::string const&), que se define en algún lugar de la jerarquía iostreams (o posiblemente donde esté definido std::string). También necesitará usar las instalaciones (un tanto feas) en ios_base para registrar una bandera booleana que tenga el estado actual de comillas. Consulte ios_base::xalloc(), ios_base::iword() y ios_base::pword() para averiguar cómo hacerlo.

Sin embargo, si usted está dispuesto a utilizar la siguiente sintaxis:

os << "SELECT * FROM customers WHERE name = " << quote(name); 

Esto se puede hacer de manera muy sencilla utilizando una función global (en un espacio de nombre adecuado, por supuesto).

Esta sintaxis tiene la ventaja de que la cotización no es persistente, lo que significa que no puede "filtrarse" cuando una función establece el indicador de formato quote y olvida volver a establecer su valor original.

Answer 3

Prueba esto:

#include <iostream> 
#include <iomanip> 

// The Object that we put on the stream. 
// Pass in the character we want to 'quote' the next object with. 
class Quote 
{ 
    public: 
     Quote(char x) 
      :m_q(x) 
     {} 
    private: 
     // Classes that actual does the work. 
     class Quoter 
     { 
      public: 
       Quoter(Quote const& quote,std::ostream& output) 
        :m_q(quote.m_q) 
        ,m_s(output) 
       {} 

       // The << operator for all types. Outputs the next object 
       // to the stored stream then returns the stream. 
       template<typename T> 
       std::ostream& operator<<(T const& quoted) 
       { 
        return m_s << m_q << quoted << m_q; 
       } 

      private: 
       char   m_q; 
       std::ostream& m_s; 
     }; 
     friend Quote::Quoter operator<<(std::ostream& str,Quote const& quote); 

    private: 
     char m_q; 
}; 

// When you pass an object of type Quote to an ostream it returns 
// an object of Quote::Quoter that has overloaded the << operator for 
// all types. This will quote the next object and the return the stream 
// to continue processing as normal. 
Quote::Quoter operator<<(std::ostream& str,Quote const& quote) 
{ 
    return Quote::Quoter(quote,str); 
} 


int main() 
{ 
    std::cout << Quote('"') << "plop" << std::endl; 
} 

Answer 4

o simplemente utilizar OTL que básicamente ya implementa una interfaz de corriente de SQL de manera muy similar a su ejemplo.