程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> C語言 >> C++ >> 關於C++ >> 實例解析C++/CLI中的繼承與枚舉

實例解析C++/CLI中的繼承與枚舉

編輯:關於C++

本文中,將要介紹與繼承相關的C++/CLI主題,並以現實生活中銀行交易的三種形式:存款、取款、轉賬,來說明類的繼承體系,且以一種新的枚舉形式來實現。

枚舉器

請看例1中聲明的類型,它存在於其自身的源文件中,並編譯為一個只包含此類型的程序集:

例1:

public enum class TransactionType :
unsigned char {Deposit, Withdrawal, Transfer};

與想像的一樣,枚舉器中的Deposit、Withdrawal、Transfer分別代表0、1、2的常量值,但有三個方面卻讓這個enum類型與標准C++的enum類型(也就是"本地enum")大不相同。

·enum類只用於取代enum。這使TransactionType成為了一個CLI enum。(也允許enum結構,其與enum類等價。)

·此類型的可訪問性為public,以使其可從父類程序集外可見。(在C++/CLI中,一個本地enum類型也能有一個訪問限定符。)

·enum類有一個顯式的基本類型限定符:在本例中為unsigned char。(在C++/CLI中,一個本地enum也能有一個基本類型。)默認情況下,基本類型為int。基本類型也能為bool或除wchar_t之外的任意整形。(如果指定bool為基本類型,枚舉器必須顯式地進行初始化,因為沒有默認的初始值。)

支持這個新語法的原因是CLI enum遵從CLS標准,而本地enum卻不遵從。

CLI enum與本地enum間最大的區別在於構成方式上,枚舉名的作用范圍由它的父類enum類型來限定。另外,標准C++中定義的整數提升,並不適用於CLI enum。

與本地enum類似,一個CLI enum也能被定義在一個類中,在這種情況下,就不允許使用訪問限定符了,因為嵌套類型的可見性,已被其嵌入到的類型可見性所取代。

交易的抽象基類

交易類型的繼承體系在基類Transaction中,默認從System::Object繼承,見例2:

例2:

using namespace System;
using namespace System::Threading;
/*1*/
public ref class Transaction abstract
{
  TransactionType typeOfTransaction;
  /*2*/ DateTime dateTimeOfTransaction;
  public:
  /*3a*/ property TransactionType TypeOfTransaction
  {
   TransactionType get() { return typeOfTransaction; }
  private:
   void set(TransactionType value) { typeOfTransaction = value; }
}
/*3b*/ property DateTime DateTimeOfTransaction
{
  DateTime get() { return dateTimeOfTransaction; }
  private:
   void set(DateTime value) { dateTimeOfTransaction = value; }
}
/*4*/ virtual void PostTransaction() abstract;
protected:
/*5*/ Transaction(TransactionType transType)
{
  /*6*/ Thread::Sleep((gcnew Random)->Next(1000,2001));
  /*7*/ TypeOfTransaction = transType;
  /*8*/ DateTimeOfTransaction = DateTime::Now;
}
};

在標號1中,這個類被標為abstract(抽象類),這意味著它不能被直接實例化。(抽象不是一個關鍵字,僅僅在此上下文中作了保留。)這個abstract修飾詞可用於定義一個抽象類,而無須顯式地聲明一個或多個成員函數為純虛類型。

在類的私有數據成員部分,一個Transaction包含了一個交易類型及一個時間日期戳,兩者都由定義在標號3a及3b中的屬性來訪問。在標號2中使用的CLI庫值類型System::DateTime允許用一個即時變量顯示出當天的日期與時間。請注意,兩個屬性是怎樣擁有公有get方法與私有set方法的。(這是基於新的CLI標准,並且現在已與CLS兼容了。)

標號4要求每個具體的交易類型都有公共的成員函數PostTransaction,在此的abstract函數修飾符等同於標准C++語法中的純虛函數,一個抽象(abstract)函數必須顯式地聲明為virtual。

由於構造函數只應從繼承類中調用,所以定義在標號5中的構造函數為protected,但它需做的事情卻非常簡單:設置新的交易類型為傳遞進來的類型,並通過調用公有屬性DateTime::Now的get方法把時間日期戳設置為當前時間。有關傳遞進來的交易類型,應為一個值類型,而不允許為nullptr,由於CLI enum的強類型檢查,編譯器只允許同類型的枚舉器被傳遞,或者同類型的實例,當然了,其也只能被同類型的枚舉器所初始化。

通常地,構造函數必須盡快執行完,在此,為從測試程序中得出更多的結果,所以在程序中安置了一個延遲方法,因此時間日期戳在每次交易時都會改變,見標號6,構造函數會在初始化數據成員之前,隨機休眠一段時間。由於每個程序至少都會有一個執行線程,而此線程的有關特征可通過sealed System::Threading::Thread引用類來設置或獲取,Thread::Sleep函數則把當前執行線程掛起指定的毫秒數。

為使掛起的時間有所變化,使用了System::Random引用類來生成一系列的偽隨機數,標號6中重載的Next函數則獲取了一個"大於等於1000,小於2001"的數,也就是一至兩秒鐘的延遲。

存款、取款、轉賬類

例3定義了存款類,為什麼這個類為sealed呢?如果還沒有認真考慮過它是否足夠"健壯"以可作一個基類,那麼還是讓它不可以繼承吧。 例3:

using namespace System;
/*1*/
public ref class Deposit sealed : Transaction
{
  /*2*/ Decimal amount;
  int toAccount;
  public:
   /*3a*/ Deposit(double amount, int toAccount) :
   Transaction(TransactionType::Deposit)
   {
    DepositAmount = Decimal(amount);
    DepositToAccount = toAccount;
   }
   /*3b*/ Deposit(Decimal amount, int toAccount) :
   Transaction(TransactionType::Deposit)
   {
    DepositAmount = amount;
    DepositToAccount = toAccount;
   }
   property Decimal DepositAmount
   {
    Decimal get() { return amount; };
    private:
     void set(Decimal value) { amount = value; }
   }
   property int DepositToAccount
   {
    int get() { return toAccount; };
    private:
     void set(int value) { toAccount = value; }
   }
   /*4*/ void PostTransaction()
   {
    Console::WriteLine("{0} -- {1}", DateTimeOfTransaction, this);
   }
   virtual String^ ToString() override
   {
    /*5*/ return String::Format(" Dep: {0,10:0.00} {1,10}",DepositAmount, DepositToAccount);
   }
};

CLI只支持單一繼承,因此,值類和引用類只能有一個直接的基類,默認情況下為System::Object。在標號1中,Deposit直接繼承自Transaction,請注意沒有public訪問限定符,CLI只支持公有(public)繼承,所以在此也可寫為": public Transaction",但這是多余的。(對本地類而言,當繼承的類型為結構struct時,默認為公有繼承;當繼承的類型為類class時,默認為私有繼承。)

別忘了,CLI庫支持一種非常適合金融計算的類型--System::Decimal,可在標號2中用它來表示存款額。

為了方便,提供了兩個構造函數:一個接受表示為Decimal的數額,而另一個接受表示為double的數額。請注意,在兩個構造函數的定義中,是怎樣使用CLI enum作用域符來訪問枚舉器TransactionType中Deposit的。

為完成抽象基類,需提供標號4中的PostTransaction的實現,DateTime是一個值類型,因此當它的一個實例被傳遞進來時,它被裝箱以匹配WriteLine所期望的Object^,而this表達式類型為Deposit^,其也繼承自Object^。在這兩種情況中,繼承層次會一直往下,直到抵達並調用對應的ToString函數。

也能把函數PostTransaction聲明為sealed,這樣它就不能被覆蓋了,然而,如果父類本身已經為sealed,那麼函數永遠也不可能被覆蓋。

標號5中的格式指定符{0,10:0.00},表明在10個打印位寬度中右對齊數額,並四捨五入到小數點後兩位,且至少在小數點前有一位數。

Deposit類型直接依賴於Transaction與TransactionType類型,所以在Deposit的編譯期間,必須確保可訪問到這兩者的程序集。但是,編譯器可能會發出一個警告,表示TransactionType已經被引入了兩次,一次是直接,而另一次是間接地通過Transaction,在此,可安全地忽略此警告信息。

Withdrawal類定義在例4中,而Transfer類定義在例5中。

例4:

using namespace System;
public ref class Withdrawal sealed : Transaction
{
  Decimal amount;
  int fromAccount;
  public:
   Withdrawal(double amount, int fromAccount) : Transaction(TransactionType::Withdrawal)
   {
    WithdrawalAmount = Decimal(amount);
    WithdrawalFromAccount = fromAccount;
   }
   Withdrawal(Decimal amount, int fromAccount) : Transaction(TransactionType::Withdrawal)
   {
    WithdrawalAmount = amount;
    WithdrawalFromAccount = fromAccount;
   }
   property Decimal WithdrawalAmount
   {
    Decimal get() { return amount; };
    private:
     void set(Decimal value) { amount = value; };
   }
   property int WithdrawalFromAccount
   {
    int get() { return fromAccount; };
    private:
     void set(int value) { fromAccount = value; };
   }
   void PostTransaction()
   {
    Console::WriteLine("{0} -- {1}", DateTimeOfTransaction, this);
   }
   virtual String^ ToString() override
   {
    return String::Format("With: {0,10:0.00} {1,10}",
    WithdrawalAmount, WithdrawalFromAccount);
   }
};

例5:

using namespace System;
public ref class Transfer sealed : Transaction
{
  Decimal amount;
  int fromAccount;
  int toAccount;
  public:
   Transfer(double amount, int fromAccount, int toAccount): Transaction(TransactionType::Transfer)
   {
    TransferAmount = Decimal(amount);
    TransferFromAccount = fromAccount;
    TransferToAccount = toAccount;
   }
   Transfer(Decimal amount, int fromAccount, int toAccount): Transaction(TransactionType::Transfer)
   {
    TransferAmount = amount;
    TransferFromAccount = fromAccount;
    TransferToAccount = toAccount;
   }
   property Decimal TransferAmount
   {
    Decimal get() { return amount; };
    private:
     void set(Decimal value) { amount = value; };
   }
   property int TransferFromAccount
   {
    int get() { return fromAccount; };
    private:
     void set(int value) { fromAccount = value; };
   }
   property int TransferToAccount
   {
    int get() { return toAccount; };
    private:
     void set(int value) { toAccount = value; };
   }
   void Transfer::PostTransaction()
   {
    Console::WriteLine("{0} -- {1}", DateTimeOfTransaction, this);
   }
   virtual String^ ToString() override
   {
    return String::Format("Xfer: {0,10:0.00} {1,10} {2,10}",
    TransferAmount, TransferToAccount, TransferFromAccount);
   }
};

雖然三個PostTransaction的實現是同樣的,但在真實的交易處理系統中,這是不可能發生的。

測試程序

例6是測試交易類型的程序,它會創建一個具體交易類型的數組、遍歷此數組、調用每個元素的PostTransaction函數。插1是某次執行後的輸出,默認使用的是美國式的日期時間格式,即為,月、日、年、12小時制。

例6:

using namespace System;
int main()
{
  array<Transaction^>^ list = gcnew array<Transaction^> {
   gcnew Deposit(123.05, 12345),
   gcnew Transfer(Decimal::Parse("1256.40"), 1111, 222),
   gcnew Withdrawal(34.54, 232323),
   gcnew Deposit(56.12, 14321)
  };
  for each (Transaction^ t in list)
  {
   t->PostTransaction();
  }
}

插1:例6某次執行後的輸出

3/20/2005 12:36:16 AM -- Dep: 123.05 12345
3/20/2005 12:36:18 AM -- Xfer: 1256.40 222 1111
3/20/2005 12:36:19 AM -- With: 34.54 232323
3/20/2005 12:36:21 AM -- Dep: 56.12 14321

枚舉與繼承

一個CLI enum類型通常實現為一個值類型,且隱式繼承自System::Enum。同樣地,此類型的靜態與實例成員,它們的基類System::ValueType與類型的基類System::Object,在CLI enum類型或此類型的任意實例中,都可以訪問到。插2是例7的輸出。

例7:

using namespace System;
public enum class Color {Black, White, Red};
public enum class TransactionType :
unsigned char {Deposit, Withdrawal, Transfer};
int main()
{
  Color c = Color::White;
  /*1*/ Console::WriteLine("Color::Red's name is >{0}<",
  Enum::GetName(c.GetType(), Color::Red));
  Console::Write("Color's members are:");
  /*2*/ array<String^>^ names = Enum::GetNames(Type::GetType("Color"));
  for each (String^ s in names)
  {
   Console::Write(" {0}", s);
  }
  Console::WriteLine();
  /*3*/ Console::WriteLine("The type underlying Color is >{0}<",
  Enum::GetUnderlyingType(Color::typeid));
  /*4*/ Console::WriteLine("The type underlying TransactionType is >{0}<",
  Enum::GetUnderlyingType(TransactionType::typeid));
}

插2:例7的輸出

Color::Red's name is >Red<
Color's members are: Black White Red
The type underlying Color is >System.Int32<
The type underlying TransactionType is >System.Byte<

在標號1中,調用了Enum::GetName以找出特定enum類型枚舉器的名稱,第一個參數必須為System::Type類型,而獲取它的一個方法就是通過對感興趣的變量調用Object::GetType。

在標號2中,調用了Enum::GetNames以找出特定enum類型全部枚舉器的名稱,第一個參數必須為System::Type類型,而獲取它的一個方法就是通過對感興趣的變量(其以字符串形式表示的名稱)調用Type::GetType。

在標號3及標號4中,調用了Enum::GetUnderlyingType以找出這兩個CLI enum類型的底層類型,此處使用了一個更簡單的方法用於找出類型的Type對象--新形式的typeid操作符。

數組與繼承

每個CLI數組類型隱式繼承自抽象引用類型System::Array,另外,數組的某些成員屬性也繼承自這個基類,所以當使用一個CLI數組時,便可訪問到數組及對象的每個公有成員,見例8,插3是對應的輸出。數組的成員函數在此是直接調用的。

例8:

using namespace System;
generic<typename T>
void Display1DArray(String^ text, array<T>^ ary)
{
  if (ary == nullptr)
  {
   Console::WriteLine("nullptr passed");
   return;
  }
  Console::Write("{0} {1}:", text, ary->Length);
  for each (T element in ary)
  {
   Console::Write(" {0}", element);
  }
  Console::WriteLine();
}
int main()
{
  array<int>^ numbers = gcnew array<int>{10, 75, 23, 18, 53, 18};
  Display1DArray("numbers, original", numbers);
  /*1*/ Console::WriteLine("IndexOf(18) {0}", Array::IndexOf(numbers, 18));
  /*2*/ Console::WriteLine("LastIndexOf(18) {0}",
  Array::LastIndexOf(numbers, 18));
  /*3*/ Array::Sort(numbers);
  Display1DArray("numbers, sorted ", numbers);
  /*4*/ Console::WriteLine("BinarySearch(23) {0}",
  Array::BinarySearch(numbers, 23));
  /*5*/ Array::Reverse(numbers);
  Display1DArray("numbers, reversed", numbers);
  array<int>^ numbers2 = gcnew array<int>(4);
  /*6*/ Array::Copy(numbers, numbers2, numbers2->Length);
  Display1DArray("numbers2 ", numbers2);
 
  /*7*/ Array::Clear(numbers, 1, 4);
  Display1DArray("numbers, cleared ", numbers);
}

插3:例8的輸出

numbers, original 6: 10 75 23 18 53 18
IndexOf(18) 3
LastIndexOf(18) 5
numbers, sorted 6: 10 18 18 23 53 75
BinarySearch(23) 3
numbers, reversed 6: 75 53 23 18 18 10
numbers2 4: 75 53 23 18
numbers, cleared 6: 75 0 0 0 0 10

覆蓋 VS 隱藏

在一個虛擬函數調用時,其實例的運行時類型決定了實際要調用的具體函數實現;在一個非虛擬函數調用時,實例的編譯時類型才是最終的決定因素。

我們可從標准C++中得知,一個虛擬函數的實現,可被繼承類中的相應實現所取代,而這個取代的過程被稱為"覆蓋",其是通過使用override函數修飾符來完成的。鑒於一個虛擬函數的聲明引入了一個新的函數,那麼,通過提供一個此函數新的實現,一個覆蓋函數聲明可對繼承來的虛擬函數進行專門的細化。需覆蓋的函數必須顯式聲明為virtual。

當一個類重新聲明了一個它繼承來的函數名稱時,由於出現了new函數修飾符,那麼可以說這個類,隱藏了父類中的那個名稱。

請看例9中的代碼,留意變量的定義及在調用成員函數時的使用情況:

例9:

using namespace System;
public ref struct A
{
  /*1a*/ void F0() { Console::WriteLine("A::F0"); }
  /*1b*/ virtual void F1() { Console::WriteLine("A::F1"); }
  /*1c*/ virtual void F2() { Console::WriteLine("A::F2"); }
  //*1d*/ virtual void F3() { Console::WriteLine("A::F3"); }
};
public ref struct B : public A
{
  /*2a*/ void F0() new { Console::WriteLine("B::F0"); }
  /*2b*/ virtual void F1() override { Console::WriteLine("B::F1"); }
  /*2c*/ virtual void F2() new { Console::WriteLine("B::F2"); }
  private:
   //*2d*/ void F3() new { Console::WriteLine("B::F3"); }
};
public ref struct C : public B
{
  /*3a*/ void F0() new { Console::WriteLine("C::F0"); }
  /*3b*/ virtual void F1x() override = B::F1 { Console::WriteLine("C::F1x"); }
  /*3c*/ virtual void F2x() = B::F2 { Console::WriteLine("C::F2x"); }
  //*3d*/ virtual void F3() { Console::WriteLine("C::F3"); }
};

假定有以下代碼:

A^ a = gcnew A();
a->F0(); //調用 A::F0
a->F1(); //調用A::F1
a->F2(); //調用A::F2
a->F0():A::F0是一個非虛擬函數,因此使用的是a的編譯時類型(也就是A),導致A::F0被調用。
a->F1():A::F1是一個虛擬函數,因此使用的是a的運行時類型(也就是A),導致A::F1被調用。
a->F2():與A::F1類似,A::F2也是一個虛擬函數,因此使用的是a的運行時類型(也就是A),導致A::F2被調用。
B^ b = gcnew B();
b->F0(); //調用 B::F0
b->F1(); //調用B::F1
b->F2(); //調用B::F2
b->F0():B::F0是一個非虛擬函數,因此使用的是b的編譯時類型(也就是B),導致B::F0被調用。
b->F1():B::F1覆蓋了虛擬函數A::F1,因此使用的是b的運行時類型(也就是B),導致B::F1被調用。
b->F2():B::F2(通過new)隱藏了虛擬函數A::F2,因此使用的b的是編譯時類型(也就是B),導致B::F2被調用。這個隱藏函數同樣也為virtual,允許繼承自B的類覆蓋這個帶有new的函數。
a = b;
a->F0(); //調用 A::F0
a->F1(); //調用B::F1
a->F2(); //調用A::F2
a->F0():A::F0是一個非虛擬函數,因此使用的是a的編譯時類型(也就是A),導致A::F0被調用。
a->F1():A::F1是一個虛擬函數,因此使用的是a的運行時類型(也就是B),導致B::F1被調用。
a->F2():A::F2是一個虛擬函數,其被函數B::F2所隱藏,因此使用的是a的編譯時類型(也就是A),導致A::F2被調用。(請記住,要先有後續的覆蓋函數,才會有動態查詢過程,而在本例中,是不存在的。)
C^ c = gcnew C();
c->F0(); //調用C::F0
c->F1(); //調用C::F1x
c->F2(); //調用 C::F2x
c->F0():C::F0是一個非虛擬函數,因此使用的是c的編譯時類型(也就是C),導致C::F0被調用。
c->F1():C::F1x是一個虛擬函數,因此使用的是c的運行時類型(也就是C),但是,在C::F1x的情況中,使用了一個命名覆蓋,也就是說,被覆蓋的函數與覆蓋函數有著不同的名稱,這導致C::F1x被調用。
c->F2():C::F2x覆蓋了虛擬函數B::F2,因此使用的是c的運行時類型(也就是C),導致C::F2x被調用。(正如大家所見,在這個命名覆蓋中,省略了顯式覆蓋修飾符。)
b = c;
b->F0(); //調用 B::F0
b->F1(); //調用C::F1x
b->F2(); //調用C::F2x
b->F0():B::F0是一個非虛擬函數,因此使用的是b的編譯時類型(也就是B),導致B::F0被調用。
b->F1():B::F1覆蓋了虛擬函數A::F1,因此使用的是b的運行時類型(也就是C),導致C::F1x被調用。
b->F2():B::F2是一個虛擬函數,因此使用的是b的運行時類型(也就是C),導致C::F2x被調用。
a = c;
a->F0(); //調用A::F0
a->F1(); //調用C::F1x
a->F2(); //調用 A::F2
a->F0():A::F0是一個非虛擬函數,因此使用的是a的編譯時類型(也就是A),導致A::F0被調用。
a->F1():A::F1是一個虛擬函數,因此使用的是a的運行時類型(也就是C),導致C::F1x被調用。
a->F2():A::F2是一個虛擬函數,其被函數B::F2所隱藏,因此使用的是a的編譯時類型(也就是A),導致A::F2被調用。(請記住,要先有後續的覆蓋函數,才會有動態查詢過程,而在這些例子中,是不存在的。)

訪問限定符

標准C++支持三種成員訪問限定符:public、protected、private。為了適應程序集,C++/CLI添加了另外三種,完整地列在下表中:

·public意味著訪問不受限制。

·protected意味著訪問受限於包含的類,及任意繼承自包含類的類型。

·private意味著訪問受限於包含的類中。

·internal意味著訪問受限於父類程序集。

·public protected(或protected public)意味著訪問受限於父類程序集,及繼承自包含類的類型--即使這些類型位於程序集之外。

·private protected(或protected private)意味著訪問受限於父類程序集,及繼承自包含類的類型--倘若這些類型是定義在這個程序集內的。

通過對父類施予更嚴格的訪問限定符,成員也能具有更少的可訪問性,另外,千萬不要混淆成員名可訪問性和類型可見性(類型可見性只能為public或private)。

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved