Início / coding / Perguntas / 79183960
Accepted
mgr
Asked: 2024-11-13 16:18:36 +0800 CST

Por que os operadores de comparação explicitamente padrão são excluídos quando a classe contém um membro de referência?

  • 772

Tentei usar ambos como padrão operator==em operator<=>uma classe simples que contém um membro de referência como este:

#include <iostream>
#include <string>

class Simple
{
public:
    Simple(const std::string& data)
     : data_(data)
    {
    }

    auto operator<=>(const Simple&) const = default;

private:
    const std::string& data_;
};

int main(int argc, char** argv)
{
    std::string str1 = "one";
    Simple s1(str1);
    std::string str2 = "two";
    Simple s2(str2);
    std::cout << (s1 < s2) << std::endl; // compiler error

    return 0;
}

O compilador clang afirma que

warning: explicitly defaulted three-way comparison operator is implicitly deleted
note: defaulted 'operator<=>' is implicitly deleted because class 'Simple' has a reference member

Não recebi nenhum aviso de outros compiladores (por exemplo, MSVC), mas quando tento usá-lo, recebo erros de compilação:

<source>(62): error C2280: 'auto Simple::operator <=>(const Simple &) const': attempting to reference a deleted function
<source>(49): note: see declaration of 'Simple::operator <=>'
<source>(49): note: 'auto Simple::operator <=>(const Simple &) const': function was implicitly deleted because 'Simple' data member 'Simple::data_' of type 'const std::string &' is a reference type
<source>(52): note: see declaration of 'Simple::data_'

Outras funções padrão, como atribuição de cópia, serão excluídas, porque não são possíveis com um membro de referência.

Mas por que o conteúdo de uma referência não pode ser comparado automaticamente?

E qual é o caminho mais curto para implementá-lo manualmente?

c++

3 respostas

  1. O artigo P1603R1 especifica que os membros de referência devem levar a operadores de comparação excluídos, dizendo que isso está de acordo com o artigo P0515:

    O P0515 expõe claramente a intenção do projeto como comparação após cópia, ênfase minha:

    Esta proposta unifica e regulariza as partes não controversas de propostas anteriores e incorpora a orientação do EWG de buscar a comparação tripla, permitindo que a cópia padrão guie a comparação padrão e tenha uma maneira simples de escrever um corpo de função de comparação por membro.

    O artigo continua dizendo (desta vez a ênfase é minha):

    É a regra mais segura por enquanto e é mais consistente com a intenção do projeto, conforme estabelecido em P0515.

    Ou seja, a escolha mais segura foi feita e, se houver motivação suficiente para uma mudança de regras, uma mudança poderá ser feita.

    • 6

  2. Os membros de referência de fato impedem que o compilador gere os operadores de comparação padrão , porque você pode comparar o conteúdo ao qual a referência se refere ou os endereços.

    qual é o caminho mais curto para implementá-lo manualmente?

    Você pode implementar operator<=>manualmente da seguinte maneira:

    auto operator<=>(const Simple& other) const
{
    return data_ <=> other.data_;
}

    Demonstração do Godbolt .

    Você pode implementar de forma semelhante operator==para verificar a igualdade.

    • 3
  3. Best Answer

    O problema aqui é que operator<=>e operator==não pode ser padronizado em classes com membros de referência porque as implementações padrão dependem da comparação direta de todos os membros de dados. No entanto, referências não suportam atribuição de cópia ou operações de movimentação, então o compilador não pode sintetizar esses operadores quando referências estão envolvidas.

    Quando o compilador tenta usar o operator<=>, ele tenta comparar cada membro individualmente. Mas como data_é uma referência, ele não tem um valor próprio — ele apenas aponta para outro objeto, então o compilador não pode executar comparações diretas como faria para um tipo de valor. É por isso que o operador de comparação é implicitamente excluído.

    Você precisará implementar operator==e operator<=>comparar manualmente o objeto ao qual os pontos de referência apontam, em vez da referência em si. Veja como você pode fazer isso:

    #include <string>
#include <iostream>
#include <compare>

class Simple
{
public:
    Simple(const std::string& data)
        : data_(data)
    {
    }

    bool operator==(const Simple& other) const
    {
        return data_ == other.data_;
    }

    auto operator<=>(const Simple& other) const
    {
        return data_ <=> other.data_;
    }

private:
    const std::string& data_;
};

int main()
{
    std::string str1 = "one";
    Simple s1(str1);
    std::string str2 = "two";
    Simple s2(str2);
    
    std::cout << (s1 < s2) << std::endl;  // Works now

    return 0;
}

    1. operator==: Definimos manualmente operator==para comparar data_em s1e s2por meio da comparação dos objetos aos quais eles fazem referência.

    2. operator<=>: Similarmente, definimos manualmente operator<=>para comparar data_em s1e s2usando operator<=>on std::string. Como data_é uma referência, data_ <=> other.data_realiza uma comparação entre os std::stringobjetos aos quais as referências apontam.

    Como referências não são valores em si, elas precisam ser comparadas pelos objetos aos quais fazem referência. Esta implementação manual contorna a incapacidade do compilador de usar default operator==e operator<=>para tipos com membros de referência. Esta é a maneira mais curta e limpa de lidar com a situação sem alterar o design da classe.

    • 0

relate perguntas