Perché operator! = Rimosso in C ++ 20 per molti tipi di librerie standard?

Secondo cppreference , std::type_info::operator!=viene rimosso con C ++ 20, tuttavia, a std::type_info::operator==quanto pare rimane.

Qual è il ragionamento dietro? Potrei essere d'accordo sul fatto che il confronto per l'ineguaglianza sia privo di significato, ma poi il confronto per l'uguaglianza sarebbe altrettanto insignificante, no?

Allo stesso modo, operator!=di molti altri tipi di librerie standard, inclusi contenitori come std::unordered_map::operator!=e std::unordered_set::operator!=verranno rimossi in C ++ 20 secondo cppreference.

Dover scrivere if(!(id1 == id2))non rende alcun codice più chiaro rispetto if(id1 != id2), al contrario, al contrario ...

In C ++ 20 è stato modificato il modo in cui funzionano gli operatori relazionali, in particolare con l'introduzione <=>dell'operatore di astronave . In particolare, se si fornisce solo operator==, a != bviene riscritto !(a == b).

Da [over.match.oper] /3.4 :

Il set di candidati riscritto è determinato come segue:

• Per gli operatori relazionali ([expr.rel]), i candidati riscritti includono tutti i candidati non riscritti per l'espressione x <=> y.
• Per gli operatori relazionali ([expr.rel]) e di confronto a tre vie ([expr.spaceship]), i candidati riscritti includono anche un candidato sintetizzato, con l'ordine dei due parametri invertiti, per ciascun candidato non riscritto per il espressione y <=> x.
• Per l'operatore! = ([Expr.eq]), i candidati riscritti includono tutti i candidati non riscritti per l'espressione x == y.
• Per gli operatori di uguaglianza, i candidati riscritti includono anche un candidato sintetizzato, con l'ordine dei due parametri invertiti, per ciascun candidato non riscritto per l'espressione y == x.
• Per tutti gli altri operatori, il set di candidati riscritto è vuoto.

E [over.match.oper] / 9 :

Se un operatore riscritto == candidato viene selezionato per risoluzione di sovraccarico per un operatore @, il suo tipo di ritorno deve essere cv bool e x @ y viene interpretato come:

• se @ è! = e il candidato selezionato è un candidato sintetizzato con ordine inverso di parametri,! (y == x),
• altrimenti, se @ è! =,! (x == y) ,
• altrimenti (quando @ è ==), y == x,

in ogni caso utilizzando l'operatore riscritto selezionato == candidato.

Pertanto, operator!=non è più necessario un sovraccarico esplicito per . La rimozione dell'operatore non ha modificato la semantica di confronto.

operator!=Per quanto ne so, tutti i contenitori sono stati rimossi (controllare ad esempio la sinossi vettoriale ). Le uniche eccezioni sono gli adattatori per container std::queuee std::stack: la mia ipotesi è che sia per preservare la compatibilità con le versioni precedenti quando utilizzato con container di terze parti, nel caso in cui gli operatori di uguaglianza non siano simmetrici.

Non abbiamo più bisogno di una biblioteca operator!=. Fornire operator==consente al compilatore di fare un po 'di giocoleria e valutare a != bin termini a == b, tutto da solo.

[Over.match.oper]

3 Per un operatore unario @ con un operando di un tipo la cui versione non qualificata cv è T1, e per un operatore binario @ con un operando di sinistra del tipo la cui versione non qualificata cv è T1 e un operando di destra di un tipo il cui cv- la versione non qualificata è T2, quattro serie di funzioni candidate, candidati membri designati, candidati non membri, candidati incorporati e candidati riscritti, sono costruiti come segue:

3.4.3 Per l'operatore! = ([Expr.eq]), i candidati riscritti includono tutti i candidati non riscritti per l'espressione x == y.

std::type_infoe molti altri tipi di librerie furono operator!=rimossi come parte di P1614 - La nave madre è atterrata .