Masquer la classe de base vide pour l'initialisation agrégée


9

Considérez le code suivant:

struct A
{
    // No data members
    //...
};

template<typename T, size_t N>
struct B : A
{
    T data[N];
}

Voici comment vous devez initialiser B: B<int, 3> b = { {}, {1, 2, 3} }; je veux éviter le {} vide inutile pour la classe de base. Il y a une solution proposée par Jarod42 ici , cependant, cela ne fonctionne pas avec l'initialisation par défaut des éléments: B<int, 3> b = {1, 2, 3};c'est bien mais ce B<int, 3> b = {1};n'est pas le cas: b.data[1]et b.data[2]ne sont pas initialisés par défaut à 0, et une erreur de compilation se produit. Existe-t-il un moyen (ou il y en aura avec c ++ 20) de "cacher" la classe de base à la construction?


2
Pourquoi ne pas ajouter un constructeur template<class... Ts> B(Ts... args) : data{args...} {}?
Evg

Pourquoi est-ce un commentaire? Il semble fonctionner, lol
user7769147

C'est une solution tellement évidente que je pensais que vous aviez une raison de ne pas l'utiliser. :)
Evg

C'était trop facile xD. Si vous l'écrivez comme réponse, je l'accepterai
user7769147

Réponses:


6

La solution la plus simple consiste à ajouter un constructeur variadique:

struct A { };

template<typename T, std::size_t N>
struct B : A {
    template<class... Ts, typename = std::enable_if_t<
        (std::is_convertible_v<Ts, T> && ...)>>
    B(Ts&&... args) : data{std::forward<Ts>(args)...} {}

    T data[N];
};

void foo() {
    B<int, 3> b1 = {1, 2, 3};
    B<int, 3> b2 = {1};
}

Si vous fournissez moins d'éléments dans la {...}liste d'initialisation que N, les autres éléments du tableau dataseront initialisés en tant que par T().


3
Je viens de découvrir pourquoi cela est différent de l'initialisation agrégée. Si vous pensez B<Class, 5> b = {Class()}; Classqu'il sera construit en premier puis déplacé, alors qu'en utilisant l'initialisation agrégée, Classil sera construit en place, aucun mouvement impliqué
user7769147

@ user7769147, bon point. Vous pouvez prendre std::tupledes arguments et les utiliser pour construire des objets sur place. Mais la syntaxe sera plutôt lourde.
Evg

1
J'ai trouvé au hasard une solution qui résout ce problème, je vais laisser cette réponse acceptée pour vous remercier de votre disponibilité :).
user7769147


4

Toujours avec le constructeur, vous pourriez faire quelque chose comme:

template<typename T, size_t N>
struct B : A
{
public:
    constexpr B() : data{} {}

    template <typename ... Ts,
              std::enable_if_t<(sizeof...(Ts) != 0 && sizeof...(Ts) < N)
                               || !std::is_same_v<B, std::decay_t<T>>, int> = 0>
    constexpr B(T&& arg, Ts&&... args) : data{std::forward<T>(arg), std::forward<Ts>(args)...}
    {}

    T data[N];
};

Démo

SFINAE est fait principalement pour éviter de créer un pseudo constructeur de copie B(B&).

Vous auriez besoin d'une balise privée supplémentaire pour prendre en charge B<std::index_sequence<0, 1>, 42>;-)


Pourquoi as-tu besoin ((void)Is, T())...? Et si vous l'omettez simplement? Les éléments restants ne seront-ils pas initialisés avec une T()valeur par défaut?
Evg

1
@Evg: En effet, simplifié. J'avais peur de ne initialiser par défaut que les éléments restants au lieu de les initialiser par valeur ...
Jarod42

2

J'ai trouvé une autre solution qui (je ne sais pas comment) fonctionne parfaitement et résout le problème dont nous discutions sous la réponse d'Evg

struct A {};

template<typename T, size_t N>
struct B_data
{
    T data[N];
};

template<typename T, size_t N>
struct B : B_data<T, N>, A
{
    // ...
};

Solution intéressante. Mais maintenant, il faut utiliser this->dataou using B_data::data;accéder à l' dataintérieur B.
Evg
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.