Leere Basisklasse für die aggregierte Initialisierung ausblenden

9

Betrachten Sie den folgenden Code:

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

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

So müssen Sie B initialisieren: B<int, 3> b = { {}, {1, 2, 3} }; Ich möchte das unnötige leere {} für die Basisklasse vermeiden. Es gibt eine Lösung von Jarod42 vorgeschlagen hier jedoch nicht mit Elementen Standardinitialisierung funktioniert: B<int, 3> b = {1, 2, 3};ist gut , aber B<int, 3> b = {1};nicht ist: b.data[1]und b.data[2]ist nicht auf 0 initialisiert default und ein Compiler - Fehler auftritt. Gibt es eine Möglichkeit (oder wird es mit c ++ 20 geben), die Basisklasse vor der Konstruktion zu "verstecken"?

user7769147
quelle
2
Warum nicht einen Konstruktor hinzufügen template<class... Ts> B(Ts... args) : data{args...} {}?
Evg
Warum ist es ein Kommentar? Es scheint zu funktionieren, lol
user7769147
Dies ist eine so offensichtliche Lösung, dass ich dachte, Sie hätten einen Grund, sie nicht zu verwenden. :)
Evg
Es war zu einfach xD. Wenn Sie es als Antwort schreiben, werde ich es akzeptieren
user7769147

Antworten:

6

Die einfachste Lösung besteht darin, einen variadischen Konstruktor hinzuzufügen:

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};
}

Wenn Sie in der {...}Initialisierungsliste weniger Elemente als angeben N, werden die verbleibenden Elemente im Array wie datafolgt mit dem Wert initialisiert T().

Evg
quelle
3
Ich habe gerade herausgefunden, warum sich dies von der aggregierten Initialisierung unterscheidet. Wenn Sie in Betracht ziehen, B<Class, 5> b = {Class()}; Classwird zuerst erstellt und dann verschoben, während unter Verwendung der aggregierten Initialisierung Classan Ort und Stelle erstellt werden würde, ist keine Verschiebung
erforderlich
@ user7769147, guter Punkt. Sie können std::tupleArgumente verwenden und sie verwenden, um Objekte direkt zu erstellen. Die Syntax ist jedoch ziemlich umständlich.
Evg
1
Ich habe zufällig eine Lösung gefunden, die dieses Problem löst. Ich werde dies als akzeptierte Antwort belassen, um Ihnen für Ihre Verfügbarkeit zu danken :).
user7769147
4

Da C ++ 20 Sie nutzen könnten bezeichnet initializers in Aggregat Initialisierung .

B<int, 3> b = { .data {1} }; // initialize b.data with {1}, 
                             // b.data[0] is 1, b.data[1] and b.data[2] would be 0
songyuanyao
quelle
Das ist mir immer noch zu ausführlich, das war ein minimales Beispiel. Mein Array-Mitglied hat einen seltsamen Namen, der vom Benutzer ignoriert werden sollte
user7769147
4

Noch mit dem Konstruktor können Sie Folgendes tun:

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];
};

Demo

SFINAE wird hauptsächlich durchgeführt, um zu vermeiden, dass ein Pseudokopiekonstruktor erstellt wird B(B&).

Sie würden zusätzliche private Tags benötigen, um zu unterstützen B<std::index_sequence<0, 1>, 42>;-)

Jarod42
quelle
Warum brauchen Sie ((void)Is, T())...? Was ist, wenn Sie es einfach weglassen? Werden die verbleibenden Elemente nicht T()standardmäßig mit einem Wert initialisiert ?
Evg
1
@ Evg: In der Tat vereinfacht.
Ich hatte
2

Ich habe eine andere Lösung gefunden, die (ich weiß nicht wie) perfekt funktioniert und das Problem löst, das wir unter Evgs Antwort besprochen haben

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
{
    // ...
};
user7769147
quelle
Interessante Lösung. Aber jetzt muss man das Innere benutzen this->dataoder using B_data::data;darauf zugreifen . dataB
Evg