przechowywanie i ponowne używanie wartości decltype?

Question

jeśli mam szablon:

template <class T> 
struct Item 
{ 
    T _value; 
}; 

mogę wtedy zrobić:

// ... 
Item<int> x = { 42 }; // declared as an int 

// ... 
decltype(x._value) y = 20; // 'y' is also an int 

Ale czy jest to możliwe do przechowywania decltype do zmiennej, dzięki czemu można go stosować później?

Dlaczego?
Chcę przechowywać wartości elementów jako wskaźnik.

Coś std::vector<Item*> ale jak są szablony muszę przechowywać je jako wskazówki do void:

std::vector<void*> is; 
is.push_back(new Item<int>()); 
is.push_back(new Item<double>()); 
is.push_back(new Item<float>()); 

I to wszystko jest w porządku, ale gdy przychodzi czas, aby usunąć wskaźnik muszę ponownie obsady moja void* z powrotem do właściwego typu (tak nazywane są destruktory):

delete (Item<int>*)is[0]; 

A jeśli wiem, typ, mogę zrobić:

delete (Item<decltype(whatever)>*)is[0]; 

Z tego powodu muszę przechowywać decltype.

Mam nadzieję, że to ma sens.

Answer 1

decltype to funkcja językowa, która umożliwia pobieranie typu podczas kompilacji. Wygląda na to, że chcesz "przechowywać" ten typ, aby móc poprawnie umieszczać obiekty w pamięci dynamicznej w czasie wykonywania. Zakładając, że tak jest, decltype nie pomoże tutaj.

Masz różne opcje:

1. korzystać z niektórych form typu kasowania obiektu jak Boost.Variant lub Boost.Any, jak sugeruje Baum mit Augen w komentarzach.

2. Dokonać obiekty część polimorficznych hierarchii i użyj inteligentne kursory:

   struct ItemBase 
   { 
       virtual ~ItemBase() { } 
   }; 
   
   template <class T> 
   struct Item : ItemBase 
   { 
       T _value; 
   }; 
   
   int main() 
   { 
       std::vector<std::unique_ptr<ItemBase>> items; 
       items.emplace_back(std::make_unique<Item<int>>()); 
       items.emplace_back(std::make_unique<Item<float>>());      
       items.emplace_back(std::make_unique<Item<double>>()); 
   } 
   

Answer 2

Jeśli problem jest tylko, aby je usunąć, można użyć unique_ptr z niestandardowym Deleter zamiast nagich wskaźników.
Aby to zrobić, nie trzeba modyfikować hierarchii.
Jako przykład:

std::vector<std::unique_ptr<void, void(*)(void*)>> is; 
is.push_back(std::unique_ptr<void, void(*)(void*)>{new Item<int>(), [](void *ptr) { delete static_cast<Item<int>*>(ptr); }}); 

Jeszcze lepiej, jeśli za pomocą emplace_back zamiast push_back:

std::vector<std::unique_ptr<void, void(*)(void*)>> is; 
is.emplace_back(new Item<int>(), [](void *ptr) { delete static_cast<Item<int>*>(ptr); }); 

Wynika minimalny, przykład działa na podstawie kodeksu PO za:

#include<vector> 
#include<memory> 

template<typename> 
struct Item {}; 

int main() { 
    using Deleter = void(*)(void*); 
    std::vector<std::unique_ptr<void, Deleter>> is; 
    is.emplace_back(new Item<int>(), [](void *ptr) { delete static_cast<Item<int>*>(ptr); }); 
    is.emplace_back(new Item<double>(), [](void *ptr) { delete static_cast<Item<double>*>(ptr); }); 
    is.emplace_back(new Item<float>(), [](void *ptr) { delete static_cast<Item<float>*>(ptr); }); 
} 

Answer 3

ty może przechowywać przetwornik

więc z std::shared_ptr, staje się:

std::vector<std::shared_ptr<void>> items; 

// The simplest 
items.push_back(std::make_shared<Item<int>>(/*args...*/)); 

// Explicitly specify the (default) deleter 
items.push_back(std::shared_ptr<void>{new Item<double>(/*args...*/), 
             std::default_delete<Item<double>>{}}); 

// Explicitly specify the (default) allocator 
items.push_back(
    std::allocate_shared<Item<float>>(std::allocator<Item<float>>{} /*, args...*/);