Create instance of derived abstract class in c++ - c++

Question

I have got this problem and don't know how to solve it.
Suppose I have these base classes:
class ValueBase
{
private:
int base_value;
public:
int GetValue();
void SetValue(int val);
virtual ValueBase* Meet(ValueBase* const a, ValueBase* const b) = 0;
}
class NodeBase
{
private:
ValueBase* base_nodeValue;
public:
bool AddValue(int val);
}
and derived class:
class Value : public ValueBase
{
public:
Value* Meet(ValueBase* a, ValueBase* b) override;
}
Is there a way to create instance of class Value in method AddValue in class NodeBase? I know that I should probably make AddValue pure virtual and implement it in derived class of NodeBase, but is there possibility to do it without this option? Can I use e.g. template method or maybe a callback to method in Value that would construct that object? Or is it just too evil to do it?
EDITED:
I don't have access to derived class Value in class NodeBase

Answer 1

Add a creation member function:
class ValueBase
{
public:
virtual ValueBase * create() = 0;
// ...
};
Then in NodeBase you can use base_nodeValue->create().
Derived classes implement it:
class Value : public ValueBase
{
Value * create() override { return new Value; }
};
The more common form of this pattern is a clone function, though, which does not produce a default-constructed object of the same type, but a copy:
Derived * clone() override { return new Derived(*this); }

Answer 2

I see no approach without changing class definitions. However, there are many approaches that involve changing class definitions, depending on what you are "allowed" to use.
A. Make AddValue() templated on the object type it should create:
class NodeBase
{
private:
ValueBase* base_nodeValue;
public:
template<class ValueType>
bool AddValue(int val) { base_nodeValue = new ValueType; }
}
...
// other code that has access to Value
node.AddValue<Value>(10);
B. Create function that creates Value (forwarding any arguments to constructor if needed) and pass it as an argument toAddValue`:
// might need to adapt syntax
class NodeBase
{
private:
ValueBase* base_nodeValue;
public:
bool AddValue(int val, ValueBase* (*creator)()) { base_nodeValue = (*creator)(); }
}
...
// other code that has access to Value
ValueBase* valueCreator() { return new Value; }
...
node.AddValue(10, valueCreator);
(May use a functor or a lambda here as well)
C. You can create a function in ValueBase that returns Value*.
class ValueBase
{
public:
static ValueBase* createValue();
};
class NodeBase
{
private:
ValueBase* base_nodeValue;
public:
bool AddValue(int val) { base_nodeValue = ValueBase::createValue(); }
};
// in a separate cpp
ValueBase* ValueBase::createValue() { return new Value; }
This is in fact similar to a factory approach: you can have createValue() accept a parameter and create different ValueBases depending on it. Having ValueBase store some pointer to creator function, you can have it not know about Value at all, just initialize that pointer at some other place, like you can register a subclass in a factory table in base class.