Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Operatore di confronto definito per default

`= default` chiede al compilatore di generare l’implementazione di un operatore di confronto. Se definiti per default, `operator==` e `operator<=>` confrontano i sotto-oggetti della classe in un ordine definito: il primo verifica l’uguaglianza, il secondo determina l’ordinamento. Gli operatori secondari definiti per default, come `!=` e `<`, usano confronti riscritti anziché confrontare direttamente i sotto-oggetti.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

struct T {
    bool operator==(const T&) const = default;
    auto operator<=>(const T&) const = default;
};

Un Defaulted comparison operator è un operatore di confronto la cui implementazione viene generata dal compilatore tramite = default. Deve essere una funzione non template: una funzione membro non statica oppure una funzione friend di una classe. Una definizione con = default all’interno della classe deve essere la prima dichiarazione di quella funzione.

Il confronto esamina prima le classi base dirette e poi i membri dati non statici, nell’ordine di dichiarazione. Gli array vengono espansi nei loro elementi. operator== deve restituire bool e si ferma alla prima coppia disuguale. operator<=> confronta lessicograficamente: la prima coppia con un risultato di confronto diverso da zero determina il risultato. Perciò, nell’esempio, a < b è vero anche se 9 > 0.

Con auto operator<=>, il compilatore deduce la categoria di confronto comune dei sotto-oggetti: std::strong_ordering, std::weak_ordering oppure std::partial_ordering. Se la classe non dichiara esplicitamente un membro o una funzione friend chiamata operator==, un operator<=> definito per default all’interno della classe dichiara anche implicitamente un operator== definito per default. Definire per default solo operator== non fornisce un ordinamento.

Anche gli operatori secondari !=, <, <=, > e >= possono essere definiti per default; richiedono un risultato bool e una riscrittura valida del confronto, invece di confrontare i membri in modo indipendente. Nell’uso tipico, le espressioni usano una riscrittura basata su == o <=>, senza dichiarazioni separate di questi operatori.

= default non garantisce la validità: un confronto di sotto-oggetto inaccessibile o non supportato può far sì che l’operatore venga definito come eliminato. Questo vale anche per == e <=> nelle classi con membri dati di riferimento o membri variant delle union. Scrivi un’implementazione personalizzata se non tutti i sotto-oggetti devono contribuire al risultato.

Esempi

#include <compare>
#include <iostream>

struct Point {
    int x;
    int y;
    auto operator<=>(const Point&) const = default;
};

int main() {
    const Point a{1, 9};
    const Point b{2, 0};
    const Point c{1, 9};

    std::cout << std::boolalpha;
    std::cout << (a == c) << '\n';
    std::cout << (a != b) << '\n';
    std::cout << (a < b) << '\n';
}

Risultato

true
true
true

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti