一、類和對象的基本概念

結構化程序設計

C語言使用結構化程序設計：

程序 = 數(shù)據(jù)結構 + 算法

程序由全局變量以及眾多相互調用的函數(shù)組成 。算法以函數(shù)的形式實現(xiàn)，用于對數(shù)據(jù)結構進行操作。

結構化程序設計的不足

1.結構化程序設計中，函數(shù)和其所操作的數(shù)據(jù)結構，沒有直觀的聯(lián)系。

2.隨著程序規(guī)模的增加，程序逐漸難以理解，很難一下子看出來：

某個數(shù)據(jù)結構到底有哪些函數(shù)可以對它進行操作？

某個函數(shù)到底是用來操作哪些數(shù)據(jù)結構的？

任何兩個函數(shù)之間存在怎樣的調用關系？

3.結構化程序設計沒有“封裝”和“隱藏”的概念。 要訪問某個數(shù)據(jù)結構中的某個變量，就可以直接訪問，那么當該變量的定義有改動的時候，就要把所有訪問該變量的語句找出來修改，十分不利于程序的維護、擴充。

4.難以查錯，當某個數(shù)據(jù)結構的值不正確時，難以找出到底是那個函數(shù)導致的。

5.重用：在編寫某個程序時，發(fā)現(xiàn)其需要的某項功 能，在現(xiàn)有的某個程序里已經(jīng)有了相同或類似的 實現(xiàn)，那么自然希望能夠將那部分代碼抽取出來， 在新程序中使用。

6.在結構化程序設計中，隨著程序規(guī)模的增大，由 于程序大量函數(shù)、變量之間的關系錯綜復雜，要抽取這部分代碼，會變得十分困難。

總之，結構化的程序，在規(guī)模龐大時，會變得難以理解，難以擴充（增加新功能），難以查錯，難以重用。

• 如何更高效地實現(xiàn)函數(shù)的復用？
• 如何更清晰的實現(xiàn)變量和函數(shù)的關系？使得程序 更清晰更易于修改和維護。

面向對象的程序設計

面向對象的程序 = 類 + 類 + …+ 類

面向對象的程序設計方法：

將某類客觀事物共同特點（屬性）歸納出來，形成一個數(shù)據(jù) 結構（可以用多個變量描述事物的屬性）；

將這類事物所能進行的行為也歸納出來，形成一個個函數(shù)， 這些函數(shù)可以用來操作數(shù)據(jù)結構(這一步叫“抽象”）。

然后，通過某種語法形式，將數(shù)據(jù)結構和操作該數(shù)據(jù)結構的函 數(shù)“捆綁”在一起，形成一個“類”，從而使得數(shù)據(jù)結構和操作該數(shù)據(jù)結構的算法呈現(xiàn)出顯而易見的緊密關系，這就是“封裝”。

面向對象的程序設計具有“抽象”，“封裝”“繼承”“多態(tài)” 四個基本特點。

例如：

將長、寬變量和設置長，寬，求面積，以及求周長的三個函數(shù)“封裝”在一起，就能形成一個“矩形類”。

長、寬變量成為該“矩形類”的“成員變量”，三個函數(shù)成為該類的“成員函數(shù)” 。 成員變量和成員函數(shù)統(tǒng)稱為類的成員。

class CRectangle
{
public:
	int w, h;
	int Area() {
		return w * h;
	}
	int Perimeter(){
		return 2 * ( w + h);
	}
	void Init( int w_,int h_ ) {
		w = w_; h = h_;
	}
}; // 必須有分號

通過類，可以定義變量。類定義出來的變量，也稱為類的實例，就是我們所說的“對象” 。

C++中，類的名字就是用戶自定義的類型的名字?？梢韵笫褂没绢愋湍菢觼硎褂盟Rectangle 就是一種用戶自定義的類型。

int main( )
{
	int w,h;
	CRectangle r; //r 是一個對象
	cin >> w >> h;
	r.Init( w,h);
	cout << r.Area() << endl 
	<<r.Perimeter();
	return 0;
}

對象的內存分配

類的內存分配與結構體分配內存相同，類的成員函數(shù)所占內存不屬于類。

每個對象各有自己的存儲空間。一個對象的某個成員變量被改變了，不會影響到另一個對象。

和結構變量一樣，對象之間可以用 “=”進行賦值，但是不能用 “==”，“!=”，“>”,“<”“>=”“<=”進行比較，除非這些運算符經(jīng)過了“重載”（第四篇講）。

使用類的成員變量和成員函數(shù)

用法1：對象名.成員名

CRectangle r1,r2;
r1.w = 5;
r2.Init(5,4);

用法2： 指針->成員名

CRectangle r1,r2;
CRectangle * p1 = & r1;
CRectangle * p2 = & r2;
p1->w = 5;
p2->Init(5,4); //Init作用在p2指向的對象上

用法3：引用名.成員名

CRectangle r2;
CRectangle & rr = r2;
rr.w = 5;
rr.Init(5,4); //rr 的值變了，r2 的值也變

二、類和對象基礎 類成員的可訪問范圍

在類的定義中，用下列訪問范圍關鍵字來說明類成員

可被訪問的范圍：

private: 私有成員，只能在成員函數(shù)內訪問
public : 公有成員，可以在任何地方訪問
protected: 保護成員，后面再說，暫時理解和私有成員類似

以上三種關鍵字出現(xiàn)的次數(shù)和先后次序都沒有限制。

代碼如下（示例）：

class className {
private:
	私有屬性和函數(shù)
public:
	公有屬性和函數(shù)
protected:
	保護屬性和函數(shù)
};

如過某個成員前面沒有上述關鍵字，則缺省地被認為是私有成員。

class Man {
	int nAge; // 私有成員
	char szName[20]; // 私有成員
public:
	void SetName(char * szName){
	strcpy( Man::szName,szName);
	}
};

在類的成員函數(shù)內部，能夠訪問：

• 當前對象的全部屬性、函數(shù)；
• 同類其它對象的全部屬性、函數(shù)。

在類的成員函數(shù)以外的地方，只能夠訪問該類對象的公有成員。

成員函數(shù)在類內聲明，一般在類外實現(xiàn)（也可類內聲明并實現(xiàn)），需要加上“類名::”。

class CEmployee {
private:
	char szName[30]; // 名字
public :
	int salary; // 工資
	void setName(char * name);
	void getName(char * name);
	void averageSalary(CEmployee e1,CEmployee e2);
};
void CEmployee::setName( char * name) {
	strcpy( szName, name); //ok
}
void CEmployee::getName( char * name) {
	strcpy( name,szName); //ok
}
void CEmployee::averageSalary(CEmployee e1,CEmployee e2){
	cout << e1.szName; //ok ，訪問同類其他對象私有成員
	salary = (e1.salary + e2.salary )/2;
	}
int main()
{
	CEmployee e;
	strcpy(e.szName,"Tom1234567889"); // 編譯錯，不能訪問私有成員
	e.setName( "Tom"); // ok
	e.salary = 5000; //ok
	return 0;
}

設置私有成員的機制，叫“隱藏”

• “隱藏”的目的是強制對成員變量的訪問一定要通過成員函數(shù) 進行，那么后成員變量的類型等屬性修改后，只需要更改成員函數(shù)即可。否則，所有直接訪問成員變量的語句都需要修改。

同樣我們也可以用struct定義類

struct CEmployee {
	char szName[30]; // 公有!!
public :
	int salary; // 工資
	void setName(char * name);
	void getName(char * name);
	void averageSalary(CEmployee
	e1,CEmployee e2);
};

和用"class"的唯一區(qū)別，就是未說明是公有，還是私有的成員。

成員函數(shù)的重載及參數(shù)缺省

• 成員函數(shù)也可以重載
• 成員函數(shù)可以帶缺省參數(shù)。

注：使用缺省參數(shù)要注意避免有函數(shù)重載時的二義性

構造函數(shù)(constructor)

基本概念

成員函數(shù)的一種
名字與類名相同，可以有參數(shù)，不能有返回值(void也不行)
作用是對對象進行初始化，如給成員變量賦初值
如果定義類時沒寫構造函數(shù)，則編譯器生成一個默認的無參數(shù)的構造函數(shù)
默認構造函數(shù)無參數(shù)，不做任何操作。

• 如果定義了構造函數(shù)，則編譯器不生成默認的無參數(shù)的構造函數(shù)
• 對象生成時構造函數(shù)自動被調用。對象一旦生成，就再也不能在其上執(zhí)行構造函數(shù)
• 一個類可以有多個構造函數(shù)

為什么需要構造函數(shù)：

構造函數(shù)執(zhí)行必要的初始化工作，有了構造函數(shù)，就不 必專門再寫初始化函數(shù)，也不用擔心忘記調用初始化函數(shù)。

有時對象沒被初始化就使用，會導致程序出錯。對象不初始化是件很糟糕的事。

代碼如下（示例）：

class Complex {
private :
double real, imag;
public:
	Complex( double r, double i = 0);
};
Complex::Complex( double r, double i) {
	real = r; imag = i;
}
int main()
{
	Complex c1; // error, 缺少構造函數(shù)的參數(shù)
	Complex * pc = new Complex; // error, 沒有參數(shù)
	Complex c1(2); // OK
	Complex c1(2,4), c2(3,5);
	Complex * pc = new Complex(3,4);
	return 0;
}

同樣的構造函數(shù)也可以根據(jù)需求重載。

構造函數(shù)最好是public的，private構造函數(shù)不能直接用來初始化對象

構造函數(shù)在數(shù)組中的使用

class Test {
public:
	Test( int n) { } //(1)
	Test( int n, int m) { } //(2)
	Test() { } //(3)
};
Test array1[3] = { 1, Test(1,2) };// 三個元素分別用(1),(2),(3)初始化
Test * pArray[3] = { new Test(4), new Test(1,2) };//兩個元素分別用(1),(2) 初始化

拷貝（復制）構造函數(shù)

• 只有一個參數(shù),即對同類對象的引用。 形如 X::X( X& )或X::X(const X &), 二者選一 后者能以常量對象作為參數(shù)
• 如果沒有定義拷貝構造函數(shù)，那么編譯器生成默認拷貝構造函數(shù)。默認的拷貝構造函數(shù)完成復制功能。

如果定義的自己的拷貝構造函數(shù)，則默認的拷貝構造函數(shù)不存在。

class Complex {
public :
	double real,imag;
	Complex(){ }
	Complex( const Complex & c ) {
	real = c.real;
	imag = c.imag;
	cout << “Copy Constructor called”;
	}
};
Complex c1;
Complex c2(c1);//調用自己定義的拷貝構造函數(shù)，輸出 Copy Constructor called

拷貝構造函數(shù)起作用的三種情況

當用一個對象去初始化同類的另一個對象時。

Complex c2(c1);
Complex c2 = c1; //初始化語句，非賦值語句

如果某函數(shù)有一個參數(shù)是類 A 的對象， 那么該函數(shù)被調用時，類A的拷貝構造函數(shù)將被調用。

class A
{
public:
	A() { };
	A( A & a) {
		cout << "Copy constructor called" <<endl;
	}
};
void Func(A a1){ }
int main(){
	A a2;
	Func(a2);
	return 0;
}

程序輸出結果為: Copy constructor called

如果函數(shù)的返回值是類A的對象時，則函數(shù)返回時， A的拷貝構造函數(shù)被調用:

class A
{
public:
	int v;
	A(int n) { v = n; };
	A( const A & a) {
		v = a.v;
		cout << "Copy constructor called" <<endl;
	}
};
A Func() {
A b(4);
	return b;
}
int main() {
	cout << Func().v << endl; return 0;
}

輸出結果：

Copy constructor called
4

注意：對象間賦值并不導致拷貝構造函數(shù)被調用

類型轉換構造函數(shù)

• 定義轉換構造函數(shù)的目的是實現(xiàn)類型的自動轉換。
• 只有一個參數(shù)，而且不是拷貝構造函數(shù)的構造函數(shù)，一般就可以看作是轉換構造函數(shù)。
• 當需要的時候，編譯系統(tǒng)會自動調用轉換構造函數(shù)，建立 一個無名的臨時對象(或臨時變量)。

//Comlex是一個類
Complex( int i) {// 類型轉換構造函數(shù)
	cout << "IntConstructor called" << endl;
	real = i; imag = 0;
}

析構函數(shù)（destructors）

名字與類名相同，在前面加‘~'， 沒有參數(shù)和返回值，一個類最多只能有一個析構函數(shù)。

析構函數(shù)對象消亡時即自動被調用?？梢远x析構函數(shù)來在 對象消亡前做善后工作，比如釋放分配的空間等

如果定義類時沒寫析構函數(shù)，則編譯器生成缺省析構函數(shù)。 缺省析構函數(shù)什么也不做。

如果定義了析構函數(shù)，則編譯器不生成缺省析構函數(shù)。

class String{
private :
char * p;
public:
	String () {
	p = new char[10];
	}
	~ String () ;
};
String::~ String()
{
	delete [] p;
}

對象數(shù)組生命期結束時，對象數(shù)組的每個元素的析構函數(shù)都會被調用。
delete 運算導致析構函數(shù)調用。

Ctest * pTest;
pTest = new Ctest; // 構造函數(shù)調用
delete pTest; // 析構函數(shù)調用

pTest = new Ctest[3]; // 構造函數(shù)調用3次 次
delete [] pTest; // 析構函數(shù)調用3次

一旦有對象生成調用構造函數(shù)
一旦有對象消亡調用析構函數(shù)

總結

本篇文章就到這里了，希望能給你帶來幫助，也希望您能夠多多關注腳本之家的更多內容！

最新評論