Namespaces
Variants

explicit specifier

From cppreference.net
C++
C++ language
General topics
Flow control
Conditional execution statements
Iteration statements (loops)
Jump statements
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications ( until C++17* )
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Memory allocation
Classes
Class-specific function properties
explicit (C++11)
static

Special member functions
Templates
Miscellaneous
Classes

Table des matières

Syntaxe

explicit (1)
explicit ( expression ) (2) (depuis C++20)
expression - expression constante contextuellement convertie de type bool


1) Spécifie qu'un constructeur ou une fonction de conversion (depuis C++11) ou un guide de déduction (depuis C++17) est explicite, c'est-à-dire qu'il ne peut pas être utilisé pour les conversions implicites et l' initialisation par copie .
2) Le spécificateur explicit peut être utilisé avec une expression constante. La fonction est explicite si et seulement si cette expression constante évalue à true .
(depuis C++20)

Le spécificateur explicit peut uniquement apparaître dans la decl-specifier-seq de la déclaration d'un constructeur ou d'une fonction de conversion (depuis C++11) dans sa définition de classe.

Notes

Un constructeur avec un seul paramètre non par défaut (jusqu'au C++11) qui est déclaré sans le spécificateur de fonction explicit est appelé constructeur de conversion .

Les deux constructeurs (autres que les copy / move ) et les fonctions de conversion définies par l'utilisateur peuvent être des modèles de fonction ; la signification de explicit ne change pas.

Un jeton ( qui suit explicit est toujours analysé comme faisant partie du spécificateur explicite : 

struct S
{
    explicit (S)(const S&);    // error in C++20, OK in C++17
    explicit (operator int)(); // error in C++20, OK in C++17
};
 (depuis C++20)
Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_conditional_explicit 201806L (C++20) explicit conditionnel

Mots-clés

explicit

Exemple

Exécuter ce code 
struct A
{
    A(int) {}      // constructeur de conversion
    A(int, int) {} // constructeur de conversion (C++11)
    operator bool() const { return true; }
};
struct B
{
    explicit B(int) {}
    explicit B(int, int) {}
    explicit operator bool() const { return true; }
};
int main()
{
    A a1 = 1;      // OK : l'initialisation par copie sélectionne A::A(int)
    A a2(2);       // OK : l'initialisation directe sélectionne A::A(int)
    A a3 {4, 5};   // OK : l'initialisation directe par liste sélectionne A::A(int, int)
    A a4 = {4, 5}; // OK : l'initialisation par copie de liste sélectionne A::A(int, int)
    A a5 = (A)1;   // OK : le cast explicite effectue un static_cast
    if (a1) { }    // OK : A::operator bool()
    bool na1 = a1; // OK : l'initialisation par copie sélectionne A::operator bool()
    bool na2 = static_cast<bool>(a1); // OK : static_cast effectue une initialisation directe
//  B b1 = 1;      // erreur : l'initialisation par copie ne considère pas B::B(int)
    B b2(2);       // OK : l'initialisation directe sélectionne B::B(int)
    B b3 {4, 5};   // OK : l'initialisation directe par liste sélectionne B::B(int, int)
//  B b4 = {4, 5}; // erreur : l'initialisation par copie de liste ne considère pas B::B(int, int)
    B b5 = (B)1;   // OK : le cast explicite effectue un static_cast
    if (b2) { }    // OK : B::operator bool()
//  bool nb1 = b2; // erreur : l'initialisation par copie ne considère pas B::operator bool()
    bool nb2 = static_cast<bool>(b2); // OK : static_cast effectue une initialisation directe
    [](...){}(a4, a5, na1, na2, b5, nb2); // supprime les avertissements "variable non utilisée"
}

Voir aussi