Question

C++难题，定义一个图书结构（或图书类

2、 图书馆藏书管理系统
基本功能要求：图书信息包括：图书号、书名、作者、出版社、共有存书量。
要求能够：
（1） 添加图书记录
（2） 浏览所有图书信息
（3） 按图书号或书名查找图书信息
（4） 修改图书记录
扩展功能要求：（1） 删除图书记录
（2） 按书名对图书信息进行排序浏览
（3） 实现可视化
提示：定义一个图书结构（或图书类），其中包含图书的各项信息。然后定义该图书结构的结构数组（或图书类的类对象数组）存放所有图书信息。

Answer 1

//class CList.h
#ifndef __CLIST_H__
#define __CLIST_H__

#include <iostream>
using namespace std;

#define LENGTH 100 // 表的长度，根据实际情况而定
typedef char DataType; //// 数据类型，根据实际情况而定

typedef class CList
{
private:
DataType m_Data[LENGTH]; //顺序表内存放元素的数组
int m_Length; //标识顺序表长度个数的成员
public:
CList(); //构造函数
~CList(); //析构函数
void CreateList(); //初始化顺序表的成员函数
void SetData(DataType _Data, int _nIndex); //用来设置顺序表内某指定元素的成员函数
DataType GetData(int _nIndex); //拿取顺序表内某指定位置元素的成员函数
bool SetLength(int _nIndex); //设置顺序表内元素个数的成员函数
int GetLength(); //拿取顺序表内元素个数的成员函数
bool InsertList(DataType _Data, int _nIndex); //在顺序表中某指定位置插入新元素的成员函数
bool DeleteList(int _nIndex); //删除循序表中某指定位置的元素的成员函数
void ShowList(); //显示顺序表的成员函数
}SeqList; //typedef定义的 CList类的小名为SeqList

#endif
//class CLinkList
#ifndef __CLINKLIST_H__
#define __CLINKLIST_H__

#include "CNode.h"

typedef class CLinkList
{
private:
CNode* m_Head; //链表的头指针
CNode m_Node; //链表的头结点
public:
CLinkList(); //构造函数
~CLinkList(); //析构函数
void CreateList(); //初始化链表的函数成员
LinkNode* GetListNode(DataType _Temp); //按元素查找指定位结点的成员函数
LinkNode* GetListNode(int _nIndex); //按位置查找指定位结点的成员函数
void InsertList(int _nIndex, DataType _Temp); //插入结点的成员函数
void DeleteList(int _nIndex); //删除某一结点的成员函数
LinkNode* GetHeadList(); //获取头指针的成员函数
void SetListData(int _nIndex, DataType _Temp); //设置链表中某一结点的值的成员函数
DataType GetListData(int _nIndex); //获取链中某一结点值的成员函数
void DestroyList(int _nIndex); //销毁某一位置以后链表的成员函数
void ShowList(); //显示链表的成员函数
}LinkList;

#endif

//class CLinkList

#include "CLinkList.h"
#include "CNode.h"

CLinkList::CLinkList()
{
cout << "这个是构造函数"<< endl;

m_Head = &m_Node; //链表的头指针指向头结点
m_Node.SetNodeData(0); //给头结点的内容赋0值
m_Node.SetNodeNext(NULL); //将头结点的Next指针设置为NULL;
}

CLinkList::~CLinkList()
{
cout << "这个是析构函数" << endl;
}

void CLinkList::CreateList() //以向后追加的方式创建一个链表，输入0退出
{
DataType Temp = 0;

cout << "欢迎来创建链表 !" << endl;
CNode * pTemp = NULL; //定义一个临时结点指针，用来增加新结点用
CNode * pNode = m_Head; //定义一个标记指针，首先叫其指向头结点

while(1)
{
pTemp = new CNode;

cout << "请输入下一个结点的内容!" << endl;
cin >> Temp;
if ('0' == Temp) //输入0退出
{
break;
}

pTemp->SetNodeData(Temp); //给新结点的内容赋0值
pNode->SetNodeNext(pTemp); //让链尾的Next指向新建的结点
pNode = pTemp; //将结尾元素向后移
}
cout << "创建链表结束" << endl;
}

LinkNode* CLinkList::GetListNode(DataType _Temp)
{
cout << "这个是按元素查找结点位置的成员函数" << endl;

LinkNode* pNode = m_Head->GetNodeNext(); //定义一个临时的结点指针,初始化指向头结点

while(pNode != NULL)
{
if(_Temp == pNode->GetNodeData())
{
return pNode;
}
pNode = pNode->GetNodeNext(); //临时结点向后移动
}

return pNode; //没找到结点就返回NULL
}

LinkNode* CLinkList::GetListNode(int _nIndex)
{
cout << "这个是按位置查找指定位结点的成员函数" << endl;

LinkNode* pNode = m_Head->GetNodeNext(); //定义一个临时的结点指针,初始化指向头结点
int Temp = 0; //定义一个临时的变量，用来标记已检查结点的个数的

if(-1 == _nIndex) //返回头结点（即头指针）
{
return m_Head;
}

if(_nIndex < -1) //_nIndex控制条件
{
cout << "您输入的是错误的位置！" << endl;
return 0;
}

while(pNode != NULL)
{
if(_nIndex == Temp)
{
return pNode;
}
pNode = pNode->GetNodeNext(); //临时结点向后移动
++Temp;
}

return pNode; //没找到结点就返回NULL

}

void CLinkList::InsertList(int _nIndex, DataType _Temp) //插入结点的函数成员
{
cout << "这个是插入结点的成员函数" << endl;

CNode *pNode = GetListNode(_nIndex - 1); //定义一个结点类的指针，指向的是要插入位置的前一指针

CNode * pTemp = new CNode; //定义一个临时结点指针，用来增加新结点用

pTemp->SetNodeData(_Temp); //设置插入结点的内容

pTemp->SetNodeNext(pNode->GetNodeNext());
pNode->SetNodeNext(pTemp);
}

void CLinkList::DeleteList(int _nIndex)
{
cout << "这个是删除某一结点的成员函数" << endl;

CNode *pNode = GetListNode(_nIndex - 1); //定义一个结点类的指针，指向的是要删除位置的前一指针
CNode * pTemp = NULL; //定义一个临时结点指针，用来指向要删除的结点

pTemp =pNode->GetNodeNext(); //把pTemp指向要删除的结点

pNode->SetNodeNext(pTemp->GetNodeNext()); //把pNode指向要删除的结点的后一个结点

delete pTemp; //删除结点
pTemp = NULL;
}

LinkNode* CLinkList::GetHeadList()
{
cout << "这个是获取头指针的成员函数" << endl;

return m_Head;
}

void CLinkList::SetListData(int _nIndex, DataType _Temp)
{
cout << "这个是设置链表中某一结点的值的成员函数" << endl;

CNode *pNode = GetListNode(_nIndex); //定义一个结点类的指针，指向的是要修改内容位置的结点

pNode->SetNodeData(_Temp); //修改内容

}

DataType CLinkList::GetListData(int _nIndex)
{
cout << "这个是获取链中某一结点值的成员函数" << endl;

CNode *pNode = GetListNode(_nIndex); //定义一个结点类的指针，指向的是要获取内容位置的结点

return pNode->GetNodeData(); //返回想要得到位置的结点内容
}

void CLinkList::DestroyList(int _nIndex)
{
cout << "这个是销毁某一位置以后链表的成员函数" << endl;

LinkNode* pTemp = GetListNode(_nIndex - 1); //定义一个结点指针，指向要销毁位置的前一结点
LinkNode* pNode = pTemp->GetNodeNext(); //定义一个结点指针，指向要销毁位置的结点

while(pTemp->GetNodeNext() != NULL) //销毁动作的结束条件或初始条件
{
pTemp->SetNodeNext(pNode->GetNodeNext()); //把需要销毁的位置的前结点的Next指向销毁位置的下一个结点
delete pNode; //销毁结点

pNode = pTemp->GetNodeNext(); //把pNode重新指向要销毁位置的结点
}
}

void CLinkList::ShowList()
{
cout << "这个是显示链表的成员函数" << endl;

int nTemp = 0; //定义一个临时的整形变量用来控制输入的个数

LinkNode* pTemp = m_Head->GetNodeNext(); //定义一个结点类指针，指向第0位的结点
if(NULL == pTemp)
{
cout << "这是个空链" << endl;
}

while(pTemp != NULL)
{
cout << pTemp->GetNodeData() << '\t';

++nTemp;
if(0 == nTemp % 5 && nTemp != 0) //控制每行只能输出5个结点的内容
{
cout << endl;
}

pTemp = pTemp->GetNodeNext();
}
}

//class CNode
#include "CNode.h"

CNode::CNode()
{
m_Data = 0;
m_Next = NULL;
}

CNode::~CNode()
{
}

void CNode::SetNodeData(DataType _Data)
{
m_Data = _Data;
}

DataType CNode::GetNodeData()
{
return m_Data;
}

void CNode::SetNodeNext(CNode* _Next)
{
m_Next = _Next;
}

CNode* CNode::GetNodeNext()
{
return m_Next;
}

#include "CLinkList.h"
#include "CNode.h"

DataType SeqSearch(LinkList &_LinkList, int _nIndex); //顺序查询函数声明，作用是输入要查询链的坐标，返回此处的内容
void Text(); //测试函数声明

int main()
{
cout << "这是mian函数" << endl;
Text();
return 0;
}

DataType SeqSearch(LinkList &_LinkList, int _nIndex) //_LinkList为链表的引用
{
cout << "这个是顺序查找函数" << endl;

LinkNode* pNode = NULL; //声明一个临时的结点指针

pNode = _LinkList.GetListNode(_nIndex); //获得想要查询位置的结点指针

return pNode->GetNodeData(); //返回说要查询位置的内容
}

void Text()
{
cout << "这个是测试函数" << endl;

LinkList* pList = new LinkList; //创建一个内存链表对象

cout << "------------------CreateList-----------------------------" << endl;
pList->CreateList(); //初始化链表的函数成员
pList->ShowList();
cout << endl;

cout << "------------------GetListNode-----------------------------" << endl;
LinkNode* pNode = NULL; //定义一个临时的结点类指针用于检测查找函数成员
pNode = pList->GetListNode('a'); //按元素查找指定位结点的成员函数的测试

if(pNode)
{
cout << "用按元素查找的方法找到了指定位结点" << endl;
}
else
{
cout << "对不起，用按元素查找的方没有找到指定位结点" << endl;
}
cout << endl;

pNode = NULL; //pNode先置空
pNode = pList->GetListNode(3); //按位置查找指定位结点的成员函数的测试

if(pNode)
{
cout << "用按位置查找的方法找到了指定位结点" << endl;
}
else
{
cout << "对不起，用按位置查找的方没有找到指定位结点" << endl;
}
cout << endl;

cout << "------------------InsertList-----------------------------" << endl;
pList->InsertList(0, 'x'); //插入结点的成员函数的测试
pList->ShowList();
cout << endl;

cout << "------------------DeleteList-----------------------------" << endl;
pList->DeleteList(0); //删除某一结点的成员函数的测试
pList->ShowList();
cout << endl;

cout << "------------------GetHeadList-----------------------------" << endl;
pNode = NULL;
pNode = pList->GetHeadList(); //获取头指针的成员函数的测试
if(pNode)
{
cout << "已经返回了头指针" << endl;
}
else
{
cout << "对不起，头指针为空" << endl;
}
cout << endl;

cout << "------------------GetHeadList-----------------------------" << endl;
pList->SetListData(3, '@'); //设置链表中某一结点的值的成员函数的测试
pList->ShowList();
cout << endl;

cout << "------------------GetListData-----------------------------" << endl;
cout << "pList->GetListData(3) =" << pList->GetListData(3) << endl; //获取链中某一结点值的成员函数的测试
cout << endl;

cout << "------------------SeqSearch-----------------------------" << endl; //顺序查询的测试
cout << "SeqSearch(pList, 3) =" << SeqSearch(*pList, 3) << endl;
cout << endl;

cout << "------------------DestroyList(3)-----------------------------" << endl;
pList->DestroyList(3); //销毁第3位置以后链表的成员函数的测试
pList->ShowList();
cout << endl;

cout << "------------------DestroyList(0)-----------------------------" << endl;
pList->DestroyList(0); //销毁第0位置以后链表的成员函数的测试
pList->ShowList();
cout << endl;

delete pList; //释放内存
pList = NULL; //指针置空

}

这个是我写的链表程序 ， 你可以把你的图书信息加到我CNODE类中， 自己简单的改改就可以， ，，接口很全的，而且可以随时向里面加书 的很方便的