混合抽象类和模板会导致灾难吗？

Question

我遇到以下情况的问题。我有三个类参与了这种混合。 列表、ListNode、城市。我有一个 List，其中列表将由一组 ListNode （列表节点周围的标准包装器）组成。

City 是一个抽象类，因此有几个继承自它的类可以放入此列表中并进行多态访问。 List 类有一个 getHead() 方法，该方法返回一个指向作为头的 ListNode 的指针。

任何城市都有人口，因此要访问人口，我希望以下方法能够发挥作用。事实并非如此，因此我的问题是。我将其分解为几个部分，以使其更简单：

    ListNode<City *> *head= country->city_list->getHead();
    City *headnode = *head->getNode();

    cout << "Test: " << headnode->getPopulation() << endl;

getPopulation() 返回一个整数。 country 定义为 List； *city; 任何关于如何解决我的问题的帮助将不胜感激。

编辑添加更多代码以更好地了解我正在使用的内容。首先，ListNode：

template <class T>
class ListNode
{
public:
    ListNode() {next = 0;node = 0;};

    ListNode(T *t) {node = t; next = 0;};

    ListNode(const ListNode &l)
    {
        //long copy constructor. snip.
    };

    T *getNode() const { return node; }
    ListNode *getNext() const { return next; };

private:
    T *node;
    ListNode *next;
};

现在，这是 List 类中可能相关的内容。

template <class T>
class List
{
public:
    List()
    {
        head = 0;
        size = 0;
    };

    List(ListNode<T> *t)
    {
        head = t;
        size = 1;
    };

    List(T *t)
    {
        head = new ListNode<T>(t);
        size = 1;
    };

    List(const List<T> &t)
    {
        // long copy constructor. snip.
    };
    //bunch of irrelevent methods.


    ListNode<T> *getHead() const {return head;};

    List &operator+=(T &t)
    {
        this->insert(&t);
        size++;
        return (*this);
    };


private:
    List &insert(T *t)
    {
        ListNode<T> *current = head;
        if (current == 0)
        {
            head = new ListNode<T>(t);
        }
        else
        {
            while (current->getNext() != 0)
            {
                current = current->getNext();
            }
            current->setNext(new ListNode<T>(t));
        }
        return (*this);
    };

    ListNode<T> *head;
    int size;
};

我有预感，插入过程可能是问题所在。我使用 List 类的 += 运算符插入，如上面的 List 实现所示。它还调用上面所示的私有插入方法。它看起来像这样： 城市 *somecity = 新城市(x,y,z); //一些参数。整数。 *city_list += 某个城市； // 其中 city_list 是一个列表。

Answer 1

我认为您遇到了变量范围问题。

您的 ListNode 类包含指向节点值的指针。您的 ListNode 构造函数接受指向节点值的指针并保存它。

问题是，如果该指针指向一个局部变量，那么该变量就会超出范围。您的 ListNode 的节点指针现在指向一个不存在的对象。例如，在此示例中，

addToList(List<int>& myList)
{
    int x = 3;
    myList += x;  // pointer to x is in the list
}
// Out of scope; x no longer exists, but myList has a pointer to it.
// Accessing this node will result in an error.

有几种可能的补救措施：

1. 让您的 ListNode 包含值而不是指针。这里的缺点是您将
2. 使用引用计数智能指针来创建值 Implement ListNode 的副本，该指针将管理对象的生命周期。

Answer 2

那么，您可以做的是：

ListNode<City *>* head = new ListNode<City*>(country->city_list->getHead());
City* headnode = head->getNode();

cout << "Test: " << headnode->getPopulation() << endl;

它将获取现有的 City（在内存上）并将其放在 List 节点的头部，依此类推。

如果你想复制它们，也许你可以这样做：

ListNode<City *>* head = new ListNode<City*>*(new City(country->city_list->getHead()));
City* headnode = new City(head->getNode());

cout << "Test: " << headnode->getPopulation() << endl;

希望它能帮助你。