Início / coding / Perguntas / 77482504
Accepted
edrezen
Asked: 2023-11-15 01:02:45 +0800 CST

Sobrecarregar um operador de uma estrutura dentro de uma estrutura de modelo

  • 772

Eu tenho uma estrutura de modelo Fooque define uma estrutura interna Bar.

Agora, gostaria de sobrecarregar o fluxo operator <<para esta struct interna Bar, mas o compilador parece ignorar minha implementação de sobrecarga:

erro: nenhuma correspondência para 'operator<<' (os tipos de operando são 'std::ostream' {também conhecido como 'std::basic_ostream<char>'} e 'Foo<3>::Bar')

Meu código é o seguinte:

#include <iostream>

//////////////////////////////////////////////////////////////////////////////////////////
template<int N>
struct Foo
{
    struct Bar  {};
};

//////////////////////////////////////////////////////////////////////////////////////////
template<int N>
std::ostream& operator<< (std::ostream& os, const typename Foo<N>::Bar& x)
{
    return os;
}

//////////////////////////////////////////////////////////////////////////////////////////
int main (int argc, char** argv)
{
    Foo<3>::Bar x;

    std::cout << x << std::endl;
}

Não consigo ver o erro (talvez óbvio).

Pergunta É possível sobrecarregar um operador de uma estrutura interna que pertence a uma classe template?

c++

2 respostas

  1. Best Answer

    Sim como isso:

    #include <iostream>

template<int N>
struct Foo
{
    struct Bar  {
        friend std::ostream& operator<<(std::ostream& os,const Bar&) { return os;}
    };
};

int main (int argc, char** argv)
{
    Foo<3>::Bar x;

    std::cout << x << std::endl;
}

    No seu código, isso operator<<não está realmente errado. É simplesmente impossível Ndeduzir Foo<N>::Bar. Você só pode chamá-lo explicitando N:

    int main (int argc, char** argv)
{
    Foo<3>::Bar x;
    operator<<<3>(std::cout,x);
}

    Demonstração ao vivo .

    A razão é que Foo<N>::Baré um contexto não deduzido. Consulte O que é um contexto não deduzido? para mais detalhes. Resumindo, a razão pela qual isso não funciona é que não existe uma relação 1:1 entre Foo<N>::Bare N. Considere que você adiciona uma especialização:

    template <> struct Foo<42> {
      using Bar = Foo<3>::Bar;
};

    Agora Foo<42>::Bare Foo<3>::Barconsulte exatamente o mesmo tipo. Esse

    Foo<3>::Bar x;
std::cout << x;

    e isto

    Foo<42>::Bar x;
std::cout << x;

    teria que deduzir valores diferentes, Nmas em ambos os exemplos xé exatamente do mesmo tipo.

    • 5

  2. Você quer dizer algo assim? Com classes de modelo geralmente é mais fácil declarar sobrecargas de amigos dentro do modelo (demonstração aqui: https://onlinegdb.com/NqTLD6_tU )

    #include <iostream>

template<int N>
struct Foo
{
    struct Bar
    { 
        int x{N};
    };
    
    // friend if you need access to a private member
    friend std::ostream& operator<<(std::ostream& os, const Foo<N>::Bar& bar)
    {
        os << bar.x;
        return os;
    }

private:
    Bar b; 
};

int main (int argc, char** argv)
{
    Foo<3>::Bar x;
    std::cout << x << "\n";
}
    • 2

relate perguntas