Inicjalizacja standardowego kontenera z unique_ptr [C++]

Question

Witam.

Załóżmy, że mam abstrakcyjną klasę Interface, jej dziedzica Child i klasę Keeper, która ma za zadanie zarządzać jakimś zbiorem obiektów, dziedziczących po Interface (w przykładzie mam tylko Child, ale powiedzmy, że dzieci jest więcej).

W jaki sposób mogę zainicjalizować instancję Keeper, tak aby w konstruktorze podawać elementy zbioru (patrz przykład w main())?

Nasuwające się std::initializer_list odpada, z racji kopiowania elementów, którego std::unique_ptr zabrania.

class Interface;

class Child: public Interface
{
public:
    Child(int i);
    // ...
};

class Keeper
{
public:
    Keeper(); // ???

    // ...
private:
    std::vector< std::unique_ptr<Interface> > storage;
};

int main()
{
    Keeper keeper{ std::make_unique<Child>(1),
                   std::make_unique<Child>(2),
                   std::make_unique<Child>(3) };
}

 

Answer 1

Z std::initializer_list się nie da, bo jej begin() i end() zwracają const E*, więc i tak zostanie wybrany usunięty copy constructor.

Wymodziłem za to coś takiego:

template<typename Receiver, typename Tup, size_t... Is>
void move_assign_seq(Receiver& r, Tup&& tup, std::index_sequence<Is...>) {
	int ignored[] = {
		((void)(r[Is] = std::move(std::get<Is>(tup))), 0)...
	};
	(void)ignored;
}

class Keeper
{
public:
	Keeper(); // ???

	template<typename... Ts>
	Keeper(std::unique_ptr<Ts>&&... items)
	{
		storage.resize(sizeof...(items));
		move_assign_seq(storage, std::forward_as_tuple(std::move(items)...), std::make_index_sequence<sizeof...(items)>());
	}

private:
	std::vector< std::unique_ptr<Interface> > storage;
};

http://melpon.org/wandbox/permlink/0Wus2DbNe6CFhWN1

Comments

He, nie wiedziałem, że topka polskiego cpp się tu zjawia :D

To jeszcze nie mój poziom i nie wszystko rozumiem, ale... działa. Nice.

---

Topka jak topka ;​) Ale widziałem linka na ircu i zostałem zainteresowany.

---

Super, dzięki za zainteresowanie. Zgrabności kodu nie ocenię, bo nie czuję się kompetentny. Ale działa, więc nic innego mi nie pozostaje, jak oznaczyć odpowiedź jako najlepszą.

Nie rozumiem w Twoim kodzie użycia ... w tych miejscach:

std::move(std::get<Is>(tup))), 0)...    // (1)
storage.resize(sizeof...(items));       // (2)

nawet nie za bardzo wiem, pod jakim hasłem tego szukać. Chyba że to jest coś związanego z vararg, ale... i tak nie łapię. Podpowiesz? :)

Odrobinę zastanawia mnie jedno. Czy mój przykład jest aż tak wybujały i niedorzeczny, że trzeba tu stosować tak egzotyczne rozwiązanie?

EDIT: ... (2) to "po prostu" pobranie rozmiaru wszystkich itemów?

EDIT2: już rozumiem (dzięki Criss ;).

---

sizeof... to osobny operator przeznaczony specjalnie do określania ilości argumentów w przypadku "parameter pack". I tyle wiem. Co do (1) się nie wypowiem.

Btw... Nigdzie nie moge znaleźć dokumentacji std::index_sequence... Dość dziwne.

---

Btw... Nigdzie nie moge znaleźć dokumentacji std::index_sequence... Dość dziwne.

Paragraf "Helper templates".

---

O, dzięki.

Dorzuciłem link do dokumentacji nt. sizeof..., bo ciężko to znaleźć w googlach.

Answer 2

Można pokazać przejęcie własności przez podanie r-referencji.

#include <vector>
#include <memory>
#include <initializer_list>

class Interface {
};
 
class Child: public Interface
{
public:
    Child(int i) {}
    // ...
};
 
class Keeper
{
public:
    Keeper(std::initializer_list<std::unique_ptr<Child>>&& il) {}
 
    // ...
private:
    std::vector<std::unique_ptr<Interface>> storage;
};
 
int main()
{
    std::initializer_list<std::unique_ptr<Child>> il{std::make_unique<Child>(1),
                   std::make_unique<Child>(2),
                   std::make_unique<Child>(3) };
    Keeper k1{std::move(il)};

    Keeper k2{std::make_unique<Child>(40), std::make_unique<Child>(33),
        std::make_unique<Child>(34)};
}

 

Comments

To nie jest w pełni działający przykład - inicjalizacja storage w prosty sposób nie działa:

Keeper(std::initializer_list<std::unique_ptr<Child>>&& il): storage(il) {} // error

 

---

mokrowski - dziękuję za odpowiedź, jednak nie tutaj tkwi sedno problemu (być może opis jest zbyt ubogi).

Jak pisze adrian17, inicjalizacja prosta "nie działa". Wypełnianie storage za pomocą metod rozszerzających kontener też średnio mi idzie (polecam spróbować, świetna zabawa :).

Jeśli istnieje rozwiązanie, to sądzę że trzeba tutaj zastosować jakąś
"sztuczkę-kombinację" z std::iterator_move, jednak nie potrafię tego złożyć w działającą całość.
(chyba żeby jeszcze kombinować z funkcją o zmiennej liczbie argumentów, ale - jeśli się da - wolałbym tego uniknąć)