2011-10-13 22 views

Respuesta

1

Escribe o lee objetos;

std::cout << 5; // writes the integer 5 to the standard output 

int x; 
std::cin >> x; // reads an integer from the standard input 

Está sobrecargado para todos los tipos estándar.
Y la mayoría de las personas los reemplazan por sus propios tipos definidos por el usuario.

Nota: El lado izquierdo del operador puede ser de cualquier tipo de flujo (como std :: fstream o std :: stringstream) por lo que se convierte en un mecanismo generalizado para la serialización de objetos.

10

Depende de cómo se sobrecargue para su clase.

  • En caso de std::cout, << se utiliza para escribir en la salida estándar. >> no está sobrecargado para std::cout. Entonces std::cout >> x daría error de compilación.

  • En el caso de std::cin, >> se utiliza para leer desde la entrada estándar. << no está sobrecargado para std::cout. Entonces std::cin << x daría error de compilación.

  • Para su clase personalizada, puede sobrecargar << o >>, o ambos, y en la función puede hacer lo que quiera. Por ejemplo, en el código siguiente, sobrecargo << para std::vector<T> añadir elementos al vector,

    template<typename T> 
    std::vector<T> & operator<<(std::vector<T> & v, T const & item) 
    { 
         v.push_back(item); 
         return v; 
    } 
    

    ahora puedo usar esta sobrecarga de escribir esto:

    std::vector<int> v; 
    v << 1 << 2 << 3 << 4 << 5; //inserts all integers to the vector! 
    

    se añade Todos los números enteros a la ¡vector! Ver demostración en línea: http://ideone.com/TsqtS

    Del mismo modo, podemos sobrecargar >> para std::vector<T> para imprimir todos los artículos en ella como:

    template<typename T> 
    std::vector<T> & operator>>(std::vector<T> & v, std::ostream & out) 
    { 
        for(size_t i = 0 ; i < v.size(); i++) 
         std::cout << v[i] << std::endl; 
        return v; 
    } 
    

    Y ahora podemos imprimir el vector como:

    v >> std::cout; //crazy! 
    

    Online demo: http://ideone.com/BVSm7

El punto es que puedes sobrecargar estos operadores de la forma que quieras. Cuán loca o sana sea la sobrecarga y su uso depende de usted. Por ejemplo, la sintaxis v >> std::cout parecería una locura para la mayoría de los programadores, como supongo.Una sobrecarga mejor y, probablemente, en su sano juicio sería para std::ostream como:

template<typename T> 
std::ostream & operator << (std::ostream & out, const std::vector<T> & v) 
{ 
     for(size_t i = 0 ; i < v.size(); i++) 
     out << v[i] << std::endl; 
     return out; 
} 

Ahora usted puede escribir lo siguiente:

std::cout << v << std::endl; //looks sane! 

Demostración: http://ideone.com/jce2R

+0

sobrecarga del operador tiene una mala reputación. No debemos alentar su abuso. Su uso para la transmisión está bien establecido, lo anterior solo va a confundir a un mantenedor (ya que está tan fuera de ritmo de lo normal). –

+1

@LokiAstari: ¿cómo es este abuso? Cualquiera que esté familiarizado con su uso para la transmisión debe darse cuenta de lo que hace el código anterior. La mayoría de los contenedores Qt funcionan de esa manera y los uso mucho porque hacen que el código sea más fácil de mantener y leer. – pezcode

+0

@LokiAstari: Lo sé. eso es lo que estoy explicando en mi publicación, con varios tipos de sobrecargas. – Nawaz

0

Ellos son a menudo sobrecargados y utilizados para los flujos. < < en realidad es un operador de desplazamiento lef. >> en realidad es un operador de cambio a la derecha.

2

Son operadores de desplazamiento bit a bit (<< es desplazamiento a la izquierda, >> es desplazamiento a la derecha). También suelen estar sobrecargados como operadores de transmisión (<< y luego significa transmisión, >> transmisión) - con tipo de transmisión en el lado izquierdo (por ejemplo, std::ostream o std::istream) y cualquier otro tipo en el lado derecho.

0

< < y >> son operadores simples, al igual que +, -, =, ==, + =,/= etc., obtiene el ejercicio. Eso significa que depende del objeto/estructura con el que lo estés usando. Con cout y cin estos son operadores de lectura/escritura, pero posiblemente podría sobrecargar al operador para hacer algo completamente diferente.

class myclass { 
    int x; 
    myclass operator << (int a) { 
     x += a; 
    } 
} 

Ahora, no digo que nadie debería hacer esto, pero esto daría lugar a una adición si desea utilizar un objeto miclase con este operador. Entonces, como puede ver: lo que hace con "< <" o ">>" depende de cómo el operador esté sobrecargado.