Ei, pessoal. Estou portando algum código de um projeto amplamente desenvolvido no MSVS para usar o g ++. Eu encontrei muitas pequenas diferenças, principalmente coisas que o MSVS permite, mas o g ++ não. Normalmente, é algo que envolve padrões c ++, coisas que o MSVS permite deslizar, mas estou tendo problemas para ver exatamente o que há de errado em uma seção específica.

O g ++ está com problemas para corresponder uma chamada ao operador! =, mas apenas em um contexto específico. Procurando o operador! = Para uma classe aninhada específica funciona se a classe de hospedagem não for um modelo. Se eu transformar a classe de hospedagem em um modelo de classe, no entanto, tudo quebra. Ou estou faltando algo fundamental para c ++, ou g ++ está fazendo algo errado.

Eu aprendi a não chorar "Bug do compilador!" com muita frequência, então eu queria ver se alguém aqui pode ver o que estou perdendo.

Este exemplo trabalhado mostra a versão funcional, não modelo, e a versão quebrada, modelo. A versão dá: g ++ (Ubuntu 4.4.1-4ubuntu9) 4.4.1

Versão de referência de trabalho sem modelos

namespace Works {

struct host {
    struct iterator {};
    iterator op();
};

bool operator != (host::iterator const& a0, host::iterator const& a1);

bool f() {
    return host().op() != host().op();
}

} // namespace Works

Versão quebrada com modelos

namespace Broken {

template <typename T>
struct host {
    struct iterator {};
    iterator op();
};

template <typename T>
bool operator != (typename host<T>::iterator const& a0, 
                   typename host<T>::iterator const& a1);

bool f() {
    return host<int>().op() != host<int>().op();
}

} // namespace Broken

A versão do modelo falha com os erros:

Main.cpp: In function ‘bool Broken::f()’:
Main.cpp:50: error: no match for ‘operator!=’ in ‘Broken::host<int>().Broken::host<T>::op [with T = int]() != Broken::host<int>().Broken::host<T>::op [with T = int]()’