Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

explicit — controlar conversões implícitas

O especificador explicit restringe a utilização de construtores e funções de conversão em conversões implícitas, sem impedir a criação deliberada de objetos. Aprende a diferença entre inicialização direta e por cópia, o papel especial de operator bool e explicit(condition).

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

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

explicit ajuda a restringir conversões definidas pelo utilizador que poderiam ser involuntárias. Pode marcar um construtor ou uma função de conversão numa definição de classe; não é um especificador para funções comuns. Também pode aparecer em guias de dedução de argumentos de modelos de classe. explicit sem condição significa explicit(true).

Para um construtor explicit Count(int), tanto Count a(3); como Count b{3}; são inicializações diretas válidas. Count c = 3; é inválido, porque a inicialização por cópia não utiliza esse construtor para a conversão. Count d = {3}; também é inválido se a inicialização por lista com cópia selecionar um construtor explicit. Do mesmo modo, uma função que recebe um Count não pode aceitar diretamente 3, mas pode receber Count{3}. O especificador não se limita a construtores com um único parâmetro.

Uma função de conversão explicit operator bool() const impede bool e = a;, mas permite static_cast<bool>(a) e a inicialização direta bool e(a);. As condições booleanas são uma exceção importante: if (a) pode utilizar este operador porque a conversão contextual para bool verifica se a inicialização direta é possível. Isto não permite conversões implícitas em geral.

Em C++23, explicit(condition) obedece a regras mais restritivas do que uma condição if normal: o resultado da conversão contextual para bool tem de ser uma expressão constante e a sequência só pode incluir conversões permitidas, sem conversões de estreitamento. Por exemplo, 2 é uma expressão constante e pode servir de condição em if (2), mas explicit(2) é inválido porque a conversão de 2 para bool é uma conversão de estreitamento. O valor true ativa explicit; false deixa a declaração não explícita. Não é um interruptor em tempo de execução. É útil em modelos quando a convertibilidade implícita depende do tipo. O exemplo utiliza o modo C++23. As fontes apresentam um projeto de trabalho em evolução, não uma publicação C++23 definitiva.

Exemplos

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

Resultado

3
false

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes