Por que a desigualdade é testada como (! (A == b)) em muitos códigos de biblioteca padrão do C ++?

Este é o código do código da biblioteca padrão C ++ remove. Por que a desigualdade é testada em if (!(*first == val))vez de if (*first != val)?

 template <class ForwardIterator, class T>
      ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)
 {
     ForwardIterator result = first;
     while (first!=last) {
         if (!(*first == val)) {
             *result = *first;
             ++result;
         }
         ++first;
     }
     return result;
 }

Porque isso significa que o único requisito em T é implementar um operator==. Você pode exigir que T tenha uma, operator!=mas a idéia geral aqui é que você deve colocar o mínimo de carga possível sobre o usuário do modelo e outros modelos precisam operator==.

A maioria das funções no STL funciona apenas com operator<ou operator==. Isso requer que o usuário implemente apenas esses dois operadores (ou às vezes pelo menos um deles). Por exemplo, std::setusa operator<(mais precisamente o std::lessque chama operator<por padrão) e não operator>para gerenciar pedidos. O removemodelo no seu exemplo é um caso semelhante - ele usa apenas operator==e não, operator!=portanto operator!=, não precisa ser definido.

Este é o código do código de remoção da biblioteca padrão C ++.

Errado. Não é oremove código de biblioteca padrão do C ++ . É uma possível implementação interna da removefunção de biblioteca padrão C ++ . O padrão C ++ não prescreve código real; prescreve protótipos de função e comportamentos necessários.

Em outras palavras: Do ponto de vista estrito do idioma, o código que você está vendo não existe . Pode ser de algum arquivo de cabeçalho que acompanha a implementação da biblioteca padrão do seu compilador. Observe que o padrão C ++ nem exige que esses arquivos de cabeçalho existam. Os arquivos são apenas uma maneira conveniente para os implementadores de compiladores atenderem aos requisitos de uma linha como #include <algorithm>(por exemplo, disponibilização std::removee outras funções).

Por que a desigualdade é testada em if (!(*first == val))vez de if (*first != val)?

Porque somente operator==é requerido pela função.

Quando se trata de sobrecarga de operador para tipos personalizados, o idioma permite que você faça todos os tipos de coisas estranhas. Você pode muito bem criar uma classe que tenha uma sobrecarga, operator==mas não sobrecarregada operator!=. Ou pior: você pode sobrecarregar, operator!=mas fazer com que coisas completamente não relacionadas.

Considere este exemplo:

#include <algorithm>
#include <vector>

struct Example
{
    int i;

    Example() : i(0) {}

    bool operator==(Example const& other) const
    {
        return i == other.i;
    }

    bool operator!=(Example const& other) const
    {
        return i == 5; // weird, but nothing stops you
                       // from doing so
    }

};

int main()
{
  std::vector<Example> v(10);
  // ...
  auto it = std::remove(v.begin(), v.end(), Example());
  // ...
}

Se std::removeusado operator!=, o resultado seria bem diferente.

Algumas boas respostas aqui. Eu só queria adicionar uma pequena nota.

Como todas as boas bibliotecas, a biblioteca padrão é projetada com (pelo menos) dois princípios muito importantes em mente:

1. Coloque a menor quantidade de responsabilidade nos usuários da sua biblioteca com a qual você pode se safar. Parte disso tem a ver com oferecer o menor trabalho possível ao usar sua interface. (como definir o menor número possível de operadores). A outra parte tem a ver com não surpreendê-los ou exigir que eles verifiquem códigos de erro (portanto, mantenha as interfaces consistentes e crie exceções <stdexcept>quando as coisas dão errado).

2. Elimine toda redundância lógica . Todas as comparações podem ser deduzidas apenas a partir de operator<, então por que exigir que os usuários definam outras? por exemplo:

   (a> b) é equivalente a (b <a)

   (a> = b) é equivalente a! (a <b)

   (a == b) é equivalente a! ((a <b) || (b <a))

   e assim por diante.

   Obviamente, nesta nota, pode-se perguntar por que unordered_maprequer operator==(pelo menos por padrão) e não operator<. A resposta é que, em uma tabela de hash, a única comparação que exigimos é a igualdade. Portanto, é mais logicamente consistente (isto é, faz mais sentido para o usuário da biblioteca) exigir que ele defina um operador de igualdade. Exigir um operator<seria confuso, porque não é imediatamente óbvio por que você precisaria.

O EqualityComparableconceito requer apenas que operator==seja definido.

Conseqüentemente, qualquer função que professa trabalhar com tipos satisfatórios EqualityComparable não pode contar com a existência de operator!=objetos desse tipo. (a menos que haja requisitos adicionais que impliquem a existência de operator!=).

A abordagem mais promissora é encontrar um método para determinar se o operador == pode ser chamado para um tipo específico e, em seguida, apoiá-lo somente quando estiver disponível; em outras situações, uma exceção seria lançada. No entanto, até o momento não há maneira conhecida de detectar se uma expressão arbitrária do operador f == g está definida adequadamente. A melhor solução conhecida possui as seguintes qualidades indesejáveis:

• Falha no tempo de compilação para objetos em que o operador == não está acessível (por exemplo, porque é privado).
• Falha no tempo de compilação se o operador de chamada == for ambíguo.
• Parece estar correto se a declaração do operador == estiver correta, mesmo que o operador == possa não ser compilado.

Do Boost FAQ: fonte

Sabendo que exigir uma ==implementação é um fardo , você nunca deseja criar um ônus adicional ao exigir também a !=implementação.

Para mim, pessoalmente, é sobre o SOLID (projeto orientado a objetos) L parte - princípio de substituição de Liskov: "os objetos em um programa devem ser substituíveis por instâncias de seus subtipos sem alterar a correção desse programa". Nesse caso, é o operador ! = Que eu posso substituir por == e booleano inverso na lógica booleana.