C++ Typ basiertes Caching ohne Verwendung von statischen Speicher

Question

ich etwas bin mit wie:

struct VectorCache 
{ 
    template<typename T> 
    std::vector<T>& GetTs() 
    { 
     static std::vector<T> ts; 
     return ts; 
    } 
}; 

erstellen/einige Vektoren auf der enthaltenen Typ basiert zugreifen. Das funktioniert gut, solange ich nur ein Objekt vom Typ VectorCache habe, aber wenn ich mehrere Objekte verwende, bekomme ich dieselben Vektoren von allen Instanzen von VectorCache, da die Vektoren statische Variablen sind.

Ich habe versucht, die Vektoren als Elementvariablen mit etwas ähnlich wie boost::any zu verschieben und sie mit std::type_index von T zugreifen, aber das ist irgendwie langsamer als der direkte Zugriff, den ich zuvor verwendet habe.

Eine andere Möglichkeit ist, struct VectorCache in etwas wie template<int index> struct VectorCache umzuwandeln, aber das Problem ist immer noch da - ich muss vorsichtig sein, nur eine Instanz/Index zu haben, um korrektes Verhalten zu haben.

Ist es möglich, basierend auf T direkt auf die Vektoren zuzugreifen, und basiert die Caching-Instanz statt auf der Klasse?

Answer 1

Sie könnten ein nicht geprüftes Analogon von Boost.Any versuchen. Sehen, ob das schnell genug für Sie ist (obwohl ich nicht glaube, es würde einen großen Unterschied machen):

#include <memory> 
#include <type_traits> 
#include <typeindex> 
#include <unordered_map> 
#include <vector> 

class AnyCache 
{ 
    struct TEBase 
    { 
     virtual ~TEBase() {} 
     virtual void * get() = 0; 
    }; 

    template <typename T> struct TEObject : TEBase 
    { 
     T obj; 
     virtual void * get() override { return static_cast<void *>(&obj); } 
    }; 

    std::unordered_map<std::type_index, std::unique_ptr<TEBase>> cache; 

public: 
    AnyCache(AnyCache const &) = delete; 
    AnyCache & Operator=(AnyCache const &) = delete; 

    template <typename T> decltype(auto) get() 
    { 
     using U = std::decay_t<T>; 
     using C = std::vector<U>; 

     std::unique_ptr<TEBase> & p = cache[typeid(U)]; 
     if (!p) { p = std::make_unique<TEObject<C>>(); } 
     return *static_cast<C *>(p->get()); 
    } 
}; 

Verbrauch:

AnyCache ac; 
ac.get<int>().push_back(20); 
ac.get<std::string>().push_back("Hello"); 
for (auto const & x : ac.get<Foo>()) { std::cout << x << '\n'; } 

Answer 2

Wenn - und es ist ein großes, wenn - Ihre VectorCache -verwenden Code ist nicht eingefädelt, können Sie dies tun:

struct VectorCache 
{ 
    VectorCache() : instance_counter_(++s_instance_counter_) { } 

    template<typename T> 
    std::vector<T>& GetTs() 
    { 
     static std::vector<std::vector<T>> tss; 
     if (tss.size() <= instance_counter_) 
      tss.resize(instance_counter_); 
     return tss[instance_counter_]; 
    } 

    size_t instance_counter_; 
    static size_t s_instance_counter_; 
}; 

// and define size_t VectorCache::s_instance_counter_; 

implementation on ideone.com

Mit al ittele Synchronisation können Sie es thread sicher machen, oder sogar Thread spezifisch, wenn das passt. Fügen Sie die Löschung der Kopierkonstruktion/-zuweisung usw. hinzu, wenn dies für Ihre beabsichtigte Verwendung sinnvoll ist.