Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

explicit — riadenie implicitných konverzií

Špecifikátor explicit obmedzuje používanie konštruktorov a konverzných funkcií pri implicitných konverziách, no umožňuje zámerné vytváranie objektov. Spoznajte rozdiel medzi priamou inicializáciou a inicializáciou kopírovaním, osobitnú úlohu operator bool a podmienené explicit(condition).

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

Syntax

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

explicit pomáha obmedziť nechcené používateľom definované konverzie. Môže označovať konštruktor alebo konverznú funkciu v definícii triedy; nie je to špecifikátor pre bežné funkcie. Môže sa objaviť aj pri dedukčných vodidlách pre šablóny tried. Samotné explicit znamená explicit(true).

Pri konštruktore explicit Count(int) sú Count a(3); aj Count b{3}; platné priame inicializácie. Count c = 3; je neplatné, pretože inicializácia kopírovaním tento konštruktor na konverziu nepoužije. Neplatné je aj Count d = {3};, ak inicializácia zoznamom kopírovaním vyberie konštruktor explicit. Funkcia, ktorá prijíma Count, podobne nemôže prijať samotné 3, ale môže dostať Count{3}. Špecifikátor sa neobmedzuje na konštruktory s jedným parametrom.

Konverzná funkcia explicit operator bool() const zakazuje bool e = a;, ale povoľuje static_cast<bool>(a) a priamu inicializáciu bool e(a);. Dôležitou výnimkou sú booleovské podmienky: if (a) môže použiť tento operátor, pretože kontextová konverzia na bool overuje, či je možná priama inicializácia. Vo všeobecnosti to však implicitné konverzie nepovoľuje.

V C++23 platia pre explicit(condition) prísnejšie pravidlá než pre bežnú podmienku if: výsledkom kontextovej konverzie na bool musí byť konštantný výraz a postupnosť konverzií smie obsahovať len povolené konverzie, nie zužujúce. Napríklad 2 je konštantný výraz a možno ho použiť ako podmienku v if (2), ale explicit(2) je neplatné, pretože konverzia hodnoty 2 na bool je zužujúca. Hodnota true zapína explicit; hodnota false ponecháva deklaráciu neexplicitnú. Nie je to prepínač za behu. Je to užitočné v šablónach, keď implicitná konvertibilita závisí od typu. Príklad používa režim C++23. Zdroje predstavujú vyvíjajúci sa pracovný návrh, nie ustálené vydanie C++23.

Príklady

#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';
}

Výsledok

3
false

Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.

Zdroje