（1）置頭指標 head = 0;
（2）輸入一個數據，如果該資料有效，則轉步驟（3），否則轉步驟（5）；
（3）申請分配一個結點空間，並把該空間的地址存入指標變數p中，然後把輸入的資料存入該結點；
（4）若當前連結串列為空，即head為0，則直接把p賦給 head，否則接入連結串列末尾。轉步驟（2）；
（5）如果head不為0，則置尾結點的指標域為0；
（6）返回頭指標head的值，程式結束

1.5 遍歷輸出連結串列各結點的值。

   void Print(const node *head) { 
	const node *p; p = head; 
	while(p!=0) { 
		cout<data<<'\t’; 
		p=p->next;
	 } 
	cout<<endl;
}

1.6 刪除連結串列上具有特定值的一個結點

（1）若head為0，則轉步驟（6）；
（2）如果第一個結點即為要找的結點，則轉步驟（5）；
（3）檢查下一結點P；
（4）若P不存在，則轉步驟（6），若P為要找的結點，則轉步驟（5），否則轉步驟（3）；
（5）從連結串列中刪除該結點；
（6）返回頭指標，演算法結束

1.7 釋放連結串列的結點空間

void deletechain(node *head) { 
	node *p1; 
	while(head) { 
		p1 = head; 
		head = head->next; 
		delete p1;
	 }
 }

1.8 把一個結點插入升序連結串列

node *Insert(node *head,node *p) {
 node *p1,*p2; 
 if(head == 0 ) {
 	head = p;
	p->next = 0;
 	return head; 
}
 if(head->data >= p->data) { 
	p->next = head;
	head = p;
	return head; 
}
 p2 = p1 = head;
 while(p2->next && p2->data < p->data) {
 	p1 = p2; 
	p2 = p2->next; 
} 
if(p2->data < p->data) {
 	p2->next = p;
	p->next = 0;
}
else { 
	p->next = p2; 
	p1->next = p; 
} 
return head; 
}

1.9 建立一條有序連結串列

node *Create_sort(void) {
 	node *p1,*head = NULL; 
	int a;
 	cout<<”產生一條有序連結串列，輸入資料，以-1結束:\n”;
	cin>>a;
 	while(a!=-1) {
 		p1 = new node; 
		p1->data=a; 
		head = Insert(head,p1); 
		cin>>a; 
	} 
	return head;
}

二．面向物件的程式設計語言——C++

2.1 設計方法概述

•是建立在“物件”及其相關概念基礎上的程式設計方法學。
• 它在分析問題的構成及其各部分相互聯絡的基礎上，通過一組資料抽象，把問題分解成一個個的物件來對問題建模；
• 然後以物件為中心，以類、繼承和多型機制來認識、理解、刻畫客觀世界，並設計、構建相應的程式。
• 演算法和資料被封裝在類中，程式的功能通過類的物件例項之間的相互作用表現出來。

2.2 有關概念

1.物件：
由屬和行為構成，C++中，分別體現為資料以及函式
2.封裝及資訊隱蔽
（1）物件的封裝，各個物件相互獨立，互不干擾
（2）物件中某些部分的隱藏，只留下少量介面
3.抽象
把具有同一性質的物件歸到一類
4.繼承與重用
在類A的基礎上增加一些新內容得到類B,則A(父類/基類)，B(子類/派生類)
5.多型
不同派生類的物件對於同一訊息作出不同的反應

2.3 舉例

物件圖解

2.4 類和物件的定義及引用

2.4.1 類的定義

類的定義一般包括兩個部分：宣告部分和實現部分。

Class<類名> { 
public: 
<資料成員或成員函式的宣告>
protected: 
<資料成員或成員函式的宣告>
private: 
<資料成員或成員函式的宣告>
};

類的實現主要是指類的成員函式的定義；
類的成員函式定義可在類體外進行，也可在類體內進行；
類定義中宣告的資料成員和成員函式都具有類作用域；
在類體外定義成員函式時，需用類名加域運算子“::”進行限定；

2.4.2 物件的定義

物件是類型別的變數，是類的例項；
通過定義物件、為物件分配空間、讓對象之間相互作用來實現程式的功能；
物件與普通變數的作用域規則相同。

2.5 建構函式

2.5.1 建構函式的提出

建構函式在物件被建立時使用特定的值構造物件，或者說將物件初始化為一個特定的狀態。
建構函式是類中一個特殊的成員函式，其語法形式為：

ClassName(形參表)
{ … }
或者
ClassName::ClassName(形參表)
{ … }

例程：

    class Time { 
    	public:Time( ); //建構函式 
     	void SetTime(int newH, int newM, int newS) { 
     	hour= newH;
    	minute= newM;
     	second= newS; 
    }
     void ShowTime() { 
    	cout<<hour<<"\t"<<minute<<"\t"<<second<<"\n"; 
    }
     	private: int hour, minute, second;
    }
    Time::Time( ) {
     	hour= 1;
     	minute= 2;
     	second= 3; 
    }
     int main() {
     	Time c; 
     	Time c( );  
    	// c. Time( );
     	c.ShowTime(); 
    	return 0;
    }

2.5.2 建構函式的特性

① 建構函式的函式名必須與類名相同
② 不能指定建構函式返回值的型別
③ 建構函式可以過載
④ 建構函式由系統呼叫
⑤ 建構函式一般是公有的或保護的成員函式
⑥ 若沒有定義建構函式，系統會提供一個預設建構函式

2.6 帶引數的建構函式

例程：

class Rectangle { 
private: int left , top , right , bottom ; public: Rectangle(int l, int t, int r,int b) { 
	left=l ; top=t ; right=r ; bottom=b;   	cout<< "呼叫帶參建構函式!\n"; 
} 
Rectangle() { 
	left=0 ; top=0 ; right=0 ; bottom=0 ; 
	cout<< "呼叫不帶參建構函式!\n "; 
}
 void print() { 
	cout<<left<<" "<<top<<" " ; 	cout<<right<<" "<<bottom<<'\n’; 
} 
}；
int main() { 
	Rectangle r1(100,200,300,400); 
	r1.print(); 
	Rectangle r2; 
	Rectangle r3(); 
	r2.print(); 
	return 0; 
}

2.7 解構函式

2.7.1 解構函式的提出

解構函式完成物件被刪除前( 釋放物件佔用空間前）的一些清理工作。
解構函式的語法形式為：

~ClassName( ) { … }
或者
ClassName::~ClassName( )

例程：

class Q {
	 int x,y; 
	public: Q(int a=0,int b=0) { 
		x = a; 
		y = b; 
	} 
	~Q() {
		 cout<<"呼叫了解構函式!\n"; 
	} 
	void P(void) { 
		cout<<x<<'\t'<<y<<endl;
	}
}；
int main() { 
	Q q(50,100); 
	q.P(); 
	cout<< "退出主函式¡\n";
	return 0;
}

2.7.2 解構函式的特性

① 析造函式的函式名與類名相同，並在前加字元”～”
② 析造函式不能帶有任何引數，無返回值型別
③ 析造函式一般在撤銷物件時由系統隱式呼叫
④ 析造函式一般是公有的或保護的成員函式
⑤ 若沒有定義析造函式，系統會提供預設析造函式
⑥ 解構函式中不能包含exit函式

2.8 物件成員

2.8.1 物件成員的初始化

建立物件時首先對其包含的物件成員初始化；
使用建構函式初始化表對物件成員初始化。

2.8.2 物件成員的引用

通過物件名(或物件的引用)和成員運算子引用物件中的成員
物件名. 成員名
通過指向物件的指標引用物件中的成員
指標變數->成員名

2.9 類的繼承

2.9.1 包含——複用類的實現

class Engine { 
	public: void fire(void) 
		{ … }//點火
 	void stall(void) 
		{ … }//熄火
	 …… 
};
class Car { 
	Engine engine;
	public: void run() 
		{ engine.fire(); //… }
	void stop()
		{ engine.stall(); //… } 
}; 
int main() { 
	Car benz; 
	benz.run(); 
	benz.stop();
}

2.9.2 單一繼承

Class<派生類名> :基類名 { … ｝； //類體
三種繼承（派生）方式
- 公有繼承（派生）
- 私有繼承（派生）
- 保護繼承（派生）
不同繼承方式的影響主要體現在：通過派生類物件對基類成員的訪問許可權

2.9.2.1 公有繼承

基類的所有成員在派生類中保持各個成員的訪問許可權不變；
派生類中的成員函式可以直接訪問基類中的public和 protected成員，但不能直接訪問基類的private成員；
公有派生類繼承了基類的介面，能夠傳送給基類物件的訊息派生類物件也可以接收。

例程：

class A { 
	int x; 
	protected:  int y; 
	public: int z; 
	A(int a,int b,int c) { 
	x=a;y=b;z=c; 
	}
    int Getx( ) { return x; } 
	int Gety( ) { return y; } 
	void ShowA( ) {
		cout<<x<<'\t' <<y<<'\t'<<z;
	}
}；
class B:public A { 
	int Length,Width;
 	public: B(int a,int b,int c,int d,int e):A(a,b,c) { 
		Length=d;Width=e;
	} 
	void ShowB() { 
	cout<<Length<<'\t'<<Width<<'\n'; 
	cout<<Getx()<<'\t'<<y<<'\t'<<< "Sum="<<b1.Sum()<<'\n'; 
	cout << "y=" <<b1.Gety()<<'\t'; 
	cout << "z="<<b1.z<<'\n’;
	}
}；

2.9.2.2 私有繼承

基類的所有成員在派生類中的訪問許可權全部變為私有；
派生類中的成員函式可以直接訪問基類中的public和 protected成員，但不能直接訪問基類的private成員；
派生類的使用者不能訪問基類的資料和功能。

例程：

class A { 
	int x;
 	protected:int y;
 	public:int z;
 	A(int a,int b,int c) {
 		 x=a;y=b;z=c; 
 	} 
	int Getx() { return x; } 
	int Gety() { return y; } 
	void ShowA() {
		cout<<x<<'\t‘<<y<<'\t‘<<z;
	}
};
class B:private A {
 	int Length,Width;
 	public: B(int a,int b,int c,int d,int e):Base(a,b,c) {Length=d;Width=e;} 
	void ShowB() {
		cout<<Length<<'\t’<<Width<<'\n'; 
		cout<<Getx()<<'\t‘<<y<<'\t‘<<z<<'\n‘;
	} 
	int Sum(void) {
		return (Getx()+y+z+Length+Width);
	} 
};
 void main(void) { B b1(1,2,3,4,5); b1.ShowA(); X錯誤
cout<<"Sum="<<b1.Sum()<<'\n’; 
cout << "y=" <<b1.Gety()<<'\t'; X錯誤
cout << "z="<<b1.z<<'\n’; X錯誤
}

2.9.2.3 保護繼承

基類中的公有成員和保護成員在派生類中均變為保護成員，它們仍然可被它的子類所繼承。
派生類中的成員函式可以直接訪問基類中的 public和protected成員，但不能直接訪問基類的private成員。
通過派生類的物件不能直接訪問基類中的任何成員。

例程:

class A { 
	protected: int x; 
}；
 int main() {
	 A a; 
	a.x=5; ×
}
class A { 
	protected: int x; 
} 
class B: protected A {
	 public: void Function() { x=5;}
}；

祕書部第五次培訓總結

文章目錄

一、連結串列

1.1 什麼是連結串列

1.2 相關概念

1.3 結點資料的訪問形式

1.4 建立一條無序連結串列