OOPC—Linked List2

上一节中球员使用数组存储，数组的大小定为20，那么问题来了，加入一个球队的球员数大于20怎么办？我们是要定义足够大吗？定义100可以吗？当然可以，但是若有一个球队队员只有5个人时，剩余的空间是不是浪费了，那么我们有什么办法解决吗？当然有了，使用链表。
LList对象内含多态性链表（Linked List），能存不同类的对象，如果这些对象又具有多态性，就更能发挥巨大效益。现将上一节球队的实例里playes[]数组改为更具有弹性的LList集合对象。如下：
1、设计LList集合类接口

//接口实现
typedef struct
{
	void (*init)(void*);		//设定初始值
	void (*add)(void*,void*);	//把一个对象指针加入到list对象中
	void (*top)(void*);		//让cureent归零，如此确保下一个next能取出
	void* (*next)(void*);		//能依序取出下一个对象
	void* (*get)(void*,int);		//取出第n项对象
	
}IColl_t;

2、设计LList链表类

//链表的类
typedef struct List_Node List_Node;

typedef struct List_Node
{
	void *pItem;
	List_Node *next;
}List_Node;

3、设计集合类

//集合类
typedef struct
{
	IColl_t  coll;
	List_Node* Head;
	List_Node* Tail;
	List_Node* Current;
}Llist_t;

void *LlistNew();

4、实现链表集合类

#include <stdlib.h>
#include <stdio.h>
#include "Llist.h"

void * Llist_NodeNew()
{
	List_Node* t;
	t = (List_Node*)malloc(sizeof(List_Node));

	return (void*)t;
}
static void init(void *t)
{
	Llist_t* cthis = (Llist_t*)t;

	cthis->Head = NULL;
	cthis->Tail = NULL;
	cthis->Current = NULL;
}

static void add(void *t,void *pi)
{
	Llist_t*cthis = (Llist_t*)t;
	List_Node* pn ;
	pn = Llist_NodeNew();
	pn->pItem = pi;
	pn->next = NULL;

	if (cthis->Head == NULL)
	{
		cthis->Current = pn;
		cthis->Head = pn;
		cthis->Tail = pn;
	}
	else
	{
		cthis->Current = pn;
		cthis->Tail->next = pn;
		cthis->Tail = pn;
	}
	
}

static void top(void* t)
{
	Llist_t* cthis = (Llist_t*)t;

	cthis->Current= NULL;
}

static void* next(void *t)
{
	Llist_t* cthis = (Llist_t*)t;

	if (cthis->Current == NULL)
	{
		if (cthis->Head == NULL)
			return NULL;
		else
		{
			cthis->Current = cthis->Head;
			return cthis->Current->pItem;
		}
	}
	else
	{
		cthis->Current = cthis->Current->next;
		if (cthis->Current == NULL)
			return NULL;
		return cthis->Current->pItem;
	}
}

static void* get(void* t,int k)
{
	Llist_t* cthis = (Llist_t*)t;
	List_Node* pn;
	int i;

	if (cthis->Head == NULL)
		return NULL;
	pn = cthis->Head;

	for (i =0; i < k; i++)
	{
		pn = pn->next;
		if (pn == NULL)
			return NULL;
	}
	return pn->pItem;
}

void *LlistNew()
{
	Llist_t* t;

	t = (Llist_t*)malloc(sizeof(Llist_t));

	t->coll.init = init;
	t->coll.add = add;
	t->coll.top = top;
	t->coll.next = next;
	t->coll.get = get;

	return (void*)t;
}

上面实现有点难度，建议先学习链表基础知识，我回头又看了看链表知识。
5、设计并实现球队类

#include "Llist.h"
#include <stdlib.h>
#include <stdio.h>

typedef struct
{
	void (*init)(void *);
	void (*setManager)(void*, char*);
	void (*setCoach)(void*, char*);
	void (*addPlayer)(void*, char*);
	void (*diapaly)(void*);
	char *manager,*coach;
	IColl_t *players;
}BaseballTeam;

static void init(void* t)
{
	BaseballTeam* cthis = (BaseballTeam*)t;

	cthis->manager = NULL;
	cthis->coach = NULL;
	cthis->players = (IColl_t*)LlistNew();
	cthis->players->init(cthis->players);
		
}

static void setManager(void* t, char* manager)
{
	BaseballTeam* cthis = (BaseballTeam*)t;

	cthis->manager = manager;
}

static void setCoach(void* t, char* coach)
{
	BaseballTeam*cthis = (BaseballTeam*)t;

	cthis->coach = coach;
	
}

static void addPlayer(void* t, char* players)
{
	BaseballTeam* cthis = (BaseballTeam*)t;

	IColl_t *list = cthis->players;
	list->add(list,(void*)players);
}
static void display(void* t)
{
	BaseballTeam* cthis = (BaseballTeam*)t;
	IColl_t* list;
	char *text;

	printf("this team Manager is %s\n",cthis->manager);
	printf("this team Coach is %s\n",cthis->coach);
	list = cthis->players;
	list->top(list);
	text = (char*)list->next(list);
	while(text != NULL)
	{
		printf("%s\n",text);
		text = (char*)list->next(list);
	}
}

void *BaseballTeamNew(void)
{
	BaseballTeam *t;
	t = (BaseballTeam*)malloc(sizeof(BaseballTeam));

	t->init = init;
	t->setCoach = setCoach;
	t->addPlayer = addPlayer;
	t->setManager = setManager;
	t->diapaly = display;

	return (void*)t;
	
}

int main(void)
{
	BaseballTeam* Redteam;

	Redteam =(BaseballTeam* ) BaseballTeamNew();
	Redteam->init(Redteam);

	Redteam->setCoach(Redteam,"Jodan");
	Redteam->setManager(Redteam,"KOBI");
	Redteam->addPlayer(Redteam,"JAMES");
	Redteam->addPlayer(Redteam,"Daweisi");
	Redteam->addPlayer(Redteam,"Tomas");

	Redteam->diapaly(Redteam);
	
	return 0;
}

在VC6.0中运行结果如下：

总结：players的类型为IColl*，表示players是LList集合对象的指针，指令cthis->players = (IColl*)LListNew(),生成LList的集合对象，并使players指向此对象。
集合对象能容纳不同类的对象，而且不限个数，能视需求不断扩充。由于List对象自动扩大，此时不必烦恼到底有多少球员。addplayer()将球员统统存入集合对象中，此外，在display()函数里，使用while循环能轻易的显示出集合对象的内容。