CKTIS / C++
explicit — controlar las conversiones implícitas
El especificador explicit restringe el uso de constructores y funciones de conversión en conversiones implícitas, sin impedir la creación deliberada de objetos. Aprende la diferencia entre inicialización directa y por copia, el papel especial de operator bool y el uso de explicit(condition).
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
explicit ClassName(parameters);
explicit operator TargetType() const;
explicit(condition) ClassName(parameters);
explicit(condition) operator TargetType() const;explicit ayuda a restringir las conversiones definidas por el usuario que podrían ser involuntarias. Puede marcar un constructor o una función de conversión dentro de la definición de una clase; no es un especificador para funciones ordinarias. También puede aparecer en guías de deducción de argumentos de plantillas de clase. explicit sin condición significa explicit(true).
Para un constructor explicit Count(int), tanto Count a(3); como Count b{3}; son inicializaciones directas válidas. Count c = 3; no es válido porque la inicialización por copia no utiliza ese constructor para convertir. Count d = {3}; tampoco es válido si la inicialización por lista con copia selecciona un constructor explicit. Del mismo modo, una función que recibe un Count no puede aceptar directamente 3, pero sí puede recibir Count{3}. El especificador no se limita a constructores de un solo parámetro.
Una función de conversión explicit operator bool() const impide bool e = a;, pero permite static_cast<bool>(a) y la inicialización directa bool e(a);. Las condiciones booleanas son una excepción importante: if (a) puede usar este operador porque la conversión contextual a bool comprueba si es posible la inicialización directa. Esto no permite las conversiones implícitas de forma general.
En C++23, explicit(condition) sigue reglas más estrictas que una condición if ordinaria: el resultado de la conversión contextual a bool debe ser una expresión constante y la secuencia solo puede contener conversiones permitidas, sin conversiones de estrechamiento. Por ejemplo, 2 es una expresión constante y puede usarse como condición en if (2), pero explicit(2) no es válido porque la conversión de 2 a bool es de estrechamiento. El valor true activa explicit; false deja la declaración sin explicit. No es un interruptor en tiempo de ejecución. Es útil en plantillas cuando la convertibilidad implícita depende del tipo. El ejemplo utiliza el modo C++23. Las fuentes presentan un borrador de trabajo en evolución, no una publicación definitiva de C++23.
Ejemplos
#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
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.