混合抽象类和模板，灾难的秘诀？

Question

我遇到了以下情况。我有三个班级参与了这个混淆。 List、ListNode、City。我有一个List<City *>，列表将由一组ListNode<City *>（列表节点周围的标准包装器）组成。

City 是一个抽象类，因此有几个继承自它的类可以放在这个列表中并以多态方式访问。 List 类有一个getHead() 方法，它返回一个指向ListNode 的指针，即头部。

任何城市都有人口，因此要访问人口，我希望以下内容可以工作。不是，因此我的问题。我把它分解成几块，以使其更简单：

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

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

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

edit 添加更多代码以更好地了解我正在使用的内容。一、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 = new City(x,y,z); //一些参数。整数。 *city_list += 某个城市； // 其中 city_list 是一个列表。

Answer 1

好吧，你可以做的是：

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;

希望对你有所帮助。

Answer 2

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

您的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. 使用将管理对象生命周期的引用计数智能指针实现ListNode。