in_place_t, in_place_type_tin_place_index_t struct

Introduit en C++17.

Les in_place_ttypes , in_place_type_tet in_place_index_t balises sont utilisés pour sélectionner le constructeur surchargé qui crée l’objet en place de la manière souhaitée. Pour les types qui utilisent ces types d’étiquettes, ils peuvent également éviter les opérations de copie ou de déplacement temporaires.

Syntaxe

struct in_place_t
{
    explicit in_place_t() = default;
};

inline constexpr in_place_t in_place{};

template <class T>
struct in_place_type_t
{
    explicit in_place_type_t() = default;
};

template <class T>
constexpr in_place_type_t<T> in_place_type{};

template <size_t I>
struct in_place_index_t
{
    explicit in_place_index_t() = default;
};

template <size_t I>
constexpr in_place_index_t<I> in_place_index{};

Paramètres

I
Index où l’objet est créé en place.

T
Type d'objet à créer.

Notes

• in_place_t indique la construction sur place d’un objet. Permet de créer des objets en place à l’intérieur d’un std::optional.
• in_place_type_t indique la construction sur place d’un objet d’un type spécifique. Il est utile car std::any std::any il peut contenir n’importe quel type de type. Nous devons donc spécifier le type qu’il contient.
• in_place_index_t indique la construction sur place d’un objet à un index spécifique. Utilisez-le std::variant pour spécifier l’index dans lequel l’objet est créé.

Les types de classes suivants utilisent ces structs dans leurs constructeurs : expected, , optional, single_viewany ou variant.

Exemple

#include <iostream>
#include <optional>
#include <any>
#include <variant>

// compile with /std:c++17

struct MyStruct
{
    double value;
    MyStruct(double v0, double v1 = 0) : value(v0 + v1) {}
};

int main()
{
    // Construct a MyStruct directly inside opt
    std::optional<MyStruct> opt(std::in_place, 29.0, 13.0);

    // Construct a MyStruct object inside an any object
    std::any a(std::in_place_type<MyStruct>, 3.14);

    // Construct a MyStruct object inside a vector at index 0
    std::variant<MyStruct, int> v(std::in_place_index<0>, 2.718);

    if (opt)
    {
        std::cout << opt->value << ", ";
    }

    std::cout << std::any_cast<MyStruct>(a).value << ", "
              << std::get<0>(v).value;

    return 0;
}

42, 3.14, 2.718

Spécifications

En-tête : <utility>

Espace de noms : std

Option du compilateur : /std:c++17 ou version ultérieure.