Elementinitialisierungsliste: initialisiert zwei Elemente aus einer Funktion, die ein Tupel zurückgibt

Question

Können mehrere Member in der Memberinitialisierungsliste aus einem Tupel initialisiert werden, das von einer Funktion erhalten wurde?

Mit der Rückgabe mehrerer Werte über Tupel, die immer beliebter werden, hoffe ich, dass es eine Lösung dafür gibt. Ich sehe keinen anderen Grund als eine Sprachbeschränkung, warum dies nicht möglich wäre.

---

Dies ist ein MCVE für das, was ich habe:

auto new_foo(std::size_t size) -> std::tuple<std::unique_ptr<char[]>, int*> 
{ 
    auto buffer = std::make_unique<char[]>(size * sizeof(int) + 8); 
    auto begin = static_cast<int*>(static_cast<void*>(buffer.get() + 4)); 
    return std::make_tuple(std::move(buffer), begin); 
} 

struct X { 
    std::unique_ptr<char[]> buffer_{nullptr}; 
    int* begin_{nullptr}; 
    std::size_t size_{0}; 

    X(std::size_t size) : size_{size} 
    { 
     std::tie(buffer_, begin_) = new_foo(size); 
    } 
}; 

Kann man das ?:

X(std::size_t size) 
     : buffer_{ ??? }, 
      begin_{ ??? }, 
      size_{size} 
    { 
    } 

ich einfach anrufen kann nicht new_foo für jedes Mitglied der Initialisierung einmal durchgeführt werden (wie es zurückgibt ein weiteres Tupel bei jedem Anruf). So

X(std::size_t size) 
     : buffer_{std:get<0>(new_foo(size)}, 
      begin_{std:get<1>(new_foo(size)}, 
      size_{size} 
    { 
    } 

es ist nicht möglich (auch wenn es dies nicht der Fall war, mehrere Male ruft das gleiche Ergebnis zu erhalten, ist weniger als optimal)

Eine andere Lösung, die ich darüber nachdachte, war es, die Mitglieder zu halten ein Tupel. Ich verworfen, da ich die beiden Mitglieder richtig innerhalb der Klasse benannt und nicht mit get<0> und get<1> zugegriffen haben.

Noch eine andere Problemumgehung wäre, eine einfache separate Struktur zu erstellen, um die zwei Mitglieder zu halten. Auf diese Weise würden sie Namen haben, aber fügen Sie eine weitere Ebene von Qualifier hinzu, und möglicherweise müsste ich eine Kopie ctor dafür erstellen (wegen der unique_ptr).

---

Wie berichtet hereC++1zStrukturierte Bindungen haben (D0144R0), die dies möglich machen:

auto {x,y,z} = f(); 

Da ich nicht die volle Papier gefunden haben, kann ich nicht sagen, ob dies helfen wird, im Zusammenhang mit Mitglied Initialisierungsliste. Ich vermute nicht.

Answer 1

Definieren Sie einen anderen (möglicherweise privaten) Konstruktor, der das Tupel übernimmt und delegiert.

private: 
    X(std::tuple<std::unique_ptr<char>, int*> t, std::size_t size) 
      : buffer_{std::move(std:get<0>(t))}, 
       begin_{std:get<1>(t)}, 
       size_{size} 
    { } 

public: 
    X(std::size_t size) : X{new_foo(size), size} 
    { }