Por que #include <string> está impedindo um erro de estouro de pilha aqui?

Este é o meu código de exemplo:

#include <iostream>
#include <string>
using namespace std;

class MyClass
{
    string figName;
public:
    MyClass(const string& s)
    {
        figName = s;
    }

    const string& getName() const
    {
        return figName;
    }
};

ostream& operator<<(ostream& ausgabe, const MyClass& f)
{
    ausgabe << f.getName();
    return ausgabe;
}

int main()
{
    MyClass f1("Hello");
    cout << f1;
    return 0;
}

Se eu comentar #include <string>, não obtenho nenhum erro do compilador, acho que é meio que incluído #include <iostream>. Se eu clicar com o botão direito do mouse -> Ir para definição no Microsoft VS, ambos apontam para a mesma linha no xstringarquivo:

typedef basic_string<char, char_traits<char>, allocator<char> >
    string;

Mas quando executo meu programa, recebo um erro de exceção:

0x77846B6E (ntdll.dll) no OperatorString.exe: 0xC00000FD: estouro de pilha (parâmetro: 0x00000001, 0x01202FC4)

Alguma idéia de por que recebo um erro de tempo de execução ao comentar #include <string>? Estou usando o VS 2013 Express.

De fato, comportamento muito interessante.

Alguma idéia de por que recebo um erro de tempo de execução ao comentar #include <string>

Com o compilador MS VC ++, o erro ocorre porque, caso contrário, #include <string>você não terá operator<<definido std::string.

Quando o compilador tenta compilar, ausgabe << f.getName();ele procura por um operator<<definido std::string. Como não foi definido, o compilador procura alternativas. Existe um operator<<definido para MyClasse o compilador tenta usá-lo, e para usá-lo, ele deve ser convertido std::stringem MyClasse é exatamente isso que acontece porque MyClasstem um construtor não explícito! Portanto, o compilador acaba criando uma nova instância sua MyClasse tenta transmiti-la novamente para o fluxo de saída. Isso resulta em uma recursão infinita:

 start:
     operator<<(MyClass) -> 
         MyClass::MyClass(MyClass::getName()) -> 
             operator<<(MyClass) -> ... goto start;

Para evitar o erro, você precisa #include <string>garantir que haja um operator<<definido para std::string. Você também deve MyClassexplicitar seu construtor para evitar esse tipo de conversão inesperada. Regra de sabedoria: torne os construtores explícitos se eles tiverem apenas um argumento para evitar a conversão implícita:

class MyClass
{
    string figName;
public:
    explicit MyClass(const string& s) // <<-- avoid implicit conversion
    {
        figName = s;
    }

    const string& getName() const
    {
        return figName;
    }
};

Parece que operator<<para std::stringrecebe apenas definido quando <string>está incluído (com o compilador MS) e por isso tudo compila, no entanto você tem um comportamento um tanto inesperado, como operator<<está sendo chamado de forma recursiva para MyClassem vez de chamar operator<<para std::string.

Isso significa que a #include <iostream>cadeia de caracteres é incluída apenas parcialmente?

Não, a string está totalmente incluída, caso contrário você não poderá usá-la.

O problema é que seu código está fazendo uma recursão infinita. O operador de streaming para std::string( std::ostream& operator<<(std::ostream&, const std::string&)) é declarado no <string>arquivo de cabeçalho, embora std::stringele próprio seja declarado em outro arquivo de cabeçalho (incluído por ambos <iostream>e <string>).

Quando você não inclui, <string>o compilador tenta encontrar uma maneira de compilar ausgabe << f.getName();.

Acontece que você definiu um operador de streaming para MyClasse um construtor que admite a std::string; portanto, o compilador o usa (por meio de construção implícita ), criando uma chamada recursiva.

Se você declarar explicitseu construtor ( explicit MyClass(const std::string& s)), seu código não será mais compilado, pois não há como chamar o operador de streaming std::stringe você será forçado a incluir o <string>cabeçalho.

EDITAR

Meu ambiente de teste é o VS 2010 e, iniciando no nível de aviso 1 ( /W1), avisa sobre o problema:

aviso C4717: 'operator <<': recursivo em todos os caminhos de controle, a função causará estouro da pilha de tempo de execução