C++ 一篇搞懂多態的實現原理

来源:https://www.cnblogs.com/xiaolincoding/archive/2020/02/01/12249144.html
-Advertisement-
Play Games

繼承關係用不好女人也可以是男人，複合關係用不好「狗中有人，人中有狗」的事情也會有。 ...


虛函數和多態

01 虛函數

  • 在類的定義中，前面有 virtual 關鍵字的成員函數稱為虛函數；
  • virtual 關鍵字只用在類定義里的函數聲明中，寫函數體時不用。
class Base 
{
    virtual int Fun() ; // 虛函數
};

int Base::Fun() // virtual 欄位不用在函數體時定義
{ }

02 多態的表現形式一

  • 「派生類的指針」可以賦給「基類指針」；
  • 通過基類指針調用基類和派生類中的同名「虛函數」時:
    1. 若該指針指向一個基類的對象，那麼被調用是
      基類的虛函數；
    2. 若該指針指向一個派生類的對象，那麼被調用
      的是派生類的虛函數。

這種機制就叫做“多態”，說白點就是調用哪個虛函數，取決於指針對象指向哪種類型的對象。

// 基類
class CFather 
{
public:
    virtual void Fun() { } // 虛函數
};

// 派生類
class CSon : public CFather 
{ 
public :
    virtual void Fun() { }
};

int main() 
{
    CSon son;
    CFather *p = &son;
    p->Fun(); //調用哪個虛函數取決於 p 指向哪種類型的對象
    return 0;
}

上例子中的 p 指針對象指向的是 CSon 類對象，所以 p->Fun() 調用的是 CSon 類里的 Fun 成員函數。

03 多態的表現形式二

  • 派生類的對象可以賦給基類「引用」
  • 通過基類引用調用基類和派生類中的同名「虛函數」時:
    1. 若該引用引用的是一個基類的對象，那麼被調
      用是基類的虛函數；
    2. 若該引用引用的是一個派生類的對象，那麼被
      調用的是派生類的虛函數。

這種機制也叫做“多態”，說白點就是調用哪個虛函數，取決於引用的對象是哪種類型的對象。

// 基類
class CFather 
{
public:
    virtual void Fun() { } // 虛函數
};

// 派生類
class CSon : public CFather 
{ 
public :
    virtual void Fun() { }
};

int main() 
{
    CSon son;
    CFather &r = son;
    r.Fun(); //調用哪個虛函數取決於 r 引用哪種類型的對象
    return 0;
}
}

上例子中的 r 引用的對象是 CSon 類對象，所以 r.Fun() 調用的是 CSon 類里的 Fun 成員函數。

04 多態的簡單示例

class A 
{
public :
    virtual void Print() { cout << "A::Print"<<endl ; }
};

// 繼承A類
class B: public A 
{
public :
    virtual void Print() { cout << "B::Print" <<endl; }
};

// 繼承A類
class D: public A 
{
public:
    virtual void Print() { cout << "D::Print" << endl ; }
};

// 繼承B類
class E: public B 
{
    virtual void Print() { cout << "E::Print" << endl ; }
};

A類、B類、E類、D類的關係如下圖：

int main() 
{
    A a; B b; E e; D d;
    
    A * pa = &a; 
    B * pb = &b;
    D * pd = &d; 
    E * pe = &e;
    
    pa->Print();  // a.Print()被調用，輸出：A::Print
    
    pa = pb;
    pa -> Print(); // b.Print()被調用，輸出：B::Print
    
    pa = pd;
    pa -> Print(); // d.Print()被調用，輸出：D::Print
    
    pa = pe;
    pa -> Print(); // e.Print()被調用，輸出：E::Print
    
    return 0;
}

05 多態作用

在面向對象的程式設計中使用「多態」，能夠增強程式的可擴充性，即程式需要修改或增加功能的時候，需要改動和增加的代碼較少。

LOL 英雄聯盟游戲例子

下麵我們用設計 LOL 英雄聯盟游戲的英雄的例子，說明多態為什麼可以在修改或增加功能的時候，可以較少的改動代碼。

LOL 英雄聯盟是 5v5 競技游戲，游戲中有很多英雄，每種英雄都有一個「類」與之對應，每個英雄就是一個「對象」。

英雄之間能夠互相攻擊，攻擊敵人和被攻擊時都有相應的動作，動作是通過對象的成員函數實現的。

下麵挑了五個英雄：

  • 探險家 CEzreal
  • 蓋樓 CGaren
  • 盲僧 CLeesin
  • 無極劍聖 CYi
  • 瑞茲 CRyze

基本思路：

  1. 為每個英雄類編寫 Attack、FightBack 和 Hurted 成員函數。
  • Attack 函數表示攻擊動作；
  • FightBack 函數表示反擊動作；
  • Hurted 函數表示減少自身生命值，並表現受傷動作。
  1. 設置基類CHero，每個英雄類都繼承此基類

02 非多態的實現方法

// 基類
class CHero 
{
protected:  
    int m_nPower ; //代表攻擊力
    int m_nLifeValue ; //代表生命值
};


// 無極劍聖類
class CYi : public CHero 
{
public:
    // 攻擊蓋倫的攻擊函數
    void Attack(CGaren * pGaren) 
    {
        .... // 表現攻擊動作的代碼
        pGaren->Hurted(m_nPower);
        pGaren->FightBack(this);
    }

    // 攻擊瑞茲的攻擊函數
    void Attack(CRyze * pRyze) 
    {
        .... // 表現攻擊動作的代碼
        pRyze->Hurted(m_nPower);
        pRyze->FightBack( this);
    }
    
    // 減少自身生命值
    void Hurted(int nPower) 
    {
        ... // 表現受傷動作的代碼
        m_nLifeValue -= nPower;
    }
    
    // 反擊蓋倫的反擊函數
    void FightBack(CGaren * pGaren) 
    {
        ...．// 表現反擊動作的代碼
        pGaren->Hurted(m_nPower/2);
    }
    
    // 反擊瑞茲的反擊函數
    void FightBack(CRyze * pRyze) 
    {
        ...．// 表現反擊動作的代碼
        pRyze->Hurted(m_nPower/2);
    }
};

有 n 種英雄，CYi 類中就會有 n 個 Attack 成員函數，以及 n 個 FightBack
成員函數。對於其他類也如此。

如果游戲版本升級，增加了新的英雄寒冰艾希 CAshe，則程式改動較大。所有的類都需要增加兩個成員函數:

void Attack(CAshe * pAshe);
void FightBack(CAshe * pAshe);

這樣工作量是非常大的！！非常的不人性，所以這種設計方式是非常的不好！

03 多態的實現方式

用多態的方式去實現，就能得知多態的優勢了，那麼上面的慄子改成多態的方式如下：

// 基類
class CHero 
{
public:
    virtual void Attack(CHero *pHero){}
    virtual voidFightBack(CHero *pHero){}
    virtual void Hurted(int nPower){}

protected:  
    int m_nPower ; //代表攻擊力
    int m_nLifeValue ; //代表生命值
};

// 派生類 CYi:
class CYi : public CHero {
public:
    // 攻擊函數
    void Attack(CHero * pHero) 
    {
        .... // 表現攻擊動作的代碼
        pHero->Hurted(m_nPower); // 多態
        pHero->FightBack(this);  // 多態
    }
    
    // 減少自身生命值
    void Hurted(int nPower) 
    {
        ... // 表現受傷動作的代碼
        m_nLifeValue -= nPower;
    }
    
    // 反擊函數
    void FightBack(CHero * pHero) 
    {
        ...．// 表現反擊動作的代碼
        pHero->Hurted(m_nPower/2); // 多態
    }
};

如果增加了新的英雄寒冰艾希 CAshe，只需要編寫新類CAshe，不再需要在已有的類里專門為新英雄增加：

void Attack( CAshe * pAshe) ;
void FightBack(CAshe * pAshe) ;

所以已有的類可以原封不動，那麼使用多態的特性新增英雄的時候，可見改動量是非常少的。

多態使用方式：

void CYi::Attack(CHero * pHero) 
{
    pHero->Hurted(m_nPower); // 多態
    pHero->FightBack(this);  // 多態
}

CYi yi; 
CGaren garen; 
CLeesin leesin; 
CEzreal ezreal;

yi.Attack( &garen );  //(1)
yi.Attack( &leesin ); //(2)
yi.Attack( &ezreal ); //(3)

根據多態的規則，上面的(1)，(2)，(3)進入到 CYi::Attack 函數後
，分別調用：

CGaren::Hurted
CLeesin::Hurted
CEzreal::Hurted

多態的又一例子

出一道題考考大家，看大家是否理解到了多態的特性，下麵的代碼，pBase->fun1()輸出結果是什麼呢？

class Base 
{
public:
    void fun1() 
    { 
        fun2(); 
    }
    
    virtual void fun2()  // 虛函數
    { 
        cout << "Base::fun2()" << endl; 
    }
};

class Derived : public Base 
{
public:
    virtual void fun2()  // 虛函數
    { 
        cout << "Derived:fun2()" << endl; 
    }
};

int main() 
{
    Derived d;
    Base * pBase = & d;
    pBase->fun1();
    return 0;
}

是不是大家覺得 pBase 指針對象雖然指向的是派生類對象，但是派生類里沒有 fun1 成員函數，則就調用基類的 fun1 成員函數，Base::fun1() 里又會調用基類的 fun2 成員函數，所以輸出結果是Base::fun2() ？

假設我把上面的代碼轉換一下， 大家還覺得輸出的是 Base::fun2() 嗎？

class Base 
{
public:
    void fun1() 
    { 
        this->fun2();  // this是基類指針，fun2是虛函數，所以是多態
    }
}

this 指針的作用就是指向成員函數所作用的對象， 所以非靜態成員函數中可以直接使用 this 來代表指向該函數作用的對象的指針。

pBase 指針對象指向的是派生類對象，派生類里沒有 fun1 成員函數，所以就會調用基類的 fun1 成員函數，在Base::fun1() 成員函數體里執行 this->fun2() 時，實際上指向的是派生類對象的 fun2 成員函數。

所以正確的輸出結果是：

Derived:fun2()

所以我們需要註意：

在非構造函數，非析構函數的成員函數中調用「虛函數」，是多態!!!

構造函數和析構函數中存在多態嗎？

在構造函數和析構函數中調用「虛函數」，不是多態。編譯時即可確定，調用的函數是自己的類或基類中定義的函數，不會等到運行時才決定調用自己的還是派生類的函數。

我們看如下的代碼例子，來說明：

// 基類
class CFather 
{
public:
    virtual void hello() // 虛函數
    {
        cout<<"hello from father"<<endl; 
    }
    
    virtual void bye() // 虛函數
    {
        cout<<"bye from father"<<endl; 
    }
};

// 派生類
class CSon : public CFather
{ 
public:
    CSon() // 構造函數
    { 
        hello(); 
    }
    
    ~CSon()  // 析構函數
    { 
        bye();
    }

    virtual void hello() // 虛函數
    { 
        cout<<"hello from son"<<endl;
    }
};

int main()
{
    CSon son;
    CFather *pfather;
    pfather = & son;
    pfather->hello(); //多態
    return 0;
}

輸出結果：

hello from son  // 構造son對象時執行的構造函數
hello from son  // 多態
bye from father // son對象析構時，由於CSon類沒有bye成員函數，所以調用了基類的bye成員函數

多態的實現原理

「多態」的關鍵在於通過基類指針或引用調用一個虛函數時，編譯時不能確定到底調用的是基類還是派生類的函數，運行時才能確定。

我們用 sizeof 來運算有有虛函數的類和沒虛函數的類的大小，會是什麼結果呢？

class A 
{
public:
    int i;
    virtual void Print() { } // 虛函數
};

class B
{
public:
    int n;
    void Print() { } 
};

int main() 
{
    cout << sizeof(A) << ","<< sizeof(B);
    return 0;
}

在64位機子，執行的結果：

16,4

從上面的結果，可以發現有虛函數的類，多出了 8 個位元組，在 64 位機子上指針類型大小正好是 8 個位元組，這多出 8 個位元組的指針有什麼作用呢？

01 虛函數表

每一個有「虛函數」的類（或有虛函數的類的派生類）都有一個「虛函數表」，該類的任何對象中都放著虛函數表的指針。「虛函數表」中列出了該類的「虛函數」地址。

多出來的 8 個位元組就是用來放「虛函數表」的地址。

// 基類
class Base 
{
public:
    int i;
    virtual void Print() { } // 虛函數
};

// 派生類
class Derived : public Base
{
public:
    int n;
    virtual void Print() { } // 虛函數
};

上面 Derived 類繼承了 Base類，兩個類都有「虛函數」，那麼它「虛函數表」的形式可以理解成下圖：

多態的函數調用語句被編譯成一系列根據基類指針所指向的（或基類引用所引用的）對象中存放的虛函數表的地址，在虛函數表中查找虛函數地址，並調用虛函數的指令。

02 證明虛函數表指針的作用

在上面我們用 sizeof 運算符計算了有虛函數的類的大小，發現是多出了 8 位元組大小（64位系統），這多出來的 8 個位元組就是指向「虛函數表的指針」。「虛函數表」中列出了該類的「虛函數」地址。

下麵用代碼的例子，來證明「虛函數表指針」的作用：

// 基類
class A 
{
public: 
    virtual void Func()  // 虛函數
    { 
        cout << "A::Func" << endl; 
    }
};

// 派生類
class B : public A 
{
public: 
    virtual void Func()  // 虛函數
    { 
        cout << "B::Func" << endl;
    }
};

int main() 
{
    A a;
    
    A * pa = new B();
    pa->Func(); // 多態
    
    // 64位程式指針為8位元組
    int * p1 = (int *) & a;
    int * p2 = (int *) pa;
    
    * p2 = * p1;
    pa->Func();
    
    return 0;
}

輸出結果：

B::Func
A::Func
  • 第 25-26 行代碼中的 pa 指針指向的是 B 類對象，所以 pa->Func() 調用的是 B 類對象的虛函數 Func()，輸出內容是 B::Func ；
  • 第 29-30 行代碼的目的是把 A 類的頭 8 個位元組的「虛函數表指針」存放到 p1 指針和把 B 類的頭 8 個位元組的「虛函數表指針」存放到 p2 指針；
  • 第 32 行代碼目的是把 A 類的「虛函數表指針」 賦值給 B 類的「虛函數表指針」，所以相當於把 B 類的「虛函數表指針」 替換 成了 A 類的「虛函數表指針」；
  • 由於第 32 行的作用，把 B 類的「虛函數表指針」 替換 成了 A 類的「虛函數表指針」，所以第 33 行調用的是 A 類的虛函數 Func()，輸出內容是 A::Func

通過上述的代碼和講解，可以有效的證明瞭「虛函數表的指針」的作用，「虛函數表的指針」指向的是「虛函數表」，「虛函數表」里存放的是類里的「虛函數」地址，那麼在調用過程中，就能實現多態的特性。

虛析構函數

析構函數是在刪除對象或退出程式的時候，自動調用的函數，其目的是做一些資源釋放。

那麼在多態的情景下，通過基類的指針刪除派生類對象時，通常情況下只調用基類的析構函數，這就會存在派生類對象的析構函數沒有調用到，存在資源泄露的情況。

看如下的例子：

// 基類
class A 
{
public: 
    A()  // 構造函數
    {
        cout << "construct A" << endl;
    }
    
    ~A() // 析構函數
    {
        cout << "Destructor A" << endl;
    }
};

// 派生類
class B : public A 
{
public: 
    B()  // 構造函數
    {
        cout << "construct B" << endl;
    }
    
    ~B()// 析構函數
    {
        cout << "Destructor B" << endl;
    }
};

int main() 
{
    A *pa = new B();
    delete pa;
    
    return 0;
}

輸出結果：

construct A
construct B
Destructor A

從上面的輸出結果可以看到，在刪除 pa指針對象時，B 類的析構函數沒有被調用。

解決辦法：把基類的析構函數聲明為virtual

  • 派生類的析構函數可以 virtual 不進行聲明；
  • 通過基類的指針刪除派生類對象時，首先調用派生類的析構函數，然後調用基類的析構函數，還是遵循「先構造，後虛構」的規則。

將上述的代碼中的基類的析構函數，定義成「虛析構函數」：

// 基類
class A 
{
public: 
    A()  
    {
        cout << "construct A" << endl;
    }
    
    virtual ~A() // 虛析構函數
    {
        cout << "Destructor A" << endl;
    }
};

輸出結果：

construct A
construct B
Destructor B
Destructor A

所以要養成好習慣:

  • 一個類如果定義了虛函數，則應該將析構函數也定義成虛函數;
  • 或者，一個類打算作為基類使用，也應該將析構函數定義成虛函數。
  • 註意：不允許構造函數不能定義成虛構造函數。

純虛函數和抽象類

純虛函數： 沒有函數體的虛函數

class A 
{

public:
    virtual void Print( ) = 0 ; //純虛函數
private: 
    int a;
};

包含純虛函數的類叫抽象類

  • 抽象類只能作為基類來派生新類使用，不能創建抽象類的對象
  • 抽象類的指針和引用可以指向由抽象類派生出來的類的對象
A a;         // 錯，A 是抽象類，不能創建對象
A * pa ;     // ok,可以定義抽象類的指針和引用
pa = new A ; // 錯誤, A 是抽象類，不能創建對象

推薦閱讀：

C++ this指針的理解和作用

C++ 一篇搞懂繼承的常見特性

C++ 賦值運算符'='的重載（淺拷貝、深拷貝）

C++ 手把手教你實現可變長的數組


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Redis詳解（二）——AOF
    Redis詳解（二）——AOF 前言 RDB 持久化存在一個缺點是一定時間內做一次備份，如果redis意外down掉的話，就會丟失最後一次快照後的所有修改(數據有丟失)。對於數據完整性要求很嚴格的需求，怎麼解決呢？ 本篇博客接著來介紹Redis的另一種持久化方式——AOF。 1、AOF簡介 Redi ...
  • Java基礎系列1：Java基本類型與封裝類型
    Java基礎系列1：Java基本類型與封裝類型 當初學習電腦的時候，教科書中對程式的定義是：程式=數據結構+演算法，Java基礎系列第一篇就聊聊Java中的數據類型。 本篇聊Java數據類型主要包括兩個內容： Java基本類型 Java封裝類型 Java基本類型 Java基本類型分類、大小及表示範圍 ...
  • @RequestParam，@PathParam，@PathVariable等註解區別
    @RequestParam 和 @PathVariable 註解是用於從request中接收請求的，兩個都可以接收參數，關鍵點不同的是@RequestParam 是從request裡面拿取值，而 @PathVariable 是從一個URI模板裡面來填充 @RequestParam看下麵一段代碼： h ...
  • scala安裝教程及簡單配置
    本文將介紹以下內容：Windows下安裝scala運行環境，安裝編譯工具並簡單配置，實現著名的“Hello,World"。 一，Windows下安裝scala運行環境 1.配置jdk,因為scala的運行需要依靠jvm虛擬機，所以在使用scala時需要有java環境 2.官網下載scala包，點擊這 ...
  • 從零開始學C++（0 簡介）
    2020年，給自己定一個新目標————開始寫技術博客，將之前所學的內容重新複習並整理成一系列的文章，一來可以讓自己對這些基礎知識更加熟悉，二來方便於以後的複習查閱。 以前自己都是以筆記的形式將知識點記錄在有道雲筆記中，這樣可能造成由於時間緊或者懶，只是記錄了筆記，沒有去深刻的理解。所以乘著這次全面復 ...
  • JavaAgent學習小結
    前言 最近因為公司需要,需要瞭解下java探針,在網上找資料,發現資料還是有很多的,但是例子太少,有的直接把公司代碼粘貼出來,太複雜了,有的又特別簡單不是我想要的例子, 我想要這樣的一個例子: jvm在運行,我想動態修改一個類,jvm在不用重啟的情況下, 自動載入新的類定義. 動態修改類定義,聽著感 ...
  • 使用SpringMVC時，web應用的資源路徑問題
    web應用常見的資源存方式 在WEB-INF下新建lib，存放要使用的jar包 在WEB-INF下新建jsp文件夾，存放jsp文件。首頁除外，首頁就放到web下。 在web下，或WEB-INF下，新建css、js、image文件夾，存放相關文件。 WEB-INF目錄是web應用的安全目錄，裡面的資源 ...
  • Thymeleaf--起步
    Spring官方支持的服務的渲染模板中，並不包含jsp。而是Thymeleaf和Freemarker等，而Thymeleaf與SpringMVC的視圖技術，及SpringBoot的自動化配置集成非常完美，幾乎沒有任何成本，你只用關註Thymeleaf的語法即可。 Thymeleaf的特點 動靜結合： ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類