C++_類和對象

類和對象

OOP第二課

• 1 類的構成
  • 1.1 從結構到類
  • 1.2 類的構成
• 2 成員函數的聲明
  • 2.1 普通成員函數形式
  • 2.2 將成員函數以內聯函數的形式進行說明
• 3 對象的定義和使用
  • 3.1 對象的定義
  • 3.2 對象中成員的訪問
  • 3.3 類成員的訪問屬性
  • 3.4 類中成員的訪問方式
  • 3.5 對象賦值語句
  • 3.6 類的作用域

類（class）是面向對象程序設計的最基本的概念，是C++最強有力的特征，是進行封裝和數據隱藏的工具，它將一個數據結構與一個操作集緊密地結合起來。類對象是類的實例，用類對象模擬現實世界中的事物比用數據對象更確切。

1. 類的構成

1.1 從結構到類

結構是C的一種自定義的數據類型，它把相關聯的數據元素組成一個單獨的統一體。

例2.1有關日期結構的例子

#include <iostream.h>
struct Date {
    int year;
    int month;
    int day;
};
int main()
{
    Date date1;
    date1.year=2003;
    date1.month=8;
    date1.day=25;
    cout<<date1.year<<"."<<date1.month<<"."
    <<date1.day<<endl;
    return 0;
}

⭐class與struct的比較

• 類是C++對C中結構的擴展。
• C語言中的struct是數據成員集合，而C++中的類，則是數據成員和成員函數的集合。
• struct是用戶定義的數據類型，是一種構造數據類型。類和struct一樣，也是一種用戶定義的數據類型，是一種構造數據類型。
• C結構無法對數據進行保護和權限控制，所以結構中的數據是不安全的。C++中的類將數據和與之相關聯的數據封裝在一起，形成一個整體，具有良好的外部接口可以防止數據未經授權的訪問，提供了模塊間的獨立性。

1.2 類的構成

類的成員分兩部分：一部分對應數據的狀態，稱為數據成員，另一部分為作用於該數據狀態的函數，稱為成員函數。

類聲明的一般格式如下:

class 類名 {
public:
    公有數據成員;
    公有成員函數;
protected:
    保護數據成員;
    保護成員函數;
private:
    私有數據成員;
    私有成員函數;
};

3個關鍵字： private、protected和public,稱為訪問權限關鍵字。每個關鍵字下面又都可以有數據成員和成員函數。

• private部分稱為類的私有部分，這一部分的數據成員和成員函數稱為類的私有成員。私有成員只能由本類的成員函數訪問，而類外部的任何訪問都是非法的。
• public部分稱為類的公有部分，這部分的數據成員和成員函數稱為類的公有成員。公有成員可以由程序中的函數訪問，它對外是完全開放的。
• protected部分稱為類的保護部分，這部分的數據成員和成員函數稱為類的保護成員。保護成員可以由本類的成員函數訪問，也可以由本類的派生類的成員函數訪問，而類外的任何訪問都是非法的。

注意：

• (1) 類聲明格式中的3個部分並非一定要全有，但至少要有其中的一個部分。
  • 一般一個類的數據成員應該聲明為私有成員，成員函數聲明為公有成員。
• (2) 類聲明中的private、protected和public三個關鍵字可以按任意順序出現任意次。但是，如果把所有的私有成員、保護成員和公有成員歸類放在一起，程序將更加清晰。
• (3) private處於類體中第一部分時， 關鍵字private可以省略。
• (4) 數據成員可以是任何數據類型，但不能用自動(auto)、寄存器(register)或外部(extern)進行聲明。
• (5) 不能在類聲明中給數據成員賦值。C++規定，只有在類對象定義之后才能給數據成員賦初值

用一個類來描述日期,其形式如下:

class Date {
public:
    void setDate(int y,int m,int d);
    void showDate();
private:
    int m_year;
    int m_month;
    int m_day;
};

2. 成員函數的聲明

成員函數的聲明通常采用以下兩種方式:

2.1 普通成員函數形式

即在類的聲明中只給出成員函數的原型，而成員函數體寫在類的外部。

返回類型 成員函數 (參數列表);

類外定義的一般形式是:

返回類型 類名∷成員函數名(參數表)
{
// 函數體
}

例如, 以下是表示坐標點的類Coord的聲明

class Coord {
public:
    void setCoord (int,int); // 設置坐標點
    int getx(); // 取x坐標點
    int gety(); // 取y坐標點
private:
    int x,y;
};
void Coord∷setCoord(int a,int b){ x=a; y=b;}
int Coord::getx(){ return x;}
int Coord::gety(){ return y;}

內聯函數和外聯函數

類的成員函數可以分為內聯函數和外聯函數。

• 內聯函數是指那些定義在類體內的成員函數，即該函數的函數體放在類體內。而說明在類體內，定義在類體外的成員函數叫外聯函數。外聯函數的函數體在類的實現部分。
• 內聯函數在調用時不是像一般函數那樣要轉去執行被調用函數的函數體，執行完成后再轉回調用函數中，執行其后語句，而是在調用函數處用內聯函數體的代碼來替換，這樣將會節省調用開銷，提高運行速度。
• 內聯函數與帶參數的宏定義進行一下比較，它們的代碼效率是一樣的，但是內聯函數要優於宏定義，因為內聯函數遵循函數的類型和作用域規則，它與一般函數更相近，在一些編譯器中，一旦關上內聯擴展，將與一般函數一樣進行調用，調試比較方便。
• 外聯函數變成內聯函數的方法很簡單，只要在函
  數頭前面加上關鍵字inline就可以了。

2.2 將成員函數以內聯函數的形式進行說明

有兩種格式將成員函數聲明為類的內聯函數:

• （1）隱式聲明 直接將函數聲明在類內部。

class Coord{
public:
    void setCoord(int a,int b)
    { x=a; y=b;}
    int getx()
    { return x;}
    int gety()
    { retrun y;}
private:
    int x,y;
};

• （2）顯式聲明

在類聲明中只給出成員函數的原型，而成員函數體寫在類的外部。為了使它起內聯函數的作用，在成員函數返回類型前冠以關鍵字“inline”。

這種成員函數在類外定義的一般形式是:

inline 返回類型 類名::成員函數名(參數表)
{
// 函數體
}

class Coord{
public:
    void setCoord(int,int);
    int getx();
    int gety();
private:
    int x,y;
};
inline void Coord::setCoord(int a,int b)
{ x=a; y=b;}
inline int Coord::getx(){ return x;}
inline int Coord::gety(){ return y; }

說明

• (1)使用inline說明內聯函數時，必須使函數體和inline說明結合在一起，否則編譯器將它作為普通函數處理。

inline void Coord:: setCoord(int ,int);
// 不能說明這是一個內聯函數

• (2) 通常只有較短的成員函數才定義為內聯函數，對較長的成員函數最好作為一般函數處理。

class Date{
public:
    void showDate();
private:
    int year;
    int month;
    int day;
};
inline void Date::showDate()
{cout<<year<<'.';<<month<<'.'<<day<<endl;}

3. 對象的定義和使用

類與對象的關系

通常我們把具有共同屬性和行為的事物所構成的集合叫做類。

在C++中,可以把相同數據結構和相同操作集的對象看成屬於同一類。

在C++中，類也是一種用戶自定義數據類型，類的對象可以看成是該類類型的一個實例，定義一個對象和定義一個變量相似。類與對象間的關系，可以用數據類型int和整型變量i之間的關系類比。

C++把類的變量叫做類的對象，對象也稱為類的實例。

3.1 對象的定義

對象的定義， 也稱對象的創建

在C++中可以用以下兩種方法定義對象：

(1) 在聲明類的同時,直接定義對象。

class Coord {
public:
    void setCoord(int,int);
    int getx();
    int gety();
private:
    int x,y;
} op1,op2;

(2) 聲明了類之后,在使用時再定義對象

class Coord {
    //…
};
// …
main()
{
    Coord op1,op2;
    // …
}

說明：

• 在聲明類的同時定義的對象是一種全局對象，在它的生存期內任何函數都可以使用它。
• 聲明了一個類便聲明了一種類型，它並不接收和存儲具體的值，只作為生成具體對象的一種“樣板”，只有定義了對象后，系統才為對象分配存儲空間。

3.2 對象中成員的訪問

當定義了一個類的對象后，就可以訪問對象的成員了。在類的外部可以通過類的對象對公有成員進行訪問,訪問對象成員要使用操作符“.”。

訪問的一般形式是:

• 對象名.數據成員名
• 對象名.成員函數名(參數表)

其中“.”叫做對象選擇符,簡稱點運算符。

例2.2 使用類Coord的完整程序

#include<iostream.h>
class Coord {
public：
    void setCoord(int a,int b)
    { x=a; y=b; }
    int getx()
    { return x; }
    int gety()
    { return y; }
private：
    int x,y;
};
void main()
{
    Coord op1,op2;
    int i,j;
    op1.setCoord(5,6); // 調用op1的setCoord()，初始化對象op1
    op2.setCoord(7,8); // 調用op2的setCoord()，初始化對象op2
    i=op1.getx(); // 調用op1的getx()，取op1的x值
    j=op1.gety(); // 調用op1的gety()，取op1的y值
    cout<<"op1 i= "<<i<<" op1 j= "<<j<<endl;
    i=op2.getx(); // 調用op2的getx()，取op2的x值
    j=op2.gety(); // 調用op2的gety()，取op2的y值
    cout<<"op2 i= "<<i<<" op2 j= "<<j<<endl;
}

說明：

• 對象名.成員名實際上是一種縮寫形式，它表達的意義是:對象名.類名::成員名

void main( )
{
    Date date1;
    date1.setDate(2006,9,21);
    //……
}

• 在類的內部所有成員之間都可以通過成員函數直接訪問，但是類的外部不能訪問對象的私有成員。

例2.3 一個存在錯誤的程序

#include <iostream.h>
class Date {
public:
    void setDate(int y,int m,int d);
    void showDate();
private:
    int year;
    int month;
    int day;
};
void Date∷setDate(int y,int m,int d)
{
    year=y;
    month=m;
    day=d;
}
inline void Date∷showDate()
{
    cout<<year<<"."<<month<<"."<<day<<endl;
}
void main()
{
    Date date1,date2;
    cout<<"Date1 set and output:"<<endl;
    date1.setDate(1998,4,28);
    cout<<date1.year<<"."<<date1.month<<"."<<date1.day<<endl; //錯誤
    date1.showDate();
    cout<<"Date2 set and output： "<<endl;
    date2.setDate(2002,11,14);
    cout<<date2.year<<"."<<date2.month<<"."<<date2.day<<endl; //錯誤
    date2.showDate();•
}

• 在定義對象時，若定義的是指向對象的指針，則訪問此對象的成員時，要用“->”操作符。

void main( )
{
    Date *date3;
    date3->setDate(2001,8,15);
    //……
}

3.3 類成員的訪問屬性

類成員有三種訪問屬性:公有（public）、 私有（private） 和保護（protected） 。

• 說明為公有的成員不但可以被類中成員函數訪問;還可在類的外部,通過類的對象進行訪問。
• 說明為私有的成員只能被類中成員函數訪問,不能在類的外部,通過類的對象進行訪問。
• 說明為保護的成員除了類本身的成員函數可以訪問外,該類的派生類的成員也可以訪問,但不能在類的外部,通過類的對象進行訪問。類成員的訪問屬性

類的成員對類對象的可見性和對類的成員函數的可見性是不同的。

類的成員函數可以訪問類的所有成員，而類的對象對類的成員的訪問是受類成員的訪問屬性的制約的。

3.4 類中成員的訪問方式

• 類中成員互訪：直接使用成員名
• 類外訪問：使用“對象名.成員名”方式訪問 public 屬性的成員

class Sample{
public:
    int k;
    int geti(){return i;}
    int getj(){return j;}int getk(){return k;}
private:
    int i;
protected:
    int j;
};
//……
Sample a; //定義類Sample的對象a
a.i; //非法，類Sample的對象a不能訪問類的私有成員i
a.j; //非法，類Sample的對象a不能訪問類的保護成員j
a.k; //合法，類Sample的對象a能訪問類的公有成員k
//……

一般來說，公有成員是類的對外接口，而私有成員和保護成員是類的內部數據和內部實現，不希望外界訪問。

將類的成員划分為不同的訪問級別有兩個好處：一是信息隱蔽，即實現封裝；二是數據保護，即將類的重要信息保護起來，以免其它程序不恰當地修改。

3.5 對象賦值語句

兩個同類型的變量之間可以相互賦值。同類型的對象間也可以進行賦值，當一個對象賦值給另一個對象時，所有的數據成員都會逐位拷貝。

例2.5

#include<iostream.h>
class abc{
public:
    void init(int i,int j) { a=i; b=j; }
    void show(){ cout<<a<<" "<<b<<endl; }
private:
    int a,b;
};
main()
{
    abc o1,o2;
    o1.init(12,34);
    o2=o1; // 將對象o1數據成員的值賦給對象o2
    o1.show();
    o2.show();
    return 0;
}

說明：

• 在使用對象賦值語句進行對象賦值時，兩個對象的類型必須相同，如果對象的類型不同，編譯時將出錯。
• 兩個對象之間的賦值，僅僅使這些對象中數據成員相同，而兩個對象仍是分離的。
• 例2.5的對象賦值是通過缺省的賦值運算符函數實現的。
• 當類中存在指針時，使用缺省的賦值運算符進行對象賦值，可能會產生錯誤。

3.6 類的作用域

所謂類的作用域就是指在類聲明中的一對花括號所形成的作用域。

• 一個類的所有成員都在該類的作用域內,一個類的任何成員可以訪問該類的其他成員。
• 一個類的成員函數可以不受限制地訪問類的成員，而在類的外部，對該類的數據成員和成員函數的訪問則要受到一定的限制，有時甚至是不允許的,這體現了類的封裝功能。

例2.6 理解類的作用域

# include<iostream.h>
class myclass{
public:
    int i;
    void init(int);
    void show(){ cout<<“i=” <<i<<endl;} // 可以訪問類中的數據成員i
};
void myclass::init(int si){ i=si;} // 可以訪問類中的數據成員i
int fun(){ return i; } // 非法,不能直接訪問類中的i
void main()
{
    myclass ob;
    ob.init(5); // 給數據成員i賦初值5
    ob.show();
    i=8; // 非法,不能直接訪問類中的i,可改寫成ob.i=8
    ob.show();
}