(C++) Container of templated classes - c++

Question

I'm sure this question comes up a lot, but my question has a slight difference which I haven't seen addressed (perhaps this is due to poor design on my part: I'm pretty new to C++).
For example, let's say I have a base class as such:
class Var {
public:
Var(std::string id, std::string description) : _id(id), _description(description) {}
private:
std::string _id, _description;
public:
std::string id() {
return this->_id;
}
std::string description() {
this->_description;
}
};
And some implementations like this:
template<
typename N,
typename = typename std::enable_if<std::is_arithmetic<N>::value, N>::type
>
class VarNumber : public Var {
public:
VarNumber(std::string id, std::string desc, N value, N min, N max) : Var(id, desc), _value(value), _min(min), _max(max) {}
VarNumber(std::string id, N value, N min, N max) : VarNumber(id, "", value, min, max) {}
private:
N _value;
N _min, _max;
public:
N value() {
return this->_value;
}
void set(N value) {
this->_value = std::clamp(value, this->_min, this->_max);
}
N min_value() {
return this->_min;
}
N max_value() {
return this->_max;
}
};
class VarBool : public Var {
public:
VarBool(std::string id, std::string desc, bool value) : Var(id, desc), _value(value) {}
VarBool(std::string id, bool value) : VarBool(id, "", value) {}
private:
bool _value;
public:
bool value() {
return this->_value;
}
bool set_value(bool value) {
this->_value = value;
}
bool toggle() {
this->set_value(!this->_value);
}
};
Say I wanted a container to hold all implementations of Var in one place. Now, I've been told that abusing inheritance to do this is not the way to go, i.e.:
std::vector<Var*> vars;
vars.push_back(new VarBool(...));
vars.push_back(new VarNumber<float>(...));
Especially since the above would require a cast to access methods specific to each Var implementation:
(static_cast<VarBool*>(vars.at(0)))->toggle();
float max = (static_cast<VarNumber<float>*>(vars.at(1)))->max_value());
I've also tried defining the container like:
std::vector<std::variant<VarBool, VarNumber<int>, VarNumber<float>, ... >>
This would work if there was a finite number of types to be templated for each Var implementation, but that doesn't work for my purposes. I have other Var types that are templated for enums, that cannot be defined at compile time:
template<
typename E,
typename = typename std::enable_if<std::is_enum<E>::value>::type
>
class VarMOption : public Var {
...
};
What's the best way to go about this? I've tried implementing a type erasure pattern but that only works if each "child" has the same methods.
I'd like to design this in a way that while storing all types in a single container, there are no pointless states represented, i.e. a max_value() method on a VarBool, or a toggle() method on a VarNumber<float>.
Is this a result of poor design? What's the best approach for this?
Thanks.
EDIT: Example regarding #ALX23z's comment
enum Target {
FOO,
BAR,
QAZ
}
std::unique_ptr<Var> enum_var = std::make_unique(Var("test enum", "description"));
enum_var->variant = EnumVar<Target>(Target::FOO); //EnumVar doesn't exist, since we would have to somehow define it in the variant
// But this would work:
std::unique_ptr<Var> num_var = std::make_unique(Var("test num", "desc"));
num_var->variant = NumberVar<float>(3.f, 0.f, 10.f);
// In Var class:
class Var {
// constructor here... (2 strs)
std::variant<NumberVar<float>, NumberVar<int> .. etc> variant;
}
EDIT 2
Here's what I came up with. It's very ugly.
class VarBool {
public:
VarBool(bool value_) : value_(value_) {}
private:
bool value_;
public:
bool& value() {
return this->value_;
}
void set(const bool& other) {
this->value_ = other;
}
};
template<
typename N,
typename = typename std::enable_if<std::is_arithmetic<N>::value, N>::type
>
class VarNumber {
public:
VarNumber(N value_, N min_, N max_) : value_(value_), min_(min_), max_(max_) {}
private:
N value_, min_, max_;
public:
N& value() {
return this->value_;
}
void set(const N& other) {
this->value_ = std::clamp(other, this->min_, this->max_);
}
N minimum() {
return this->min_;
}
N maximum() {
return this->max_;
}
};
class VarWrapper {
using V = std::variant<VarBool, VarNumber<int>, VarNumber<float>>;
public:
VarWrapper(std::string id_, std::string desc_, V inner_) : id_(id_), desc_(desc_), inner_(inner_) {}
VarWrapper(std::string id_, V inner_) : VarWrapper(id_, "", inner_) {}
private:
std::string id_, desc_;
V inner_;
public:
std::string id() {
return this->id_;
}
std::string desc() {
return this->desc_;
}
template<typename T>
T& unwrap() {
if (std::holds_alternative<T>(this->inner_))
return std::get<T>(this->inner_);
}
};
Usage:
std::shared_ptr<VarWrapper> w_var = std::make_shared<VarWrapper>(VarWrapper("name", "description", VarNumber<float>(1.5f, 0.f, 10.f)));
float& unwrapped_var_val = w_var->unwrap<VarNumber<float>>().value();
std::cout << unwrapped_var_val << "\n"; //prints 1.5f
w_var->unwrap<VarNumber<float>>().set(200.f);
std::cout << unwrapped_var_val << "\n"; //prints 10.f (clamped)