面向對象程序設計課程實驗報告

1、課程實驗報課程名稱：面向對象程序設計院系：專業(yè)班級：學號：姓名：指導教師：目錄實驗一 .面向過程的整型棧編程 01. 需求分析 01.1 題目要求 01.2 需求分析 02. 系統(tǒng)設計 12.1 概要設計 12.2 詳細設計 24. 軟件測試 35. 特點與不足 35.1 技術特點 35.2 不足和改進的建議 46. 過程和體會 46.1 遇到的主要問題和解決方法 46.2 課程設計的體會 47. 源碼和說明 47.1 文件清單及其功能說明 47.2 用戶使用說明書 47.3 源代碼 4實驗二 .面向對象的整型棧編程 111. 需求分析 111.1 題目要求 111.2 需求分析 112. 系

2、統(tǒng)設計 122.1 概要設計 122.2 詳細設計 123. 軟件開發(fā) 134. 軟件測試 135. 特點與不足 135.1 技術特點 135.2 不足和改進的建議 146. 過程和體會 147. 源碼和說明 147.1 文件清單及其功能說明 147.2 用戶使用說明書 147.3 源代碼 14實驗三 .基于算符重載的整型棧編程 181. 需求分析 181.1 題目要求 181.2 需求分析 182. 系統(tǒng)設計 192.1 概要設計 192.2 詳細設計 193. 軟件開發(fā) 194. 軟件測試 195. 特點與不足 205.1 技術特點 205.2 不足和改進的建議 206. 過程和體會 20

3、6.1 遇到的主要問題和解決方法 206.2 課程設計的體會 207. 源碼和說明 207.1 文件清單及其功能說明 207.2 用戶使用說明書 207.3 源代碼 20實驗四 . 面向對象的整型隊列編程 241. 需求分析 241.1 題目要求 241.2 需求分析 242. 系統(tǒng)設計 253. 軟件開發(fā) 254. 軟件測試 255. 特點與不足 255.1 技術特點 255.2 不足和改進的建議 256. 過程和體會 256.1 遇到的主要問題和解決方法 256.2 課程設計的體會 267. 源碼和說明 267.1 文件清單及其功能說明 267.2 用戶使用說明書 267.3 源代碼 26

4、實驗五 . 基于組合的整型隊列編程 301. 需求分析 301.1 題目要求 301.2 需求分析 302. 系統(tǒng)設計 303. 軟件開發(fā) 314. 軟件測試 315. 特點與不足 315.1 技術特點 315.2 不足和改進的建議 316. 過程和體會 316.1 遇到的主要問題和解決方法 316.2 課程設計的體會 317. 源碼和說明 327.1 文件清單及其功能說明 327.2 用戶使用說明書 327.3 源代碼 32實驗六 . 基于繼承的整型隊列編程 361.需求分析 361.1 題目要求 361.2 需求分析 372.系統(tǒng)設計 373. 軟件開發(fā) 374. 軟件測試 375. 特點

5、與不足 375.1 技術特點 375.2 不足和改進的建議 376. 過程和體會 387. 源碼和說明 387.1 文件清單及其功能說明 387.2 用戶使用說明書 387.3 源代碼 38實驗一 . 面向過程的整型棧編程1. 需求分析1.1 題目要求整型棧是一種先進后出的存儲結構，對其進行的操作通常包括判斷棧是否 為空、向棧頂添加一個整型元素、出棧等。整型棧類型及其操作函數(shù)采用非面 向對象的純 C 語言定義，請將完成上述操作的所有函數(shù)采用面向過程的方法編 程， 然后寫一個 main 函數(shù)對棧的所有操作函數(shù)進行測試。struct STACKint*elems;/申請內存用于存放棧的元素intm

6、ax;/棧能存放的最大元素個數(shù)intpos;/棧實際已有元素個數(shù)，?？諘r pos=0;void initSTACK(STACK *const p, int m);/ 初始化 p 指空棧：可存 m 個元素 void initSTACK(STACK *const p, const STACK&s); / 用 s 初始化 p 指空棧 int size (const STACK *const p);/返回 p 指的棧的最大元素個數(shù) maxint howMany (const STACK *const p); 返回p指的棧的實際元素個數(shù) pos int getelem (const STACK

7、*const p, int x);/取下標 x 處的棧元素STACK *const push(STACK *const p, int e); 將 e入棧，并返回 pSTACK *const pop(STACK *const p, int &e); /出棧到 e,并返回 pSTACK *const assig n(STACK*co nst p, con st STACK&s); 賦給 p 指棧，返回 p void print(const STACK*const p);/打印 p 指向的棧元素void destroySTACK(STACK*const p);/銷毀 p 指向的棧，釋

8、放1.2 需求分析本實驗需要實現(xiàn)棧的功能的操作，如元素的進棧，連續(xù)進棧，出棧和連續(xù) 出棧，所以需要設計兩個棧，在完成初始化后直接在程序里給定棧內元素。2. 系統(tǒng)設計2.1概要設計函數(shù)結構圖見圖1.1銷毀棧圖1.1初始化?？傮w流程圖見圖1.2YY2.2 詳細設計void initSTACK(STACK *const p, int m) 入口參數(shù)： int m 出口參數(shù)：無 功能：初始化棧，可存 m 個元素void initSTACK(STACK *const p, const STACK&s) 入口參數(shù)： const STACK&s 出口參數(shù)：無功能：用s初始化p指空棧 int

9、size (const STACK *const p) 入口參數(shù)：無 出口參數(shù)： int max 功能：返回 p 指的棧的最大元素個數(shù) max int howMany (const STACK *const p) 入口參數(shù)：無 出口參數(shù)： int pos 功能：返回 p 指的棧的實際元素個數(shù) pos int getelem (const STACK *const p, int x) 入口參數(shù)： int x 出口參數(shù)： elemm 功能：取下標 x 處的棧元素 STACK *const push(STACK *const p, int e) 入口參數(shù)： int e 出口參數(shù)： (*this) 功

10、能：將 e 入棧，并返回 p STACK *const pop(STACK *const p, int &e) 入口參數(shù)： int &e 出口參數(shù)： (*this) 功能：出棧到e,并返回p STACK *const assign(STACK*const p, const STACK&s) 入口參數(shù)： STACK&s 出口參數(shù)： (*this) 功能：賦 s 給 p 指棧,返回 p void print(const STACK*const p)入口參數(shù)：無出口參數(shù)：無功能：打印p指向的棧元素void destroySTACK(STACK*const p)入口參數(shù)

11、：出口參數(shù)：功能：銷毀p指向的棧，釋放3. 軟件開發(fā)在Codeblocks編譯環(huán)境下，使用 C+語言編寫4. 軟件測試測試結果見圖1.3圖1.35. 特點與不足5.1技術特點完成了實驗的所有要求，沒有錯誤的地方。5.2 不足和改進的建議沒有做人機交互界面，無法自由選擇入棧的數(shù)據(jù)；同時注釋較少，對于程序不了解的人可能需要花費更多時間去了解。6. 過程和體會6.1 遇到的主要問題和解決方法輸出結果數(shù)字與預計不同，檢查后發(fā)現(xiàn)原因是變量初始值未設置。6.2 課程設計的體會本次實驗主要還是通過回顧C語言中棧的知識完成在C+上的編程，所以 總體過程沒有出現(xiàn)太大的問題；同時也對const變量有了進一步的認識

12、。7. 源碼和說明7.1 文件清單及其功能說明experime ntl.cpp 源碼 experime nt1.exe 可執(zhí)行文件。7.2 用戶使用說明書experimentl.cpp是程序的源碼，可通過修改其中main函數(shù)中的變量來測試 各個函數(shù)。7.3 源代碼#include<stdio.h>#include<malloc.h>#include<stdlib.h>struct STACKint *elems; / int max;int pos;申請內存用于存放棧的元素/ 棧能存放的最大元素個數(shù)/ 棧實際已有元素個數(shù)，?？諘r pos=0;4;void i

13、nitSTACK(STACK *const p, int m);/ 初始化 p指向的棧：最多m個元素void initSTACK(STACK *const p, const STACK&s); /用棧 s 初始化 p 指向的棧int size (const STACK *con st p);個數(shù)maxint howMa ny (co nst STACK *co nst p); 個數(shù)posint getelem (const STACK *const p, int x);素/返回p指向的棧的最大兀素/返回p指向的棧的頭際兀素/取下標x處的棧兀STACK *const push(STACK

14、 *const p, int e);STACK *con st pop(STACK *con st p, i nt &e);/將e入棧，并返回p/出棧到e,并返回pSTACK *const assig n(STACK*co nst p, con st STACK&s); /賦 s 給 p 指的棧,并返回pvoid print(const STACK*const p);void destroySTACK(STACK*co nst p);/打印p指向的棧/銷毀p指向的棧int main (i nt argc, char* argv)STACK *s1 = (STACK *)mall

15、oc(sizeof(STACK);STACK *s2 = (STACK *)malloc(sizeof(STACK); in itSTACK(s1,10);push(s1,1);push(s1,2); push(push(s1,3),4); ini tSTACK(s2,*s1);prin t(s2);printf("棧 s1:n");prin t(s1);/assig n(s2,*s1);printf("棧 s2:n");prin t(s2);int a,b,c; a = size(s1); printf(" 棧的最大元素個數(shù)是 %dn&quo

16、t;,a); b = howMany(s1);printf(" 棧的實際元素個數(shù)是 %dn",b);c = getelem(s1,3);printf("3 處棧元素是是 %dn",c);int x,y,z; pop(s2,x); pop(pop(s2,y),z);printf("x= %d, y= %d, z= %d n",x,y,z); destroySTACK(s2);destroySTACK(s1); getchar();return 0;void initSTACK(STACK *const p, int m) /初始化 p

17、指向的棧：最多 m個元素p->elems = (int*)malloc(m*sizeof(int*); if(!p->elems)return;p->pos = 0; p->max = m;int i; for(i=0;i<(p->max);i+) p->elemsi = 0;void initSTACK(STACK *const p, const STACK&s) /用棧 s 初始化 p 指向的棧p->elems = (int*)malloc(s.max)*sizeof(int); p->pos = s.pos;p->max

18、 = s.max;int i;for(i=0;i<(s.pos);i+)p->elemsi=s.elemsi;prin tf("%dn",p->elemsi);int size (const STACK *con st p)個數(shù)maxreturn p->max;int howMa ny (const STACK *co nst p) 個數(shù)posretur n p->pos;/返回p指向的棧的最大元素/返回p指向的棧的實際元素int getelem (const STACK *const p, i nt x) 素if(p=NULL)return

19、NULL;elseif(x>(p->pos) printf("不存在元素n");elsereturn p->elemsx;/取下標x處的棧元/ 將 e 入棧，并返回 p/出棧到e,并返回pSTACK *const push(STACK *const p, int e) if(p=NULL) return NULL; else if(p->pos)<=(p->max) p->elemsp->pos=e; p->pos+;return p;elseprintf("棧滿 n");STACK *const p

20、op(STACK *const p, int &e) if(p=NULL)return NULL;elseif(p->pos)=0)printf(" 棧為空 n");elsee=p->elems(p->pos)-1;(p->pos)-;return p;STACK *const assig n(STACK*co nst p, con st STACK&s) / 賦 s 給 p 指的 棧,并返回pif(p=NULL | & s=NULL)return NULL;elsefree(p->elems);/free(p);/ST

21、ACK *p = (STACK *)malloc(sizeof(STACK);ini tSTACK(p,s);return p;void print(const STACK*const p)/ 打印 p指向的棧int i;if(p = NULL)return;else if(p->pos = 0)prin tf("棧為空 n");elsefor(i=0;i<(p->pos);i+)prin tf("%d ",p->elemsi);printf("n");void destroySTACK(STACK*const

22、 p)/ 銷毀 p 指向的棧free(p->elems);free(p);printf(" 棧已銷毀 n");實驗二.面向對象的整型棧編程1. 需求分析1.1題目要求class STACKint *const elems; / const int max;int pos;public:STACK(i nt m);整型棧是一種先進后出的存儲結構，對其進行的操作通常包括判斷棧是否 為空、向棧頂添加一個整型元素、出棧等。整型棧類型及其操作函數(shù)采用面向 對象的C+語言定義，請將完成上述操作的所有函數(shù)米用 C+S程，然后寫 個main函數(shù)對棧的所有操作函數(shù)進行測試。申請內存用于

23、存放棧的元素/棧能存放的最大元素個數(shù)/棧實際已有元素個數(shù)，?？諘rpos=0;/初始化棧：最多m個元素STACK(const STACK&s); /用棧s拷貝初始化棧int size ( ) con st;/返回棧的最大元素個數(shù) maxint howMa ny ( ) con st;/返回棧的實際元素個數(shù) posint getelem (int x) con st;/ 取下標 x 處的棧元素STACK& push(int e);/將e入棧，并返回棧STACK& pop(int &e);/出棧到e,并返回棧STACK& assign(const STACK&

24、amp;s); /賦s給棧,并返回被賦值的棧 void prin t( ) con st;/ 打印棧STACK( );/ 銷毀棧;1.2需求分析采用面向對象的C+語言定義整型棧，對其進行的操作通常包括判斷棧是 否為空、向棧頂添加一個整型元素、出棧等。2. 系統(tǒng)設計2.1 概要設計首先需要定義一個類來實現(xiàn)棧，然后依次實現(xiàn)棧的各個功能，在主函數(shù)中給定一個棧然后，然后通過函數(shù)調用實現(xiàn)棧的功能。2.2 詳細設計STACK(int m) 功能：初始化棧：最多 m 個元素返回值：無STACK(const STACK&s)功能：用棧 s 拷貝初始化棧返回值：無int size ( ) const 功

25、能：返回棧的最大元素個數(shù) max 返回值：最大元素個數(shù) maxint howMany ( ) const 功能：返回棧的實際元素個數(shù) pos 返回值：元素數(shù)目 posint getelem (int x) const功能：取下標 x 處的棧元素返回值：下標為 x 的元素STACK& push(int e)功能：將 e 入棧 返回值：棧的引用STACK& pop(int &e)功能：出棧到e,并返回棧返回值：棧的引用STACK & assig n(co nst STACK&s)功能：使用棧s給棧p賦值 返回值：棧的引用void prin t( ) cons

26、t功能：打印棧 返回值：無STACK()功能：銷毀棧返回值：無3. 軟件開發(fā)在Codeblocks編譯環(huán)境下，使用 C+語言編寫4. 軟件測試測試結果見圖2.1圖2.15. 特點與不足5.1技術特點完成了初定目標，無其他特點。5.2 不足和改進的建議人機交互需要進一步完善。6. 過程和體會6.1 遇到的主要問題和解決方法由于第一次使用C+面向對象編寫程序，開始不明白對象的生成及使用。 在和同學老師的溝通和交流中，慢慢學會了編程的方法。6.2 課程設計的體會C+語言與C語言有很多相通的地方，所以其中的某些原理和方法可以互 相借鑒，這樣就減少了在理解上的難度。7. 源碼和說明7.1 文件清單及其功

27、能說明experime nt2.cpp 源碼 experime nt2.exe可執(zhí)行文件7.2 用戶使用說明書experiment2.cpp是程序的源碼，可通過修改其中main函數(shù)中的變量來測試 各個函數(shù)。7.3 源代碼#include <iostream>#include <string> using namespace std;class STACKint *constconst intelems;/申請內存用于存放棧的元素max; /棧能存放的最大元素個數(shù)int pos;/棧實際已有元素個數(shù)，?？諘r pos=0;public:STACK(int m);/初始化棧：

28、最多m 個元素STACK(const STACK&s); /用棧s拷貝初始化棧 int size ( ) con st; 返回棧的最大元素個數(shù) max int howMa ny ( ) const; /返回棧的實際元素個數(shù) pos int getelem (int x) con st; 取下標x處的棧元素 STACK& push(int e);/將e入棧,并返回棧STACK& pop(int &e);/出棧到e并返回棧STACK& assign(const STACK&s); /賦s給棧，并返回被賦值的棧 void print( ) con st

29、;/ 打印棧STACK( );/ 銷毀棧;STACK:STACK(int m):elems(new intm),max(m),pos(0) STACK:STACK(co nst STACK&s):elems( newin ts.size(),max(s.size(),pos(s.howMa ny()for(i nt i=0;i<pos;i+)elemsi=s.getelem(i);cout«"復制構造成功"<<endl;int STACK:size() con streturn max;int STACK:howMa ny() const

30、return pos;int STACK:getelem (int x) con streturn elemsx;STACK & STACK:push(i nt e)if(posvmax)elemspos=e;pos+;else cout<<"fulln"return *this;STACK& STACK:pop(int &e)if(pos=0)cout<<"empty stack"return *this;pos-;e = elemspos;coutvv"出棧成功"return *th

31、is;STACK& STACK:assign(const STACK&s) int i;delete elems;/elems = new int s.size();/max = s.size();pos = s.howMany(); for(i=0;i<s.howMany();i+) elemsi = s.getelem(i); return *this;void STACK:print( ) constint i;coutvv"棧的元素為："for(i=0;i<pos;i+)coutvvelemsivv" " coutvv

32、endl;STACK:STACK()delete elems;/ elems= 0;/ max = 0;pos = 0;cout«"析構完成"int mai n()STACK s(7);s.push(5);s.push(7);s.push(9);s.push(11);s.pri nt();int i;s.pop(i);cout«"出棧元素"vvivvendl;STACK p(s);cout«"容量"<vp.size()v<e ndl; cout«"當前元素數(shù)目"v

33、vp.howMany();實驗三 . 基于算符重載的整型棧編程1. 需求分析1.1 題目要求virtual int size ( ) const;virtual operator int ( ) const;virtual int operator (int x) const;/ virtual STACK& operator<<(int e); virtual STACK& operator>>(int &e);/ 返回棧的最大元素個數(shù) max / 返回棧的實際元素個數(shù) pos 取下標 x 處的棧元素/ 將 e 入棧, 并返回棧/ 出棧到 e,

34、 并返回棧整型棧是一種先進后出的存儲結構，對其進行的操作通常包括判斷棧是否 為空、向棧頂添加一個整型元素、出棧等。整型棧類型及其操作函數(shù)采用面向 對象的C+語言定義，請將完成上述操作的所有函數(shù)米用C+編程，然后寫個 main 函數(shù)對棧的所有操作函數(shù)進行測試。class STACKint *const elems; / const int max;int pos;public:申請內存用于存放棧的元素/ 棧能存放的最大元素個數(shù)/ 棧實際已有元素個數(shù)，?？諘r pos=0;STACK(int m);/初始化棧：最多m個元素STACK(const STACK&s);/ 用棧 s 拷貝初始化棧v

35、irtual STACK& operator=(const STACK&s);/ 賦 s 給棧, 并返回被賦 值的棧/ 打印棧/ 銷毀棧virtual void print( ) const;virtual STACK( );1.2 需求分析采用面向對象的C+語言定義，構建整型棧并對其進行判斷棧是否為空、 向棧頂添加一個整型元素、出棧等操作。2. 系統(tǒng)設計2.1概要設計首先需要定義一個類來實現(xiàn)棧，然后依次實現(xiàn)棧的各個功能，在主函數(shù)中 給定一個棧然后，然后通過函數(shù)調用實現(xiàn)棧的功能。2.2詳細設計初始化定義一個類，分配一個數(shù)組空間來存儲棧內元素信息，然后初始化為0；實現(xiàn)入棧則需要將

36、入棧元素e放入棧內，采用了先判斷棧的最大容量夠 不夠的問題，如果不夠重新分配空間，并且讓e入棧，將當前元素pos加一; 然后返回棧結構。實現(xiàn)出棧操作，首先判斷是不是空，若空直接返回，不空則需將棧頂?shù)脑?素賦給一個變量然后將當前元素 pos減一；返回棧結構。實現(xiàn)棧的賦給即需要將si棧內的元素依次賦給s2棧的，當前元素也需一 致并且返回新的棧結構。3. 軟件開發(fā)在Codeblocks編譯環(huán)境下，使用 C+語言編寫。4. 軟件測試測試結果見圖3.1圖3.15. 特點與不足5.1 技術特點使用了符號重載，在一定程度上簡化了函數(shù)。5.2 不足和改進的建議 在使用符號重載時需要特別注意，防止與其他操作符混

37、淆。6. 過程和體會6.1 遇到的主要問題和解決方法對于符號重載，剛開始不會調用函數(shù)，之后通過查閱書籍，明白了重載的 含義。6.2 課程設計的體會本次實驗以實驗二為基礎，通過使用符號重載來更簡單的實現(xiàn)實驗目的。7. 源碼和說明7.1 文件清單及其功能說明experime nt3.cpp 源碼experime nt3.exe 可執(zhí)行文件。7.2 用戶使用說明書experiment3.cpp是程序的源碼，可通過修改其中main函數(shù)中的變量來測試 各個函數(shù)。7.3 源代碼#include <iostream>#include <string>using namespace s

38、td;class STACKint *const elems;/申請內存用于存放棧的元素const int max; 棧能存放的最大元素個數(shù)int pos;/棧實際已有元素個數(shù)，棧空時 pos=0;public:STACK(int m);/初始化棧：最多m個元素STACK(const STACK&s);/用棧s拷貝初始化棧virtual int size ( ) const;返回棧的最大元素個數(shù) maxvirtual operator int () con st;返回棧的實際元素個數(shù) posvirtual in t operator (i nt x) con st;取下標 x 處的棧元

39、素virtual STACK& operator«(int e);/將 e 入棧并返回棧virtual STACK& operator»(int &e); /出棧到 e,并返回棧 virtual STACK& operator=(const STACK&s); / 賦 s 給棧，并返回被賦值的棧 virtual void prin t( ) con st;/ 打印棧virtual STACK( );/ 銷毀棧;STACK:STACK(int m):elems(new intm),max(m),pos(0) STACK:STACK(co

40、 nst STACK&s):elems( newin ts.max),max(s.max),pos(s.pos)for(i nt i=0;i<pos;i+)elemsi=s.elemsi;int STACK:size ( ) con streturn max;STACK:operator int () con streturn pos;int STACK:operator (int x) con streturn elemsx;STACK & STACK:operator<<(i nt e)if(pos>max)coutvv"棧滿"e

41、lse*(elems+pos)=e;pos+;return (*this);STACK& STACK:operator>>(int &e)if(pos=0)cout«"?？?quot;elsee=*(elems+pos-1);pos-;return (*this);STACK& STACK:operator=(const STACK&s)delete elems;*(int*)&elems = new ints.max;*(int*)&max = s.max; for(pos=0;pos<s.pos;pos+

42、) elemspos = s.elemspos;return *this;void STACK:print( ) constfor(int i=0;i<pos;i+) cout<<elemsi<<"n"STACK:STACK( )delete elems;if(elems=0)cout«"銷毀失敗"<<endl;elsecoutvv"銷毀成功"<<endl;int mai n()STACK i(5),j(8); i<<1<<3<<6&l

43、t;<9;int k;i»k;cout<<kvv"n"i. pri nt();j=i;j.pri nt(); j<<1<<2<<3<<4;cout«e ndl«(i nt)j;實驗四.面向對象的整型隊列編程1. 需求分析1.1題目要求整型隊列是一種先進先出的存儲結構，對其進行的操作通常包括判斷隊列 是否為空、向隊列頂添加一個整型元素、出隊列等。整型隊列類型及其操作函 數(shù)米用面向對象的C+語言定義，請將完成上述操作的所有函數(shù)米用C+®程,class QUEUEint *c

44、onst elems; / const int max;int head, tail;時 head=tail=O然后寫一個main函數(shù)對隊列的所有操作函數(shù)進行測試。申請內存用于存放隊列的元素/隊列能存放的最大元素個數(shù)/隊列頭和尾，隊列空時head=tail;初始public:QUEUE(int m);/初始化隊列：最多 m個元素QUEUE(const QUEUE&s);/用隊列s拷貝初始化隊列virtual operator int ( ) con st;/返回隊列的實際元素個數(shù)virtual QUEUE& operator«(i nt e)volatile;返回隊列

45、virtual QUEUE& operator>>(int &e)volatile;返回隊列/將e入隊列,并/出隊列到e,并virtual QUEUE & operator=(co nst QUEUE&s); /賦s給隊列,并返回被賦值的隊列virtual void prin t( ) con st;/打印隊列virtual QUEUE();/銷毀隊列;1.2需求分析本題目用數(shù)組實現(xiàn)隊列，需要預知需要空間的大小，會造成空間浪費或不夠用；插入或刪除不需要動態(tài)分配或刪除內存，耗時很?。恢С蛛S機存取。2. 系統(tǒng)設計定義一個類，分配一個數(shù)組空間來存儲棧內元素

46、信息，類中分別定義兩個 int元素表示隊列的頭和尾，入棧的時候，頭加一；出棧的時候，尾加一。3. 軟件開發(fā)在Codeblocks編譯環(huán)境下，使用 C+語言編寫4. 軟件測試測試結果見圖4.1圖4.15. 特點與不足5.1技術特點通過創(chuàng)建隊列類QUEUE完成了隊列的構造析構等諸多功能；同時再次運 用重載操作符方便了入隊出隊等操作的完成。5.2不足和改進的建議隊列一旦生成則無法改變。6. 過程和體會6.1遇到的主要問題和解決方法如何構建一個循環(huán)隊列，解決方法利用求余的方法，當頭結點大于最大元 素的時候，除以最大元素求余，重新的得到頭結點。6.2 課程設計的體會本次實驗使用面向對象的方法來編寫一個隊

47、列，讓我對隊列的構建以及對其進行一些列的操作有了更進一步的了解。與前幾次棧的實驗相比，難度有所 增加，但更鍛煉了個人能力。7. 源碼和說明7.1 文件清單及其功能說明experime nt4.cpp 源碼experime nt4.exe 可執(zhí)行文件。7.2 用戶使用說明書experiment4.cpp是程序的源碼，可通過修改其中main函數(shù)中的變量來測試各個函數(shù)。7.3 源代碼#include <iostream>#include <string>using namespace std;class QUEUEint *const elems;/申請內存用于存放隊列的元素

48、const int max; /隊列能存放的最大元素個數(shù)int head, tail;/隊列頭和尾，隊列空時 head=tail初始時head=tail=0public:QUEUE(int m);/初始化隊列：最多 m 個元素QUEUE(const QUEUE&s);/用隊列s拷貝初始化隊列virtual operator int ( ) const;/返回隊列的實際元素個數(shù)virtual QUEUE& operator<<(int e);/將 e 入隊列 ,并返回隊列virtual QUEUE& operator»(int &e); /

49、出隊列到 e并返回隊列 virtual QUEUE& operator=(const QUEUE&s); / 賦 s給隊列，并返回被賦值的 隊列virtual void print( ) const;/打印隊列virtual QUEUE( );/銷毀隊列;QUEUE:QUEUE(int m):elems(new intm),max(m),head(O),tail(O)QUEUE:QUEUE(co nst QUEUE&s):elems( newin ts.max),max(s.max),head(s.head),tail(s.tail)for(int i=head;i&l

50、t;tail;i+)elemsi=s.elemsi;QUEUE:operator int () con stif(tail>=head)return (tail-head);retur n (max-head+tail);QUEUE & QUEUE:operator«(i nt e)if(tail+1)%max=head)coutvv"隊列滿 n"elseelemstail=e;tail+;return (*this);QUEUE & QUEUE:operator»(i nt & e)if(head=tail)coutvv&

51、quot;隊列空 n"elsee=elemshead;head=(head+)%max;return(*this);QUEUE& QUEUE:operator=(const QUEUE&s) delete elems;*(int*)&elems = new ints.max;*(int*)&max = s.max;head = s.head;tail = s.tail;for(int i=head;i<tail;i+) elemsi=s.elemsi;cout«"賦值成功n"return *this;void QUE

52、UE:print( ) constif(head=tail)cout<<"Emptyn" cout«"隊列元素為："if(head<tail)for(int i=head;i<tail;i+) cout<<elemsi<<"t"elsefor(int i=head;i<max+1;i+) cout<<elemsi<<"t"for(int i=0;i<tail;i+)cout<<elemsi<<&qu

53、ot;t" cout<<"n"QUEUE:QUEUE( )delete elems;*(int*)&elems = 0;*(int*)&max =0;head = tail =0;int mai n()QUEUE q(5);q<<2<<5<<8;cout«"元素數(shù)目"<<(int)q«endl;QUEUE p(q);p.pri nt();int i;q»i；cout«"出隊元素"<<i<<

54、;endl;q.pri nt();實驗五 . 基于組合的整型隊列編程1. 需求分析1.1 題目要求整型隊列是一種先進先出的存儲結構，對其進行的操作通常包括判斷隊列 是否為空、向隊列頂添加一個整型元素、出隊列等。整型隊列類型及其操作函 數(shù)米用面向對象的C+語言定義，請將完成上述操作的所有函數(shù)米用C+編程,然后寫一個 main 函數(shù)對隊列的所有操作函數(shù)進行測試。注意，請用實驗三的 SATCK&合形成新的類QUEUE請說明如果刪掉virtual有什么不同。class QUEUESTACK s1, s2;public:QUEUE(int m);/初始化隊列：每個棧最多 m個元素QUEUE(co

55、nst QUEUE&s);/用隊列s拷貝初始化隊列virtual operator int ( ) const;/ 返回隊列的實際元素個數(shù)virtual QUEUE& operator«(int e);/ 將 e入隊列，并返回隊列virtual QUEUE& operator»(int &e);/ 出隊列到 e,并返回隊列virtual QUEUE& operator=(const QUEUE&s); /賦 s 給隊列，并返回被賦值的隊列virtual void print( ) const;/ 打印隊列virtual QUEUE( );/ 銷毀隊列;1.2 需求分析采用面向對象的C+語言定義，構建整型隊列并對其進行的操作通常包括 判斷隊列是否為空、向隊列頂添加一個整型元素、出隊列等，再寫一個 main 函數(shù)對隊列的所有操作函數(shù)進行測試。 。2. 系統(tǒng)設計用兩個棧實現(xiàn)隊列，先判棧 S2是否為空，如果為空，對S1進行入棧操作, 如果