Quebrar a mudança no C ++ 20 ou a regressão no clang-trunk / gcc-trunk ao sobrecarregar a comparação de igualdade com o valor de retorno não-booleano?

O código a seguir é compilado com clang-trunk no modo c ++ 17, mas é interrompido no modo c ++ 2a (próximo c ++ 20):

// Meta struct describing the result of a comparison
struct Meta {};

struct Foo {
    Meta operator==(const Foo&) {return Meta{};}
    Meta operator!=(const Foo&) {return Meta{};}
};

int main()
{
    Meta res = (Foo{} != Foo{});
}

Também compila bem com gcc-trunk ou clang-9.0.0: https://godbolt.org/z/8GGT78

O erro com clang-trunk e -std=c++2a:

<source>:12:19: error: use of overloaded operator '!=' is ambiguous (with operand types 'Foo' and 'Foo')
    Meta res = (f != g);
                ~ ^  ~
<source>:6:10: note: candidate function
    Meta operator!=(const Foo&) {return Meta{};}
         ^
<source>:5:10: note: candidate function
    Meta operator==(const Foo&) {return Meta{};}
         ^
<source>:5:10: note: candidate function (with reversed parameter order)

Eu entendo que o C ++ 20 tornará possível apenas sobrecarregar operator==e o compilador será gerado automaticamente operator!=negando o resultado de operator==. Tanto quanto eu entendo, isso só funciona enquanto o tipo de retorno é bool.

A fonte do problema é que em Eigen que declarar um conjunto de operadores ==, !=, <, ... entre Arrayobjectos ou Arraye escalares, que retornam (uma expressão de) uma matriz de bool(a qual pode então ser acedida elemento a elemento, ou de outro modo utilizados ) Por exemplo,

#include <Eigen/Core>
int main()
{
  Eigen::ArrayXd a(10);
  a.setRandom();
  return (a != 0.0).any();
}

Em contraste com o meu exemplo acima, isso ainda falha com o gcc-trunk: https://godbolt.org/z/RWktKs . Ainda não consegui reduzir isso a um exemplo que não é Eigen, que falha nos clang-trunk e no gcc-trunk (o exemplo na parte superior é bastante simplificado).

Relatório de problema relacionado: https://gitlab.com/libeigen/eigen/issues/1833

Minha pergunta real: isso é realmente uma mudança de quebra no C ++ 20 (e existe a possibilidade de sobrecarregar os operadores de comparação para retornar Meta-objetos) ou é mais provável uma regressão no clang / gcc?

O problema de Eigen parece reduzir ao seguinte:

using Scalar = double;

template<class Derived>
struct Base {
    friend inline int operator==(const Scalar&, const Derived&) { return 1; }
    int operator!=(const Scalar&) const;
};

struct X : Base<X> {};

int main() {
    X{} != 0.0;
}

Os dois candidatos à expressão são

1. o candidato reescrito de operator==(const Scalar&, const Derived&)
2. Base<X>::operator!=(const Scalar&) const

Por [over.match.funcs] / 4 , como operator!=não foi importado para o escopo Xpor uma declaração de uso , o tipo do parâmetro implícito do objeto para # 2 é const Base<X>&. Como resultado, o número 1 tem uma sequência de conversão implícita melhor para esse argumento (correspondência exata, em vez da conversão de derivada para base). A seleção de # 1 torna o programa mal formado.

Correções possíveis:

• Adicionar using Base::operator!=;a Derivedou
• Altere operator==para tirar um em const Base&vez de a const Derived&.

Sim, o código de fato quebra no C ++ 20.

A expressão Foo{} != Foo{}possui três candidatos no C ++ 20 (considerando que havia apenas um no C ++ 17):

Meta operator!=(Foo& /*this*/, const Foo&); // #1
Meta operator==(Foo& /*this*/, const Foo&); // #2
Meta operator==(const Foo&, Foo& /*this*/); // #3 - which is #2 reversed

Isso vem das novas regras de candidato reescritas em [over.match.oper] /3.4 . Todos esses candidatos são viáveis, já que nossos Fooargumentos não são const. Para encontrar o melhor candidato viável, precisamos passar por nossos desempates.

As regras relevantes para a melhor função viável são, de [over.match.best] / 2 :

Dadas essas definições, uma função viável F1é definida como uma função melhor do que outra função viável F2se, para todos os argumentos i, não for uma sequência de conversão pior que e, em seguida, ICSi(F1)ICSi(F2)

• [... muitos casos irrelevantes para este exemplo ...] ou, se não for isso, então
• F2 é um candidato reescrito ([over.match.oper]) e F1 não é
• F1 e F2 são candidatos reescritos, e F2 é um candidato sintetizado com ordem inversa de parâmetros e F1 não é

#2e #3são candidatos reescritos e #3inverte a ordem dos parâmetros, enquanto #1não é reescrito. Mas, para chegar a esse desempatador, precisamos primeiro passar pela condição inicial: para todos os argumentos, as seqüências de conversão não são piores.

#1é melhor do que #2porque todas as seqüências de conversão são iguais (trivialmente, porque os parâmetros de função são os mesmos) e #2é um candidato reescrito enquanto #1não é.

Mas ... ambos os pares #1/ #3e #2/ #3 ficam presos nessa primeira condição. Nos dois casos, o primeiro parâmetro tem uma melhor sequência de conversão para #1/ #2enquanto o segundo parâmetro tem uma melhor sequência de conversão para #3(o parâmetro constprecisa passar por uma constqualificação extra , para ter uma pior sequência de conversão). Este constflip-flop faz com que não possamos preferir nenhum deles.

Como resultado, toda a resolução de sobrecarga é ambígua.

Tanto quanto eu entendo, isso só funciona enquanto o tipo de retorno é bool.

Isso não está correto. Consideramos incondicionalmente candidatos reescritos e revertidos. A regra que temos é, de [over.match.oper] / 9 :

Se um operator==candidato reescrito for selecionado por resolução de sobrecarga para um operador @, seu tipo de retorno será cv bool

Ou seja, ainda consideramos esses candidatos. Mas se o melhor candidato viável é operator==aquele que retorna, digamos, Meta- o resultado é basicamente o mesmo que se esse candidato tivesse sido excluído.

Nós fez não quer estar em um estado onde a resolução de sobrecarga teria que considerar o tipo de retorno. E, de qualquer forma, o fato de o código retornar aqui Metaé irrelevante - o problema também existiria se ele retornasse bool.

Felizmente, a correção aqui é fácil:

struct Foo {
    Meta operator==(const Foo&) const;
    Meta operator!=(const Foo&) const;
    //                         ^^^^^^
};

Depois de criar os dois operadores de comparação const, não há mais ambiguidade. Todos os parâmetros são iguais, portanto, todas as seqüências de conversão são trivialmente iguais. #1agora venceria #3por não ser reescrita e #2agora venceria #3por não ser revertida - o que torna #1o melhor candidato viável. O mesmo resultado que tivemos no C ++ 17, apenas mais algumas etapas para chegar lá.

[over.match.best] / 2 lista como as sobrecargas válidas em um conjunto são priorizadas. A Seção 2.8 nos diz que F1é melhor do que F2se (entre muitas outras coisas):

F2é um candidato reescrito ([over.match.oper]) e F1não é

O exemplo lá mostra um explícito operator<sendo chamado mesmo que operator<=>esteja lá.

E [over.match.oper] /3.4.3 nos diz que a candidatura operator==nessas circunstâncias é um candidato reescrito.

No entanto , seus operadores esquecem uma coisa crucial: eles devem ser constfunções. E fazê-los não constfaz com que aspectos anteriores da resolução de sobrecarga entrem em cena. Nem função é uma correspondência exata, como não constPara- constconversões precisam acontecer para diferentes argumentos. Isso causa a ambiguidade em questão.

Depois de criá -los const, o Clang tronco é compilado .

Não posso falar com o resto de Eigen, pois não conheço o código, é muito grande e, portanto, não pode caber em um MCVE.

Temos problemas semelhantes com nossos arquivos de cabeçalho Goopax. Compilar o seguinte com clang-10 e -std = c ++ 2a produz um erro do compilador.

template<typename T> class gpu_type;

using gpu_bool     = gpu_type<bool>;
using gpu_int      = gpu_type<int>;

template<typename T>
class gpu_type
{
  friend inline gpu_bool operator==(T a, const gpu_type& b);
  friend inline gpu_bool operator!=(T a, const gpu_type& b);
};

int main()
{
  gpu_int a;
  gpu_bool b = (a == 0);
}

Fornecer esses operadores adicionais parece resolver o problema:

template<typename T>
class gpu_type
{
  ...
  friend inline gpu_bool operator==(const gpu_type& b, T a);
  friend inline gpu_bool operator!=(const gpu_type& b, T a);
};