Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

explicit — controllare le conversioni implicite

Lo specificatore explicit limita l’uso di costruttori e funzioni di conversione nelle conversioni implicite, pur consentendo di creare oggetti in modo intenzionale. Scopri la differenza tra inizializzazione diretta e per copia, il ruolo particolare di operator bool e explicit(condition).

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

Sintassi

explicit ClassName(parameters);
explicit operator TargetType() const;
explicit(condition) ClassName(parameters);
explicit(condition) operator TargetType() const;

explicit aiuta a limitare le conversioni definite dall’utente non intenzionali. Può contrassegnare un costruttore o una funzione di conversione all’interno della definizione di una classe; non è uno specificatore per le funzioni ordinarie. Può comparire anche nelle guide di deduzione dei parametri di una classe template. explicit senza condizione significa explicit(true).

Per un costruttore explicit Count(int), sia Count a(3); sia Count b{3}; sono inizializzazioni dirette valide. Count c = 3; non è valido, perché l’inizializzazione per copia non usa quel costruttore per la conversione. Anche Count d = {3}; non è valido se l’inizializzazione con lista e per copia seleziona un costruttore explicit. Analogamente, una funzione che accetta un Count non può ricevere direttamente 3, ma può ricevere Count{3}. Lo specificatore non è limitato ai costruttori con un solo parametro.

Una funzione di conversione explicit operator bool() const impedisce bool e = a;, ma consente static_cast<bool>(a) e l’inizializzazione diretta bool e(a);. Le condizioni booleane sono un’eccezione importante: if (a) può usare questo operatore perché la conversione contestuale a bool verifica se è possibile l’inizializzazione diretta. Questo non abilita in generale le conversioni implicite.

In C++23, explicit(condition) segue regole più restrittive di una normale condizione if: il risultato della conversione contestuale a bool deve essere un’espressione costante e la sequenza può contenere solo conversioni ammesse, senza conversioni di restringimento. Per esempio, 2 è un’espressione costante e può essere usata come condizione in if (2), ma explicit(2) non è valido perché la conversione da 2 a bool è una conversione di restringimento. Il valore true attiva explicit; false lascia la dichiarazione non esplicita. Non è un interruttore a runtime. È utile nei template quando la convertibilità implicita dipende dal tipo. L’esempio usa la modalità C++23. Le fonti presentano una bozza di lavoro in evoluzione, non una pubblicazione C++23 definitiva.

Esempi

#include <iostream>
#include <type_traits>

struct Count {
    int value;
    explicit Count(int n) : value(n) {}
    explicit operator bool() const { return value != 0; }
};

static_assert(std::is_constructible_v<Count, int>);
static_assert(!std::is_convertible_v<int, Count>);
static_assert(!std::is_convertible_v<Count, bool>);

int main() {
    Count a(3);
    Count b{0};
    // Count c = 3;
    // Count d = {3};
    // bool e = a;
    if (a) {
        std::cout << a.value << '\n';
    }
    std::cout << std::boolalpha << static_cast<bool>(b) << '\n';
}

Risultato

3
false

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