c++ - ¿Por qué llamar a cout.operator<<(const char*) imprime la dirección en lugar de la cadena de caracteres?




c++11 c++14 (2)

Cuando haces cout.operator<<(str) llamas a la función miembro de cout ' operator << . Si nos fijamos en qué funciones miembro sobrecarga cout tenemos

basic_ostream& operator<<( short value );
basic_ostream& operator<<( unsigned short value );

basic_ostream& operator<<( int value );
basic_ostream& operator<<( unsigned int value );

basic_ostream& operator<<( long value );
basic_ostream& operator<<( unsigned long value );

basic_ostream& operator<<( long long value );
basic_ostream& operator<<( unsigned long long value );

basic_ostream& operator<<( float value );
basic_ostream& operator<<( double value );
basic_ostream& operator<<( long double value );

basic_ostream& operator<<( bool value );

basic_ostream& operator<<( const void* value );

basic_ostream& operator<<( std::nullptr_t );

basic_ostream& operator<<( std::basic_streambuf<CharT, Traits>* sb);

basic_ostream& operator<<(
    std::ios_base& (*func)(std::ios_base&) );

basic_ostream& operator<<(
    std::basic_ios<CharT,Traits>& (*func)(std::basic_ios<CharT,Traits>&) );

basic_ostream& operator<<(
    std::basic_ostream<CharT,Traits>& (*func)(std::basic_ostream<CharT,Traits>&) );

Si observa, no hay uno para un const char* , pero hay uno para un const void* . Por lo tanto, su const char* se convierte en un const void* y esa versión de la función imprime la dirección que posee el puntero.

Lo que debe hacer es llamar a la sobrecarga de la función no miembro del operator<< y para hacerlo puede usar

cout << str;

Estaba explorando la clase ostream en C ++. Estoy atascado en la extraña salida de cout en cadenas y tipos de datos enteros.

Al pasar un valor entero o de punto flotante, la salida es exactamente lo que paso. Por ejemplo cout.operator<<(10); impresiones 10 . Pero al pasar una cadena como argumento, está imprimiendo algunos valores hexadecimales:

#include <iostream>
#include <string>

using namespace std;

int main() {
        const char* str = "aia";
        cout.operator<<(str);
        return 0;
}

Salida: 0x4007e0 .


El problema es que para algunos tipos el operator<< está sobrecargado como miembro de ostream y para algunos tipos está sobrecargado como una función global. En el caso de const char* es una función global, por lo que si desea llamar explícitamente a la función del operador, debe escribir

operator<<(cout, str);

pero para los tipos enteros debes escribir

cout.operator<<(num);

Lo que sucede en el código que publicó es que se llama a la sobrecarga de const void* , por lo que ve números hexadecimales.





c++14