c++ runtime instantiation of member parameter - c++

Question

As the title says I would like to initiate a Store object whose type is determined at runtime only. I initially went for a virtual class, 2 derived classes but quickly faced the need for templates.
The class O has a pointer to an interface BaseStore for these Store objects. Moreover since I also need to call the right functions for the Derived classes Store1 and Store2, I used a dynamic cast in a template function of the interface.
Since I am new to c++, I wonder if this design has flaws and if there is any place for improvements. Thanks for your expertise!
#include <iostream>
using namespace std;
struct BaseStore {
virtual ~BaseStore() {}
template<typename S> void test() const;
};
struct Store1 : public BaseStore {
Store1(int j) { this->i = j; }
void test() const { cout << i << endl; }
private:
int i = 1;
};
struct Store2 : public BaseStore {
Store2(string s) { this->i = s; }
void test() const { cout << i << endl; }
private:
string i = "2";
};
template<typename S> void BaseStore::test() const
{
dynamic_cast<const S&>(*this).test();
}
class O {
public:
O(int i) {
this->type = i;
switch (this->type) {
case 1: basestore = new Store1(42); break;
case 2: basestore = new Store2("lol"); break;
}
}
~O() { delete basestore; }
void test() const {
switch (this->type) {
case 1: basestore->test<Store1>(); break;
case 2: basestore->test<Store2>(); break;
}
}
private:
int type;
BaseStore* basestore;
};

Answer 1

I believe virtual functions and the factory pattern will help here, as in:
struct BaseStore
{
virtual ~BaseStore() = default;
virtual void test() const = 0;
BaseStore() = default;
BaseStore(BaseStore const&) = delete;
BaseStore(BaseStore&&) = delete;
BaseStore& operator=(BaseStore&&) = delete;
BaseStore& operator=(BaseStore const&) = delete;
};
struct Store1 : public BaseStore {
Store1(int j) : i(j) {}
void test() const override { std::cout << i << std::endl; }
private:
int i = 1;
};
struct Store2 : public BaseStore {
Store2(std::string s) : i(std::move(s)) {}
void test() const override { std::cout << i << std::endl; }
private:
std::string i = "2";
};
class O {
public:
O(int i) : type(i), basestore(StoreFactory(i)) {}
void test() const { basestore->test(); }
private:
static std::unique_ptr<BaseStore> StoreFactory(int i)
{
switch (i)
{
case 1: return std::unique_ptr<Store1>(new Store1(42));
case 2: return std::unique_ptr<Store2>(new Store2("lol"));
default: throw std::runtime_error("Don't know what kind of Store you want");
}
}
int type;
std::unique_ptr<BaseStore> basestore;
};