Question

我想重新组合两个代理的（复杂）成员属性并将其放入新代理中。它是一个数字向量，每秒都取自agent1，其余来自agent2。问题是，我希望能够使用浮点数在我的示例中使用整数或类似的方式交换我的numberList的实现，也许是另一个numberListInt2的实现：

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

我的问题：

如何实现[]的运算符NumberList？
有没有比使用多态性指针更好的方法？
我是否正确释放了内存？

感谢您的建议！

Answer 1

问题是operator[]将返回对NumberList项的引用。但是当你在父类中时，你不知道数字的类型。因此，您无法以多态方式定义此运算符（除非您以某种方式定义多态项）。
要从多态性中受益，您必须使用引用或指针。在你的情况下，指针是一个很好的选择。但是，您必须澄清它们在构造函数中的用法。我假设复制构造函数应该复制对象而不是重用原始代理的列表。
不，因为您尚未为NumberList定义虚拟析构函数。当你recombine()时，你返回一个新分配的列表。因此调用者必须删除返回的对象。这非常危险：如果他忘了，记忆就会泄漏。您最好考虑选择shared_ptr以避免泄露。
目前尚不清楚是否需要在运行时动态更改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 
    .... 
};

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

1 个答案: