c++ - libreria - ¿Es seguro usar operator!=As operator<en un estándar:: set?

sort algorithm c++

Question

Tengo una estructura con algunos miembros y tengo un operador implementado == para ello. ¿Es seguro implementar el operador <con la ayuda del operador ==? Quiero usar esta estructura en un conjunto, y quiero verificar que esta estructura sea única.

struct Data
{
  std::string str1;
  std::string str2;
  std::string str3;
  std::string str4;

  bool operator==(const Data& rhs)
  {
    if (str1 == rhs.str1
     && str2 == rhs.str2
     && str3 == rhs.str3
     && str4 == rhs.str4
       )
      return true;
    else
      return false;
  }

  // Is this ok??
  bool operator<(const Data& rhs)
  {
    return !this->operator==(rhs);
  }
}

Entonces, cuando inserto esta estructura en un estándar, ¿qué pasará?

Answer 1

Bueno, tu código sugiere que si A!=B , eso significa que A<B es definitivamente incorrecto, ya que también puede ser A>B

Tendrá que implementar sus operadores > y < la misma manera que lo hizo con el operator== , lo que significa al comparar los objetos en forma de miembro. Depende de usted decidir cómo determinar si A es "más" o "menos" que B según sus miembros.

Si usa el operador como lo tiene en cualquiera de los contenedores de biblioteca estándar, obtendrá UB.

Answer 2

Necesita definir operator< en sus propios términos. No puede implementar operator< en términos de operator== , aunque puede hacer lo contrario.

Considera la paradoja en esta tabla de verdad:

"a" < "b" : TRUE
"b" < "a" : TRUE

Si su implementación de operator< produce la paradoja anterior, que lo hace si la implementa en términos de operator== entonces no ha implementado correctamente un orden débil estricto. Lo que has implementado es un desastre.

Debe determinar cuál de las cadenas miembro tiene prioridad sobre las demás, y luego realizar una comparación entre ellas en orden, de mayor a menor importancia.

Por ejemplo, si la precedencia de la cadena es, de lo más importante a lo menos importante:

1. str1
2. str2
3. str3
4. str4

... entonces esto produce el siguiente algoritmo para el operator< :

bool operator<(const Data& rhs) const
{
  if( str1 < rhs.str1 )
    return true;
  if( rhs.str1 < str1 )
    return false;
  if( str2 < rhs.str2 )
    return true;
  if( rhs.str2 < str2 )
    return false;
  if( str3 < rhs.str3 )
    return true;
  if( rhs.str3 < str3 )
    return false;
  if( str4 < rhs.str4 )
    return true;
  if( rhs.str4 < str4 )
    return false;

  return false;
}

Utilizando esto, podría opcionalmente volver a implementar operator== en términos de operator< . Sin embargo, usted asume la ineficiencia inherente de la complejidad del tiempo al hacerlo:

bool operator==(const Data& rhs) const
{
  return !operator<(rhs) && !rhs.operator<(*this);
}

Answer 3

No, es bastante inseguro. La forma más sencilla de implementarlo es a través de std::tie .

#include <tuple>
struct Data
{
  std::string str1;
  std::string str2;
  std::string str3;
  std::string str4;

  bool operator<(const Data& rhs) const // you forgot a const
  {
      return 
      std::tie(str1, str2, str3, str4) < 
      std::tie(rhs.str1, rhs.str2, rhs.str3, rhs.str4);
  }
}

Answer 4

No, eso no es seguro. La forma en que ha definido < , a < b y b < a serán ambas verdaderas al mismo tiempo.

Entonces, cuando inserto esta estructura en un estándar, ¿qué pasará?

El comportamiento no está definido, por lo que todo está permitido, y es probable que sea diferente en diferentes implementaciones.