Phần 1: Xây dựng stack bằng danh sách liên kết đơn Dùng kỷ thuật template để xây dựng một stack có thể lưu trữ bất kỳ. ở đây T là kiểu bất kỳ template <class T> class Stack{ private: struct Node{ T info; Node *next; }; Node *top; void makeEmpty( ); //Làm rỗng từ 1 stack đã có public: Stack( ); // C O N S T R U C T O R Stack( const Stack & ); // C O P Y C O N S T R U C T O R ~Stack( ); // DES T R U C T O R bool isEmpty( ) ; //Kiểm tra Stack rỗng? T & topOfStack( ); //Trả về phần tử ở đỉnh stack void pop( ); //Lấy ra khỏi stack phần tử ở đỉnh stack void push( T ); //Thêm 1 phần tử kiểu T vào stack Stack & operator=( Stack & ); // O V E R L O A D E D "=" O P E R A T O R }; 1. C O N S T R U C T O R Mục đích: tạo một ngăn xếp rỗng không có phần tử nào Sử dung: Stack <kiểu> S; Đầu vào: Không có Đầu ra: một ngăn xếp S rỗng dùng để chứa kiểu T Code: template <class T> Stack<T>::Stack(){ top = NULL; } 2. C O P Y C O N S T R U C T O R Mục đích: tạo một ngăn xếp giống như một ngăn xếp S1 đã có sẵn Sử dung: Stack <kiểu> S ( S1); Đầu vào: Ngăn xếp S1 đã tồn tại Đầu ra: một ngăn xếp S giống như ngăn xếp S1 nhưng dữ liệu ở 2 vị trí bộ nhớ khác nhau Code: template <class T> Stack<T>::Stack(const Stack &s){ top = NULL; while(!s.isEmpty()){ this->push(s.topOfStack()); s.pop(); } } 3. DES T R U C T O R Mục đích: Hũy một ngăn xếp khi phạm vi sử dụng của nó hết Sử dung: chương trình tự gọi template <class T> Stack<T>::~Stack(){ makeEmpty(); } 4. Kiểm tra Stack rỗng? Mục đích: Kiểm tra một stack S có rỗng không Sử dụng: S.isEmpty(); Đầu vào: một stack S bất kỳ Đầu ra: trả về true nếu S không có phần tử nào, ngược lại là false Code: template <class T> bool Stack<T>::isEmpty() { return top == NULL; } 5. Trả về giá trị phần tử ở đỉnh stack Mục đích: Trả về giá trị trên cùng của satck S Sử dụng: S.topOfStack(); Đầu vào: một stack S bất kỳ Đầu ra: trả về về giá trị ở đỉnh stack S nếu S không rỗng Code: template <class T> const T & Stack<T>::topOfStack() { if(isEmpty()) {cout<<endl<<"empty stack !"; exit(0);} return top->info; } 6. Làm rỗng từ 1 stack đã có Mục đích: Làm rỗng một stack S để tối ưu bộ nhớ khi cần thiết Sử dụng: S.makeEmpty(); Đầu vào: một stack S bất kỳ Đầu ra: stack S rỗng Code: template <class T> void Stack<T>::makeEmpty(){ while(!isEmpty()) pop(); } 7. Lấy ra khỏi stack phần tử ở đỉnh stack Mục đích: Loại 1 phần tử của stack S Sử dụng: S.pop(); Đầu vào: một stack S bất kỳ Đầu ra: stack S bớt đi phần tử ở đỉnh nếu stack không rỗng Code: template <class T> void Stack<T>::pop(){ if(isEmpty()) {cout<<endl<<"Stack Empty !"<<endl; exit(0);} else { Node *Otop = top; top = top->next; delete Otop; } } 8. Thêm 1 phần tử kiểu T vào stack Mục đích: Thêm 1 phần tử T vào stack S Sử dụng: S.push(T); Đầu vào: một stack S bất kỳ và một giá trị có kiểu T Đầu ra: stack S thêm 1 phần tử mà giá trị của nó là T Code: template <class T> void Stack<T>::push(T x){ Node *t = new Node; t->info = x; t->next = top; top = t; } 9. Operator= Mục đích: được dùng để gán stack S cho stack T Sử dụng: T = S; Đầu vào: một stack S bất kỳ Đầu ra: stack T giống như stak S nhưng ở vị trí khác trong bộ nhớ Code: template <class T> const Stack<T> & Stack<T>::operator =(const Stack<T> &r){ if(*this != &r) { makeEmpty(); top = NULL; *this = r; } return *this; } Chú ý: Để sử dụng stack ST lưu trữ kiểu bất kỳ T thì khai báo theo cú pháp Stack <T> ST; đối với những lớp có thuộc tính con trỏ muốn sử dụng template trên thì cần định nghĩa chồng tóan tử gán “operator=” . Phần 1: Xây dựng stack bằng danh sách liên kết đơn Dùng kỷ thuật template để xây dựng một stack có thể lưu trữ bất kỳ. ở đây T là kiểu bất kỳ template <class T> class Stack{ private: struct. & topOfStack( ); //Trả về phần tử ở đỉnh stack void pop( ); //Lấy ra khỏi stack phần tử ở đỉnh stack void push( T ); //Thêm 1 phần tử kiểu T vào stack Stack & operator=( Stack &. từ 1 stack đã có public: Stack( ); // C O N S T R U C T O R Stack( const Stack & ); // C O P Y C O N S T R U C T O R ~Stack( ); // DES T R U C T O R bool isEmpty( ) ; //Kiểm tra Stack