Namespaces
Variants

    std::optional<T>::emplace

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Libre et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support du langage
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes de caractères
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et d'heure
    Bibliothèque d'entrée/sortie
    Bibliothèque du système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque d'utilitaires
    Support du langage
    Support des types (types de base, RTTI)
    Macros de test de fonctionnalités de la bibliothèque (C++20)
    Utilitaires de programme
    Fonctions variadiques
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Support des coroutines (C++20)
    Support des contrats (C++26)
    Comparaison à trois voies
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilitaires généraux
    Opérateurs relationnels (obsolète en C++20)
     
    std::optional
     
    template< class... Args >
T& emplace( Args&&... args );
    		(1) (depuis C++17)
    (constexpr depuis C++20)    		 
    template< class U, class... Args >
T& emplace( std::initializer_list<U> ilist, Args&&... args );
    		(2) (depuis C++17)
    (constexpr depuis C++20)

    Construit la valeur contenue sur place. Si *this contient déjà une valeur avant l'appel, la valeur contenue est détruite en appelant son destructeur.

    1) Initialise la valeur contenue par initialisation directe (mais pas par initialisation directe par liste) avec std::forward<Args>(args)... comme paramètres.
    2) Initialise la valeur contenue en appelant son constructeur avec ilist, std::forward<Args>(args)... comme paramètres. Cette surcharge ne participe à la résolution de surcharge que si std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value est true.

    Paramètres

    args... - les arguments à passer au constructeur
    ilist - la liste d'initialisation à passer au constructeur
    Exigences de type
    -
    T doit être constructible à partir de Args... pour la surcharge (1)
    -
    T doit être constructible à partir de std::initializer_list et Args... pour la surcharge (2)

    Valeur de retour

    Une référence à la nouvelle valeur contenue.

    Exceptions

    Toute exception levée par le constructeur sélectionné de T . Si une exception est levée, * this ne contient pas de valeur après cet appel (la valeur précédemment contenue, si elle existait, a été détruite).

    Macro de test de fonctionnalité Valeur Std Fonctionnalité
    __cpp_lib_optional 202106L (C++20)
    (DR20)     		Complètement constexpr ( 1,2 )

    Exemple

    Exécuter ce code 
    #include <iostream>
#include <optional>
struct A
{
    std::string s;
    A(std::string str) : s(std::move(str)), id{n++} { note("+ constructed"); }
    ~A() { note("~ destructed"); }
    A(const A& o) : s(o.s), id{n++} { note("+ copy constructed"); }
    A(A&& o) : s(std::move(o.s)), id{n++} { note("+ move constructed"); }
    A& operator=(const A& other)
    {
        s = other.s;
        note("= copy assigned");
        return *this;
    }
    A& operator=(A&& other)
    {
        s = std::move(other.s);
        note("= move assigned");
        return *this;
    }
    inline static int n{};
    int id{};
    void note(auto s) { std::cout << "  " << s << " #" << id << '\n'; }
};
int main()
{
    std::optional<A> opt;
    std::cout << "Assign:\n";
    opt = A("Lorem ipsum dolor sit amet, consectetur adipiscing elit nec.");
    std::cout << "Emplace:\n";
    // As opt contains a value it will also destroy that value
    opt.emplace("Lorem ipsum dolor sit amet, consectetur efficitur.");
    std::cout << "End example\n";
}

    Sortie : 

    Assign:
  + constructed #0
  + move constructed #1
  ~ destructed #0
Emplace:
  ~ destructed #1
  + constructed #2
End example
  ~ destructed #2

    Rapports de défauts

    Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

    DR Applicable à Comportement publié Comportement corrigé
    P2231R1 C++20 emplace n'était pas constexpr alors que les opérations requises peuvent être constexpr en C++20 rendu constexpr

    Voir aussi

    		assigne le contenu
    (fonction membre publique)