C++ 将两个复杂属性重新组合为新对象

我想重新组合两个代理的（复杂）成员属性，并将其放入新代理中。它是一个数字向量，每秒的值取自agent1，其余的取自agent2。问题是，我希望能够交换我的

numberList

的实现，可能是另一个

numberlistin2

使用整数，或者在我的示例中使用浮点：

#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;
}

#包括
使用名称空间std；
类数学家{
};
类别编号限制：公共编号列表{
向量数_列表{1,2,3}；
};
类别NumberListFloat:公共NumberList{
向量数_列表{1.2f，2.5f，30.0f}；
};
类代理{
数字列表*数字；
公众：
Agent（）；
代理（数字列表*数字）{
数字=数字列表*
}
~Agent（）{
删除号码；
}
数字列表*重组（代理和其他）{
数字列表*新的数字列表；
if（true）//一个布尔配置值
new_number_list=new numberlit（）；
其他的
new_number_list=new NumberListFloat（）；
对于（无符号整数i=0；i
问题是
操作符[]
将返回对
数字列表
项的引用。但是，当您在父类中时，您不知道数字的类型。因此，您将无法以多态方式定义此操作符（除非您以某种方式定义多态项）

为了从多态性中获益，您必须使用引用或指针。在您的情况下，指针是一个很好的选择。但是，您必须澄清它们在构造函数中的使用。我假设复制构造函数应该复制对象，而不是重用原始代理的列表

否，因为您尚未为
NumberList
定义虚拟析构函数。当您
重新组合（）< /代码>您返回一个新分配的列表。因此调用方必须删除返回的对象。这是非常危险的：如果他忘记了，内存会泄漏。您最好考虑选择<代码> SyddYPPTR <代码>以避免泄漏。

不清楚您是否需要在运行时动态更改
NumberList
类型。如果不需要，更安全的方法是使用模板

对于模板，它看起来像：

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 
    .... 
}; 

模板
类数学家{
矢量编号列表；
运算符[]（size_T i）{return numberlist[i]；}//是否可以添加边界检查？
};
模板
类代理{
NumberList numbers；//不再有指针，而是直接指向对象
.... 
}; 
我现在解决了这个问题，为每个数字列表创建了一个特定的函数。这不是最多态的方式，但它可以工作；）