c++ - 我的 List<T> 实现有什么问题？

标签 c++ list

我创建了容器列表的一个小实现，它根据给定的测试 main() 执行某些功能。

我想给它添加一些额外的功能。主要是一个operator[]，和一个reverse()函数，用来倒序显示列表中的数字。

这是我的代码，所有带有注释的内容都是昨天添加的。

#include <iostream> 
#include <algorithm>

using namespace std;

template <class T> class Link;
template <class T> class List_iterator;
template <class T> class Reverse_iterator;

template <class T> 
class List
{
public:
   typedef List_iterator<T> iterator;

   List();
   List(const List<T> & l);
   ~List();

   bool empty() const;
   unsigned int size() const; 
   T & back() const;
   T & front() const;
   void push_front(const T & x);
   void push_back(const T & x);
   void pop_front();
   void pop_back();
   iterator begin() const;
   iterator end() const;
   iterator rbegin() const;//REVERSE BEGIN
   iterator rend() const; //REVERSE END
   void insert(iterator pos, const T & x);
   void erase(iterator & pos); 
   List<T> & operator=(const List<T> & l);
   List<T> & operator[] (unsigned int x);//OPERATOR []
   iterator reverse() const; //REVERSE 

protected:
   Link<T> * first_link;
   Link<T> * last_link;
   unsigned int my_size;
};

template <class T>
List<T>::List()
{
        first_link = 0;
        last_link = 0;
        my_size = 0;
}

template <class T>
List<T>::List(const List & l)
{
        first_link = 0;
        last_link = 0;
        my_size = 0;
        for (Link<T> * current = l.first_link; current != 0; current = current -> next_link)
                push_back(current -> value);
}

template <class T>
typename List<T>::iterator List<T>::begin() const
{
    return iterator(first_link);
}

template <class T>
typename List<T>::iterator List<T>::end() const
{
    return iterator (last_link);
}

//RBEGIN
template <class T>
typename List<T>::iterator List<T>::rbegin() const
{
    return iterator (last_link);
}

//REND
template <class T>
typename List<T>::iterator List<T>::rend() const
{
    return iterator(first_link);
}

template <class T> 
class Link 
{
private:
   Link(const T & x): value(x), next_link(0), prev_link(0) {}

   T value;     
   Link<T> * next_link;
   Link<T> * prev_link;

   friend class List<T>;
   friend class List_iterator<T>;
};

template <class T> class List_iterator
{
public:
   typedef List_iterator<T> iterator;

   List_iterator(Link<T> * source_link): current_link(source_link) { }
   List_iterator(): current_link(0) { }
   List_iterator(List_iterator<T> * source_iterator): current_link(source_iterator.current_link) { }

   T & operator*();
   iterator & operator=(const iterator & rhs);
   bool operator==(const iterator & rhs) const;
   bool operator!=(const iterator & rhs) const;
   iterator & operator++(); 
   iterator operator++(int);
   iterator & operator--(); 
   iterator operator--(int); 

protected:
   Link<T> * current_link;

   friend class List<T>;
};

template <class T>
T & List_iterator<T>::operator*()
{
        return current_link -> value;
}

template <class T>
List_iterator<T> List_iterator<T>::operator++(int)
{

}

template <class T>
List_iterator<T> & List_iterator<T>::operator--()
{
    current_link = current_link -> prev_link;
    return * this;
}

template <class T>
List_iterator<T> & List_iterator<T>::operator=(const iterator & rhs)
{
///???
}

template <class T>
List_iterator<T> List_iterator<T>::operator--(int)
{

}

template <class T>
List_iterator<T> & List_iterator<T>::operator++()
{
        current_link = current_link -> next_link;
        return *this;
}

template <class T>
void List<T>::push_back(const T & x)
{
    Link<T> * new_link = new Link<T> (x);
    if (first_link == 0)
    first_link = last_link = new_link;
    else
    {
    new_link->prev_link = last_link;
        last_link->next_link = new_link;    
        last_link = new_link;
    }
    my_size++;
}

template <class T>
List <T>::~List()
{
    Link <T> * first = first_link;
    while (first != 0)
    {
    Link <T> * next = first->next_link;
        delete first;
    first = next;
    }
}

template<class T>
bool List_iterator<T>::operator==(const iterator & rhs) const
{
    return ( this->current_link == rhs.current_link ); 
}

template <class T>
bool List_iterator<T>::operator!=(const iterator & rhs) const
{
    return !( *this == rhs );
}

//REVERSE ITERATOR
template <class T> class Reverse_iterator
{
public:
   typedef Reverse_iterator<T> riterator;

   Reverse_iterator(Link<T> * source_link): current_link(source_link) { }
   Reverse_iterator(): current_link(0) { }
   Reverse_iterator(List_iterator<T> * source_iterator): current_link(source_iterator.current_link) { }

   T & operator*();
   riterator & operator=(const riterator & rhs);
   bool operator==(const riterator & rhs) const;
   bool operator!=(const riterator & rhs) const;
   riterator & operator++(); 
   riterator operator++(int);
   riterator & operator--(); 
   riterator operator--(int); 

protected:
   Link<T> * current_link;

   friend class List<T>;
};

template <class T>
T & Reverse_iterator<T>::operator*()
{
        return current_link -> value;
}

template <class T>
Reverse_iterator<T> Reverse_iterator<T>::operator++(int)
{

}

template <class T>
Reverse_iterator<T> & Reverse_iterator<T>::operator--()
{
    current_link = current_link -> next_link;
    return * this;
}

template <class T>
Reverse_iterator<T> & Reverse_iterator<T>::operator=(const riterator & rhs)
{
//???
}

template <class T>
Reverse_iterator<T> Reverse_iterator<T>::operator--(int)
{

}

template<class T>
bool Reverse_iterator<T>::operator==(const riterator & rhs) const
{
    return ( this->current_link == rhs.current_link ); 
}

template <class T>
bool Reverse_iterator<T>::operator!=(const riterator & rhs) const
{
    return !( *this == rhs );
}


//REVERSE FUNCTION
template <class T>
List_iterator<T> List<T>::reverse() const
{
    iterator i, j;
    i = begin();
    j = end();
    for(; i != j; j++, j--)
    {
            T value = *j;
        *j = *i;
        *i = value;
    }
}

//OPERATOR []
template <class T>
List<T> & List<T>:: operator[] (unsigned int x)
{
    Link<T> * current = first_link;
    for(int i = 0; i != x && i < my_size; i++)
    current = current -> next_link;
    return current -> value;
    delete current;
}


//REVERSE ITERATOR OPERATOR ++()
template <class T>
Reverse_iterator<T> & Reverse_iterator<T>::operator++()
{
    current_link = current_link -> prev_link;
    return *this;
}

int main()
{
   List<int> l;

   l.push_back(44);
   l.push_back(33); 
   l.push_back(11); 
   l.push_back(22); 

   List<int> m(l);
   cout << "This is the original list" << endl;
   List<int>::iterator original(m.begin());
   while (original != m.end()) {
        cout << *original << endl;
        ++original;

   //cout << l[4]; //Not working

   //m.reverse();
   //cout << m;//Also Not working
   }
}

我正在寻求帮助:

  • 正在编写我的 operator=() 函数，该函数目前是空白的。
  • 通过查看我的 operator[] 定义和我的 了解为什么 main() 中的最后几行不起作用(我知道它们被注释掉了) >reverse() 函数。

提前致谢。

最佳答案

关于 List<T>::operator[]

我认为您的主要问题 operator[]是它的返回类型是 List<T>&而不是 T& .你想要你的 operator[]返回对 T 的引用，而不是对整个列表的引用。 Operator<<不知道如何处理 List<T> , 所以它提示。

另外:

  • 那个delete在operator[]是无法访问的代码。 (除了错误行为 - 为什么要删除链接？)

  • 你的 operator[]生成几个警告，因为 i是一个 int和 my_size是unsigned .很容易更正，见下文。

  • 如果像@stefaanv 提到的那样，当列表中只有 4 项时有人请求 myList[4](集合索引从零开始，记住，所以 [4] 是第五项。在您当前的逻辑中，将返回 myList[3] - 请仔细查看 for 循环中的条件。

这是我的想法operator[]应该看起来像:

template <class T>
T& List<T>:: operator[] (unsigned int x)
{
    if(x > (my_size - 1)
       || x < 0)
    {
        // throw a suitable exception - index out of bounds
    }

    Link<T> * current = first_link;
    for(unsigned int i = 0; i != x && i < my_size; i++)
       current = current -> next_link;
    return current -> value;
}

...并查看 here在 IdeOne 上。

关于 List<T>::reverse

首先要做的事 - 查看来自 List_iterator<T> List<T>::reverse() 的错误，您首先需要修复您的 main() :

  //m.reverse();
  //cout << m;//Also Not working

注意 m 的类型是 List<int> ，所以 cout行试图在您的 List<T> 上调用 << 操作符类 - 但没有一个，所以你会出错。您可以通过以下任一方式解决此问题:

  1. 定义 operator<<在你的 List<T>类
  2. 替换 cout与类似于 main() 中的 while 循环的循环行, 它逐项遍历列表。

一旦您执行了其中一项或另一项操作，您就会看到来自 reverse() 函数的真实错误消息。一方面，您已声明 reverse 返回 List_iterator<T> - 但它目前不返回任何东西!

希望对您有所帮助!祝你好运。

关于c++ - 我的 List<T> 实现有什么问题？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/5326923/

上一篇：c++ - 我如何在我的程序中使用这个单链表结构来提高我的性能？

下一篇：c++ - 基类中的 abc 接口(interface)继承和重新公开方法

相关文章：

Python 列表抽象

Python:计算允许联系的列表中项目的最大出现次数

python - 如何使用 `sum(iterable,[])` 展平嵌套列表？

c++ - 找到最大的连续子序列总和的开始和结束

c++ - 编译器的大括号初始化列表与类型 `std::initializer_list` 的耦合程度如何？

c++ - SFINAE 用于 CRTP 结构特征的特化

c++ - 如何理解is_callable的定义？

c++ - 如何在 Visual Studio 2012 中用 C++11 替换所有 BOOST_FOREACH？

c++ - 在哪里可以找到标准库中的 "taken"标识符列表

swift - IndexSet 引用部分的索引而不是行

©2024 IT工具网  联系我们