Recombinate two complex attributes into new object - c++

Question

I want to recombine a (complex) member attribute of two agents and put it in a new agent. It's a vector of numbers, every second value is taken from agent1, the rest from agent2. The problem is, I want to be able to exchange the implementation of my numberList, maybe another numberListInt2 using integers or like in my example using floats:
#include <vector>
using namespace std;
class NumberList {
};
class NumberListInt : public NumberList {
vector<int> number_list {1,2,3};
};
class NumberListFloat : public NumberList {
vector<float> number_list {1.2f,2.5f,30.0f};
};
class Agent {
NumberList* numbers;
public:
Agent();
Agent(NumberList* numbers) {
numbers = numberList*
}
~Agent() {
delete numbers;
}
NumberList* recombine(Agent& other) {
NumberList* new_number_list;
if(true) // a boolean config value
new_number_list = new NumberListInt();
else
new_number_list = new NumberListFloat();
for(unsigned int i=0;i<3;i++) {
if(i%2)
new_number_list[i] = other.get_number_list()[i];
else
new_number_list[i] = numbers[i];
}
return new_number_list;
}
NumberList* get_number_list() {
return numbers;
}
};
int main ()
{
Agent agent;
Agent agent2;
Agent agent3(agent.recombine(agent2));
return 0;
}
My questions:
How to implement the operator [] of NumberList?
Is there a better way than using a pointer for the polymorphism?
Do I free the memory correctly?
Thanks in advice!

Answer 1

The problem is that operator[] shall return a reference to an item of the NumberList. But you don't know the type of the numbers, when you're in the parent class. So you won't be able to define this operator in a polymorphic manner (unless you define somehow a polymorphic item).
To benefit from polymorphism you have to use references or pointers. In your case the pointers are a good alternative. However you have to clarify their use in the constructors. I assume that the copy constructor should copy the object and not reuse the list of the original agent.
No, because you have not defined a virtual destructor for NumberList. And when you recombine() you return a newly allocated list. So the caller has to delete the returned object. That's very dangerous: if he forget, memory will leak. You'd better consider opting for shared_ptr to avoid leaking.
It's not clear if you need dynamic change of the NumberList type at runtime. If you don't, a safer approach would be to use templates
With templates it would look like:
template <class T>
class NumberList {
vector<T> number_list;
T& operator[] (size_t i) { return numberlist[i]; } // may be add boundary check ?
};
template <class T>
class Agent {
NumberList<T> numbers; // No more pointer, but directly the object
....
};