C++基于双向链表的List

Posted 2023-05-09

template <class List_entry>
List<List_entry> :: List(const List<List_entry> ©)

int i;
Node<List_entry>*copy_node=copy.head;
//*new_copy,
if(copy.head==NULL)
head=NULL;
else

head=new_copy=new Node<List_entry>(copy_node->entry);
new_copy->back=NULL;
while(copy_node->next!=NULL)

copy_node=copy_node->next;
new_copy->next=new Node<List_entry>(copy_node->entry);
new_copy->next->back=new_copy;
new_copy=new_copy->next;

new_copy->next=NULL;


这是本人自己写的一个C++双向链表的list的拷贝构造函数，问题在于计算机会跳过这部分，直接不执行，不知道问题出在哪里，请高手指明
我不需要所谓的其他的正确答案，只希望能在我的源代码上进行修改，指出问题，谢谢
对不起，那个注释（//*new_copy）是我做测试后忘复原留下的，应该没有//的，这是一个和上一行指针一起定义的指针，而不是没有*/的/*

参考技术A 编程里面有两种注释，一种是“//”行注释，指该行代码无需编译执行，另一种是“/*”和“*/”，多行注释，位于这两个符号间的所有文字都无需编译执行。
代码的问题在于 //*new_copy,而没有“*/”，也就是说，在“/*”之后的所有代码都不会得到编译和执行。追问

对不起，那个注释是我做测试后忘复原留下的，应该没有//的，这是一个和上一行指针一起定义的指针，而不是没有*/的/*

参考技术B 首先 参数应该是copy吧
lz说的不执行是什么意思？
假设有List L1; List L2(L1);那运行的什么结果呢追问

是的，是copy……不知道怎么成乱码了……List L2（L1）;不会被执行，main函数里我在List L2（L1）;后有一句输出全部链表，但是失败了，用于输出的那个函数是绝对没有问题的，所以是List L2（L1）;完全没有执行

双向链表的基础操作（C++实现）

★C++实现双向链表的基础操作（类的实现）

#include<iostream>
#include<cassert>
using namespace std;

typedef int DataType;
class double_link_list
{                        //定义双向链表类，包括了双向的前驱和后继指针，以及对象的初始化
public:
friend class ListNode;
double_link_list(DataType x = 0)
:_data(x)
,_next(NULL)
,_prev(NULL)
{}
private:
double_link_list* _prev;
double_link_list* _next;
DataType _data;
};



class ListNode
{
public:        //注意上一类中的friend关键字，友元函数，否则该类无法访问其类的private成员

ListNode()     //构造函数
:_head(NULL)
,_tail(NULL)
{
}


~ListNode()//析构函数
{
Clear();//清除函数
}


ListNode(const ListNode& list)        //拷贝构造函数
{
double_link_list *cur = list._head;
while (cur)
{
PushBack(cur->_data);
}
}



ListNode operator = (ListNode list)    //赋值运算符重载函数
{
double_link_list *cur = list._head;
while (cur)
{
PushBack(cur->_data);
}
}
public:

//尾插
void PushBack(const DataType& x);

//尾删
void PopBack();

//头插
void PushFront(const DataType& x);

//头删
void PopFront();

//指定位置插入节点
void Insert(double_link_list* pos, const DataType& x);

//查找节点函数
double_link_list* Find(const DataType& x);

//删除节点函数
void Erase(const DataType& x);

//逆置链表函数
void Reverse();

//输出函数
void Print();

private:
void Clear()
{
while (_head)
{
double_link_list* cur = _head;
_head = _head->_next;
delete cur;
}
}
double_link_list *_head;
double_link_list *_tail;
};



//尾插
void ListNode::PushBack(const DataType&x)    //注意域作用符的添加，否则只得在类体中定义
{
if (_head == NULL)
{
_tail = _head = new double_link_list(x);
_head->_next = NULL;
_head->_prev = NULL;
}
else
{
_tail->_next = new double_link_list(x);
_tail->_next->_prev = _tail;
_tail = _tail->_next;
}
}


//头插
void ListNode::PushFront(const DataType&x)
{
double_link_list* cur = new double_link_list(x);
if (_head == NULL)
{
_tail = _head = cur;
}
else
{
cur->_next = _head;
cur->_next->_prev = cur;
_head = cur;
}
}



//尾删
void ListNode::PopBack()
{
if (_tail)
{
double_link_list *cur = _tail;
_tail = _tail->_prev;
_tail->_next = NULL;
delete cur;
}
}



//头删
void ListNode::PopFront()
{
if (_head)
{
double_link_list *cur = _head;
_head = _head->_next;
_head->_prev = NULL;
delete cur;
}
}



//指定位置插入节点
void ListNode::Insert(double_link_list* pos, const DataType& x)
{
assert(_head);
double_link_list *cur = _head;
while (cur)
{
if (cur == pos)
{
if (cur == _tail)
{
PushBack(x);
}
else
{
double_link_list *tmp = new double_link_list(x);
tmp->_next = cur->_next;
tmp->_prev = cur;
tmp->_next->_prev = tmp;
cur->_next = tmp;
}
return;
}
cur = cur->_next;
}
}



//查找指定节点
double_link_list* ListNode::Find(const DataType& x)
{
double_link_list* cur = _head;
while (cur)
{
if (cur->_data == x)
return cur;
cur = cur->_next;
}
return NULL;
}




//删除某一节点
void ListNode::Erase(const DataType &x)
{
double_link_list *cur = _head;
while (cur)
{
if (cur->_data == x)
{
double_link_list* tmp = cur;
cur->_prev->_next = cur->_next;
cur->_next->_prev = cur->_prev;
cur = cur->_next;
delete tmp;
}
}
}




//逆置双向链表
void ListNode::Reverse()
{
std::swap(_head, _tail);
double_link_list* cur = _head;
while (cur)
{
std::swap(cur->_next, cur->_prev);
cur = cur->_next;
}
}



//输出双向链表
void ListNode::Print()
{
double_link_list* cur = _head;
while (cur)
{
cout << cur->_data << "->";
cur = cur->_next;
}
cout << "NULL" << endl;
}

本文出自 “温暖的微笑” 博客，谢绝转载！