Chương 10 Một số chương trình hướng đối tượng trên C++ Các lớp ngăn xếp và hàng đợi

Các lớp ngăn xếp và hàng đợi
Chương trình tổ chức thành 4 lớp chính:
1. Lớp container (thùng chứa) gồm 2 thuộc tính:
unsigned long count; //Số phần tử trong thùng chứa
void (*errhandler)(); //Con trỏ tới hàm xử lý lỗi
2. Lớp s_list thừa kế từ lớp container, có thêm 2 thuộc tính các con trỏ kiểu
cấu trúc listnode:
struct listnode
{
void *dataptr;
listnode *next;
};
listnode *head; // Trỏ tới đầu danh sách
listnode *tail; // Trỏ tới cuối danh sách
Các phần tử được chứa trong lớp s_list dưới dạng một danh sách móc nối đơn.
Mỗi nút chứa địa chỉ của một phần tử. Do ở đây dùng kiểu con trỏ void nên có thể
đưa vào lớp s_list các phần tử có kiểu bất kỳ.
3. Lớp stack thừa kế từ lớp s_list
4. Lớp queue thừa kế từ lớp stack
Các lớp stack và queue không có các thuộc tính riêng. Hai phương thức quan
trọng của các lớp này là:
virtual int store(void *item) ; // Cất vào một phần tử
virtual void *retrieve () ; // Lấy ra một phần tử
Chú ý là: Lớp stack hoạt động theo nguyên tắc LIFO (vào sau ra trước) còn lớp
queue hoạt động theo nguyên tắc FIFO (vào trước ra trước) .
Chương trình sau minh hoạ cách dùng liên kết bội, phương thức ảo và con trỏ
kiểu void để quản lý các kiểu dữ liệu khác nhau.
Hoạt động của chương trình như sau:
+ Trước tiên lần lượt đưa địa chỉ của biến đối tượng ts1, chuỗi “HA NOI”, biến
nguyên a, biến đối tượng ts2 và biến thực x vào ngăn xếp s1 và hàng đợi q1.
+ Thực hiện phép gán các biến đối tượng:

s2 = s1 ;
q2 = q1 ;
+ Lấy các phần tử trong ngăn xếp s2 theo trình tự ngược với lúc đưa vào.
+ Lấy các phần tử trong hàng đợi q2 theo trình tự như lúc đưa vào.
/*
CT10_05.CPP
Lop vat chua (container)
Lop danh sach moc noi
Lop ngan xep
Lop hang doi
Chu y:
1. constructor sao chep cua lop dan suat
2. toan tu gan cua lop dan suat
3. co the dung cac phuong thuc khac
de viet constructor va destructor
4. Dung con tro this
*/
#include <stdio.h>
#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
#include <alloc.h>
#include <dos.h>
//Lop container
class container
{
protected:
unsigned long count; //so pt trong thung chua
void (*errhandler)();
public:

container();
container(const container &c); // Ham tao sao chep
void operator=(const container &c); // Gan
unsigned long getcount(); // Cho biet so phan tu
// Dinh ham xl loi
void seterrorhandler(void (*userhandler)());
// 4 phuong thuc thuan ao
virtual int store(void *item)=0;//Cat mot phan tu vao thung
virtual void *examine()=0; // Xem gia tri mot phan tu
virtual void *retrieve ()=0; // Lay mot pt ra
virtual void empty()=0; // Lam cho thung tro nen rong
};
// Cai dat
// Ham xl loi mac dinh
void defaulthandler();
void defaulthandler()
{
526
puts("\nContainer error: memory allocation failure");
}
container::container ()
{
count=0; errhandler= defaulthandler;
}
container::container(const container &c)
{
count=c.count; errhandler=c.errhandler;
}
// Gan
void container::operator=(const container &c)

{
count=c.count; errhandler=c.errhandler;
}
// Cho biet so pt
unsigned long container::getcount()
{
return count;
}
// Dinh ham xl loi
void container::seterrorhandler(void (*userhandler)())
{
errhandler=userhandler;
}
// Lop danh sach moc noi don
class s_list:public container
{
protected:
//Cau truc mot nut trong ds
struct listnode
{
void *dataptr;
listnode *next;
};
listnode *head;
listnode *tail;
private:
// phuong thuc sao chep
528
void copy(const s_list &s1);
public:

s_list();
s_list(const s_list &s1);
~s_list();
void operator=(const s_list &s1);
// 4 phuong thuc ao
virtual int store(void *item)=0; // Cat mot phan tu vao
// thung
virtual void *examine()=0; // Xem gia tri mot phan tu
virtual void *retrieve ()=0; // Lay mot pt ra
virtual void empty(); // Lam cho thung tro nen rong
};
//Cai dat
void s_list::copy(const s_list &s1)
{
head=NULL; tail=NULL;
listnode *temp = s1.head;
while(temp!=NULL)
{
if(head==NULL)
{
head= new listnode;
if(head==NULL) errhandler();
tail=head;
}
else
{
tail->next = new listnode;
if(tail->next == NULL) errhandler();
tail = tail->next;
}

tail->dataptr= temp->dataptr;
tail->next=NULL;
temp = temp->next;
}
}
// constructor
s_list::s_list() : container()
{
head=NULL; tail=NULL;
}
s_list::s_list(const s_list &s1):container(s1)
{
copy(s1);
}
s_list::~s_list()
{
this->empty();
}
void s_list::operator=(const s_list &s1)
{
this->empty();
count=s1.count;
copy(s1);
}
void s_list::empty()
{
listnode *q,*p;
p = head; head=NULL; tail=NULL;
while (p!=NULL)
{

q=p; p=p->next;
delete q;
}
}
// Lop stack
class stack:public s_list
{
public:
stack();
stack(const stack &st);
void operator=(const stack &st);
virtual int store(void *item); // Cat mot phan tu vao thung
virtual void *examine(); // Xem gia tri mot phan tu
virtual void *retrieve(); // Lay mot pt ra
};
stack::stack():s_list()
530