[翻譯] Effective C++, 3rd Edition, Item 41: 理解 implicit interfaces(隱式介面)和 compile-time polymorphism(編譯

來源:互聯網
上載者:User

Item 41: 理解 implicit interfaces(隱式介面)和 compile-time polymorphism(編譯期多態)

作者:Scott Meyers

譯者:fatalerror99 (iTePub's Nirvana)

發布:http://blog.csdn.net/fatalerror99/

Object-Oriented Programming(物件導向編程)的世界是圍繞著 explicit interfaces(顯式介面)和 runtime polymorphism(執行期多態)為中心的。例如,給出下面這個(沒有什麼意義的)class(類),

class Widget {
public:
  Widget();
  virtual ~Widget();
  virtual std::size_t size() const;
  virtual void normalize();
  void swap(Widget& other);                 // see Item 25

  ...
};

以及這個(同樣沒有什麼意義的)function(函數),

void doProcessing(Widget& w)
{
  if (w.size() > 10 && w != someNastyWidget) {
      Widget temp(w);
      temp.normalize();
      temp.swap(w);
  }
}

我們可以這樣談論 doProcessing 中的 w:

  • 因為 w 被聲明成類型 Widget,則 w 必須支援 Widget interface(介面)。我們可以在原始碼中找到這個 interface(介面)(例如,Widget 的 .h 檔案)以看清楚它是什麼樣子的,所以我們稱其為一個 explicit interface(顯式介面)——它在原始碼中顯式可見。
  • 因為 Widget 的一些 member functions(成員函數)是虛擬,w 對這些函數的調用就表現為 runtime polymorphism(執行期多態):被調用的特定函數在執行期基於 w 的 dynamic type(動態類型)來確定(參見 Item 37)。

templates(模板)和 generic programming(泛型程式設計)的世界是根本不同的。在那個世界,explicit interfaces(顯式介面)和 runtime polymorphism(執行期多態)繼續存在,但是它們不那麼重要了。反而,implicit interfaces(隱式介面)和 compile-time polymorphism(編譯期多態)移到了前台。為了瞭解這是怎樣一種情況,看一下當我們把 doProcessing 從一個 function(函數)變成一個 function template(函數模板)時會發生什麼:

template<typename T>
void doProcessing(T& w)
{
  if (w.size() > 10 && w != someNastyWidget) {
     T temp(w);
     temp.normalize();
     temp.swap(w);
  }
}

現在我們可以如何談論 doProcessing 中的 w 呢?

  • w 必須支援的 interface(介面)是通過 template(模板)中在 w 身上所執行的操作確定的。在本例中,它顯現為 w 的類型 (T) 必須支援 size,normalize 和 swap member functions(成員函數);copy construction(拷貝建構函式)(用於建立 temp);以及對不等於的比較(用於和 someNastyWidget 之間的比較)。我們將在以後看到這並不很精確,但是對於現在來說它已經足夠正確了。重要的是這一系列為了模板能夠編譯必須合法的運算式就是 T 必須支援的 implicit interface(隱式介面)。
  • 對諸如 operator> 和 operator!= 這樣的涉及 w 的函數的調用可能伴隨 instantiating templates(執行個體化模板)以使這些調用成功。這樣的 instantiation(執行個體化)發生在編譯期間。因為用不同的 template parameters(模板參數)執行個體化 function templates(函數模板)導致不同的函數被調用,因此以 compile-time polymorphism(編譯期多態)聞名。

即使你從沒有使用過模板,你也應該熟悉 runtime(運行期)和 compile-time polymorphism(編譯期多態)之間的區別,因為它類似於確定一系列重載函數中哪一個應該被調用的過程(這個發生在編譯期)和 virtual function(虛擬函數)調用的 dynamic binding(動態綁定)(這個發生在運行期)之間的區別。explicit(顯式)和 implicit interfaces(隱式介面)之間的區別是與 templates(模板)有關的新內容,需要對他進行近距離的考察。

一個 explicit interface(顯式介面)一般由 function signatures(函數識別特徵)組成,也就是說,函數名,參數類型,傳回型別,等等。例如,Widget class(類)的 public interface(公有介面),

class Widget {
public:
  Widget();
  virtual ~Widget();
  virtual std::size_t size() const;
  virtual void normalize();
  void swap(Widget& other);
};

由一個 constructor(建構函式),一個 destructor(解構函式),以及函數 size,normalize 和 swap 組成,再加上 parameter types(參數類型),return types(傳回型別)和這些函數的 constnesses(常量性)。(它也包括 compiler-generated(編譯器產生)的 copy constructor(拷貝建構函式)和 copy assignment operator(拷貝賦值運算子)——參見 Item 5。)它還可能包含 typedefs,還有,如果你膽大包天敢於違背 Item 22 的讓 data members(資料成員)private(私人)的建議,那就包括 data members(資料成員),雖然在當前情況下,它不是。

一個 implicit interface(隱式介面)有很大不同。它不是基於 function signatures(函數識別特徵)的。它是由 valid expressions(合法運算式)組成的。再看一下在 doProcessing template 開始處的條件:

template<typename T>
void doProcessing(T& w)
{
  if (w.size() > 10 && w != someNastyWidget) {
  ...

對於 T(w 的類型)的 implicit interface(隱式介面)看起來有如下這些約束:

  • 它必須提供一個名為 size 的返回一個整數值的 member function(成員函數)。
  • 它必須支援一個用於比較兩個類型 T 的對象的 operator!= 函數。(這裡,我們假定 someNastyWidget 的類型為 T。)

由於 operator overloading(運算子多載)的可能性,這兩個約束都不必滿足。是的,T 必須支援一個 size member function(成員函數),可是值得一提的是這個函數可以是從一個 base class(基類)繼承來的。但是這個 member function(成員函數)不必返回一個整數類型。它甚至不必返回一個數實值型別。對於這種情況,它甚至不必返回一個定義了 operator> 的類型!它要做的全部就是返回某種類型 X 的一個 object(對象),存在一個可以由一個類型 X 的 object(對象)和一個 int(因為 10 為 int 類型)來調用的 operator>。這個 operator> 不一定非要取得一個類型 X 的參數,因為只要存在一個從類型 X 的 objects(對象)到類型 Y 的 objects(對象)的 implicit conversion(隱式轉型),它只取得一個類型 Y 的參數也是可以的!

類似地,T 支援 operator!= 也是沒有必要的,因為正像 operator!= 取得一個類型 X 的 objects(對象)和一個類型 Y 的 objects(對象)是可接受的一樣。只要 T 能轉型為 X,而 someNastyWidget 的類型能夠轉型為 Y,對 operator!= 的調用就是合法的。

(旁註:此處的分析沒有考慮 operator&& 被重載的可能性,這會將上面的運算式的含義從邏輯與轉換到某些大概完全不同的東西。)

第一次考慮 implicit interfaces(隱式介面)的時候,大多數人都會頭疼,但是他們真的不需要阿司匹林。implicit interfaces(隱式介面)簡單地由一套 valid expressions(合法運算式)構成。這些運算式自身看起來可能很複雜,但是它們施加的約束通常是簡單易懂的。例如,給出這個條件,

if (w.size() > 10 && w != someNastyWidget) ...

關於 functions size,operator>,operator&& 或 operator!= 上的約束很難說出更多的東西,但是要識別出整個運算式的約束是非常簡單的。一個 if 語句的條件部分必須是一個 boolean expression(布林運算式),所以不管 "w.size() > 10 && w != someNastyWidget" 所產生的精確類型是哪一種,它必須與 bool 相容。這就是 template(模板)doProcessing 施加於它的 type parameter(型別參數)T 之上的 implicit interface(隱式介面)的一部分。doProcessing 必需的 interface(介面)的其餘部分是 copy constructor(拷貝建構函式),normalize 和 swap 的調用對於類型 T 的 objects(對象)來說必須是合法的。

implicit interface(隱式介面)對 template(模板)的 parameters(參數)施加的影響正像 explicit interfaces(顯式介面)對一個 class(類)的 objects(對象)施加的影響,而且這兩者都在編譯期間被檢查。正像你不能用與它的 class(類)提供的 explicit interface(顯式介面)矛盾的方法使用 object(對象)(代碼無法編譯)一樣,除非一個 object(對象)支援 template(模板)所必需的 implicit interface(隱式介面),否則你就不能在一個 template(模板)中試圖使用這個 object(對象)(代碼還是無法編譯)。

Things to Remember

  • classes(類)和 templates(模板)都支援 interfaces(介面)和 polymorphism(多態)。
  • 對於 classes(類),interfaces(介面)是 explicit(顯式)的並以 function signatures(函數識別特徵)為中心。polymorphism(多態性)通過 virtual functions(虛擬函數)出現在運行期。
  • 對於 template parameters(模板參數),interfaces(介面)是 implicit(隱式)的並基於 valid expressions(合法運算式)。polymorphism(多態性)通過 template instantiation(模板執行個體化)和 function overloading resolution(函數重載解析)出現在編譯期。

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.