Cはベクトル上に複数のタイプをプッシュ++

Question

注：私は、これはSOの前に頼まれているに類似の質問を知っているが、私は彼らが役に立つか、非常に明確で見つけることができませんでした。

第2のメモ：このプロジェクト/割り当ての範囲については、私はBoostのようなサードパーティのライブラリを避けようとしています。

私はそのインデックスのそれぞれに、複数のタイプを保持する単一のベクターを持つことができる方法があるかどうかを確認しようとしています。例えば、私は次のコードサンプルを持っていると言う：

vector<something magical to hold various types> vec; 
int x = 3; 
string hi = "Hello World"; 
MyStruct s = {3, "Hi", 4.01}; 

vec.push_back(x); 
vec.push_back(hi); 
vec.push_back(s); 

私はvector<void*>は仕事ができると聞きましたが、その後、それはメモリの割り当てとトリッキー取得し、近くのメモリ内の特定の部分が意図せずになる可能性が常にあります特定のインデックスに挿入された値が予想よりも大きい場合はオーバーライドされます。

の可能性がありますタイプはベクターに挿入できますが、これらのタイプはすべて同じスーパークラスから派生しているわけではなく、これらのタイプがすべてプッシュされる保証はありませんベクトルまたはどのような順序。

安全に私のコードサンプルで実証した目的を達成する方法はありますか？

ありがとうございます。

Answer 1

：非常にラフと不完全なアウトラインは次のようになります。

以前にType-Bを格納していたときにType-Aを取得しようとすると、このクラスに例外がスローされることもあります。

は、ここに私のプロジェクトの一つからHolderクラスの一部です。おそらくここから始めることができます。

注：による無制限組合の使用に、C++ 11でのみ動作。これについて詳しい情報はここで見つけることができます：What are Unrestricted Unions proposed in C++11?

class Holder { 
public: 
    enum Type { 
     BOOL, 
     INT, 
     STRING, 
     // Other types you want to store into vector. 
    }; 

    template<typename T> 
    Holder (Type type, T val); 

    ~Holder() { 
     // You want to properly destroy 
     // union members below that have non-trivial constructors 
    } 

    operator bool() const { 
     if (type_ != BOOL) { 
      throw SomeException(); 
     } 
     return impl_.bool_; 
    } 
    // Do the same for other operators 
    // Or maybe use templates? 

private: 
    union Impl { 
     bool bool_; 
     int int_; 
     string string_; 

     Impl() { new(&string_) string; } 
    } impl_; 

    Type type_; 

    // Other stuff. 
}; 

Answer 2

オブジェクトは、均質型であるstd::vector<T>必要により保持します。異なるタイプのオブジェクトを1つのベクトルに配置する必要がある場合は、何らかの形でそれらの型を消去し、それらをすべて同じようにする必要があります。あなたはboost::anyまたはboost::variant<...>という道徳上の同等物を使うことができます。 boost::anyのアイデアは、型の階層をカプセル化し、基底へのポインタを格納するが、テンプレート化された派生型を指すことです。あなたは間違いなく何とかベクトルから、あなたのオブジェクトの型情報を隠すためにラッパークラスが必要になります、それを行うためには

#include <algorithm> 
#include <iostream> 

class any 
{ 
private: 
    struct base { 
     virtual ~base() {} 
     virtual base* clone() const = 0; 
    }; 
    template <typename T> 
    struct data: base { 
     data(T const& value): value_(value) {} 
     base* clone() const { return new data<T>(*this); } 
     T value_; 
    }; 
    base* ptr_; 
public: 
    template <typename T> any(T const& value): ptr_(new data<T>(value)) {} 
    any(any const& other): ptr_(other.ptr_->clone()) {} 
    any& operator= (any const& other) { 
     any(other).swap(*this); 
     return *this; 
    } 
    ~any() { delete this->ptr_; } 
    void swap(any& other) { std::swap(this->ptr_, other.ptr_); } 

    template <typename T> 
    T& get() { 
     return dynamic_cast<data<T>&>(*this->ptr_).value_; 
    } 
}; 

int main() 
{ 
    any a0(17); 
    any a1(3.14); 
    try { a0.get<double>(); } catch (...) {} 
    a0 = a1; 
    std::cout << a0.get<double>() << "\n"; 
} 

Answer 3

としては、あなたがなど労働組合の様々な形、変異体、あなたが保存されたオブジェクトで何をしたいのかに応じて、外部の多型が正確に何を行う可能性を使用することができます示唆しましたあなたは、基本クラスのインタフェース内のすべての必要な操作を定義することができる場合は、をしたいです。

#include <iostream> 
#include <string> 
#include <vector> 
#include <memory> 

class any_type 
{ 
public: 
    virtual ~any_type() {} 
    virtual void print() = 0; 
}; 

template <class T> 
class concrete_type : public any_type 
{ 
public: 
    concrete_type(const T& value) : value_(value) 
    {} 

    virtual void print() 
    { 
     std::cout << value_ << '\n'; 
    } 
private: 
    T value_; 
}; 

int main() 
{ 
    std::vector<std::unique_ptr<any_type>> v(2); 

    v[0].reset(new concrete_type<int>(99)); 
    v[1].reset(new concrete_type<std::string>("Bottles of Beer")); 

    for(size_t x = 0; x < 2; ++x) 
    { 
     v[x]->print(); 
    } 

    return 0; 
}