База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / C++

explicit — управление на неявните преобразувания

Спецификаторът explicit ограничава използването на конструктори и преобразуващи функции при неявни преобразувания, като същевременно позволява умишлено създаване на обекти. Научете разликата между пряка и копираща инициализация, особената роля на operator bool и условния explicit(condition).

Версия: C++23; repository compiler flag, production runtime not attested

Синтаксис

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

explicit помага да се ограничат нежеланите преобразувания, дефинирани от потребителя. С този спецификатор може да се обозначи конструктор или преобразуваща функция като явни в дефиницията на клас; той не се използва за обикновени функции. Може да се среща и при ръководства за извеждане на аргументи на шаблони на класове. Самостоятелното explicit означава explicit(true).

За конструктор explicit Count(int) и Count a(3);, и Count b{3}; са валидни преки инициализации. Count c = 3; е невалидно, защото копиращата инициализация не използва този конструктор за преобразуването. Невалидно е и Count d = {3};, ако копиращата инициализация със списък избере конструктор explicit. По същия начин функция, която приема Count, не може да приеме само 3, но може да получи Count{3}. Спецификаторът не се ограничава до конструктори с един параметър.

Преобразуваща функция explicit operator bool() const забранява bool e = a;, но позволява static_cast<bool>(a) и пряка инициализация bool e(a);. Булевите условия са важно изключение: if (a) може да използва този оператор, защото контекстуалното преобразуване към bool проверява дали пряката инициализация е възможна. Това не разрешава неявни преобразувания като общо правило.

В C++23 за explicit(condition) важат по-строги правила, отколкото за обикновено условие в if: резултатът от контекстуалното преобразуване към bool трябва да е константен израз, а последователността може да включва само разрешени преобразувания, без стесняващи преобразувания. Например 2 е константен израз и може да се използва като условие в if (2), но explicit(2) е невалидно, защото преобразуването на 2 към bool е стесняващо. При true спецификаторът explicit се прилага, а при false декларацията се държи така, сякаш този спецификатор липсва. Това не е превключвател по време на изпълнение. Полезно е в шаблони, когато неявната преобразуемост зависи от типа. Примерът използва режим C++23. Източниците представят развиващ се работен проект, а не окончателно издание на C++23.

Примери

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

Резултат

3
false

Показаният код и заявеният резултат са проверени в изолирана среда по метода, записан в доказателството за проверка на тази точна версия.

Източници