构造函数和析构函数的链表问题

Question

嗨 我有一些关于构造函数和析构函数的问题。我有一个列表类，它有两个内部类，一个用于列表节点的私有类和一个公共迭代器类。

现在针对这个问题，我编写了一个使用内部迭代器类的非成员打印函数。当我使用这个非成员函数时，它将结束调用迭代器的析构函数。但它并没有在这里结束，因为出于某种原因它也会调用列表类的析构函数。当我想再次打印列表内容时，这会导致一些问题。

我不明白为什么它也调用列表类析构函数，想知道是否有人可以告诉我，以及我应该如何解决它。

我已经附上了与问题相关的所有代码

主要

#include <iostream>

#include "sorted_list.h"
#include "iterator.h"
using namespace std;

void list_print(ostream& os, sorted_list list)
{
    sorted_list::iteratorn it(&list);

    while( ! it.iterator_end())
    {
        os <<   "key = " << setw(3) << it.iterator_get_key()   << ", "
        << "value = " << setw(5) << it.iterator_get_value() << endl;
        it.iterator_next();
    }

    os << endl;
}

int main()
{


    sorted_list a;
    a.insert(4,4);
    a.insert(5,5);


    list_print(cout,a);
    list_print(cout,a);
}

sorted_list.cc

#include "sorted_list.h"

sorted_list::sorted_list()
{
    cout << "construct sorted_list" << endl;
    this->first = 0;
}
sorted_list::~sorted_list()
{
    cout << "destruct sorted_list" << endl;
    destroy(this->first);

}

void sorted_list::destroy(list_link* item)
{
    cout << "destroy list_link" << endl;
    if(item)
    {
        destroy(item->next);
        delete item;
    }

}

void sorted_list::insert(int key, double value)
{
    list_link *curr;
    list_link *prev = 0;

    curr = first;

    while(curr)
    {
        if(value < curr->value)
            break;

        prev = curr;
        curr = curr->next;
    }
    if(this->first == 0 || prev == 0) //if empty or add first
    {
        //first = create(key, value, this->first);
        first = new list_link(key, value, this->first);
    }
    else if(curr == 0)
    {
        //prev->next = create(key, value, 0);
        prev->next = new list_link(key, value, 0);
    }
    else
    {
        //prev->next = create(key, value, curr);
        prev->next = new list_link(key, value, curr);
    }
}

void sorted_list::remove(my_key_type key)
{
    list_link *curr = first;;
    list_link *prev = 0;

   while(curr)
   {
      if(curr->key == key)
      {
         list_link *remove;

         if(prev == 0)
         {
            first = curr->next;
            delete curr;
            curr = first;
         }
         else
         {
            remove = curr;
            curr = curr->next;
            prev->next = curr;
            delete remove;
         }
         continue;
      }
      prev = curr;
      curr = curr->next;
   }
}


sorted_list::list_link* sorted_list::clone(list_link* item)
{
   list_link* copyItem= new list_link(item->key,item->value,0);
   if(item->next!= 0)

      copyItem->next=clone(item->next);
   return copyItem;
    // ADD YOUR CODE HERE ( 4 well formatted lines in reference solution )

}

void sorted_list::copy(sorted_list* my_this_destination)
{
  if (my_this_destination->first == 0) // copy if empty
  {
      cout << "Copy" << endl;
    //list_destroy(my_this_destination);
    my_this_destination->first = clone(first);
  }
}

double sorted_list::find(int key)
{
    list_link *travel = this->first;
    while(travel)
    {
        cout << travel->key << "==" << key << endl;
        if(travel->key == key)
            return travel->key;

        travel = travel->next;
    }
    return -1;
}

int sorted_list::size()
{
    list_link *travel = this->first;
    int i = 0;
    while( travel )
    {
        travel = travel->next;
        i++;
    }
    return i;
}

sorted_list.h

#ifndef _SORTED_LIST_H_
#define _SORTED_LIST_H_

#include <iostream>

#include <iomanip>
using namespace std;

typedef int     my_key_type;
typedef double  my_value_type;

class sorted_list
{

public:
    sorted_list(); 
    ~sorted_list();

    void insert(int key, double value);
    void remove(my_key_type key);
    void copy(sorted_list* my_this_destination);
    void destroy();
    void init(struct my_list* my_this);
    void print();
    void print2();
    double find(int key);
    int  size();

private:
    class list_link // An inner class inside sorted_list
    {
    public:
        list_link (my_key_type key, my_value_type value, list_link* next = 0);
        ~list_link();
        my_key_type key;
        my_value_type value;
        list_link *next;
    };

    list_link* first;
    list_link* clone(list_link* item);
    void destroy(list_link* item);
    // More declarations

public:
    class iteratorn
    {
    public:
        iteratorn();
        ~iteratorn();
        iteratorn(sorted_list *item);
        list_link* list_begin();
        bool iterator_end();
        void iterator_next();
        int iterator_get_key();
        double iterator_get_value();

    private:
        sorted_list::list_link* current;
    };
};


#endif

iteratorn.cc

#include "iterator.h"
#include "sorted_list.h"

 sorted_list::iteratorn::iteratorn()
 {
 }
sorted_list::iteratorn::iteratorn(sorted_list *list)
{
    cout << "construct iteratorn" << endl;
    this->current = list->first;
}

sorted_list::iteratorn::~iteratorn()
{
    cout << "destruct iteratorn" << endl;
}

sorted_list::list_link* sorted_list::iteratorn::list_begin()
{
    return current;
}

void sorted_list::iteratorn::iterator_next()
{
  current = current->next;
}

int sorted_list::iteratorn::iterator_get_key()
{
  return current->key;
}

double sorted_list::iteratorn::iterator_get_value()
{
  return current->value;
}

list_link.cc

#include "sorted_list.h"


sorted_list::list_link::list_link(my_key_type key, my_value_type value, list_link* next)
{
    this->key = key;
    this->value = value;
    this->next = next;
}

sorted_list::list_link::~list_link()
{
    cout << "list_link destructor" << endl;
}

Answer 1

您的函数void list_print(ostream& os, sorted_list list) 通过复制获取sorted_list 参数。一个快速而肮脏的修复（出于性能原因，无论如何你都应该这样做）如下：

void list_print(ostream& os, const sorted_list& list)

现在，您的 iteratornclass 采用 可变 列表，因此这不会像您预期的那样工作。您将有很多方法可以更改以完成这项工作。

无论如何，你真正的问题是缺少合适的复制构造函数。现在，当你“复制”一个列表时，两者最终共享相同的元素，但你的析构函数被编写为好像每个列表都拥有它自己的节点。定义正确的复制操作，它将解决您的问题。

关于如何解决问题的详细帮助：（未经测试）

更改签名：

void list_print(ostream& os, const sorted_list& list);

声明+定义复制构造函数：

sorted_list::sorted_list (const sorted_list& other);

更改iteratorn 接口以支持const sorted_list：

class sorted_list::iteratorn
{
public:
    iteratorn();
    ~iteratorn();
    iteratorn(const sorted_list& list);
    const list_link* list_begin() const;
    bool iterator_end() const;
    void iterator_next();
    int iterator_get_key() const;
    double iterator_get_value() const;

private:
        // You *should* make this `const` but it is not required.
    sorted_list::list_link* current;
};

如您所见，更改相当小，但需要在不同的地方应用。

const + 非const 迭代器：

我在此处应用更改是基于您的 iteratorn 当前仅在您的 sorted_list 上定义只读操作。如果您想支持写访问以允许更改存储在列表节点中的值（从不 允许更改键，否则您将不再有 排序 列表），您应该定义两个迭代器类。有关详细信息，请参阅 STL 迭代器接口。

Answer 2

您正在按值复制列表，因此list_print() 中的本地副本在范围结束时会破坏。改为通过 const-reference 传递它。

这反过来意味着您必须更改您的 sorted_list 以支持使用 const 列表。特别是你需要有一个函数返回一个指向列表开头的 const 迭代器：

sorted_list::const_iteratorn begin() const
{
    // returns a const_iteratorn pointing at the beginning of this list
}

请注意，您需要一种新的迭代器：const_iteratorn，它保证不会更改列表。

然后，在 print_list() 内部使用 sorted_list 返回的起始迭代器初始化一个 const_iteratorn，复制：

sorted_list::const_iteratorn s(list.begin());

最后创建第二个迭代器实例，该实例使用来自sorted_list 的成员函数的结束迭代器进行初始化，类似于begin() 函数。这将保持print_list() 中的常量正确性。

sorted_list::const_iteratorn e(list.end());
while( s != e ) {       // two iterators should be able to compare
    // ...
    s.iterator_next();  // consider ++s
}

此外，正如 André 所提到的，您没有适当的复制构造函数和赋值运算符这一事实是一个严重的问题。确保复制sorted_list 意味着复制其所有元素，以便新对象拥有自己的元素列表。记得Rule of Three。