C++ Primer 答客問 (27) 【標準與實作之間】

C++ Primer 答客問 (27) 【標準與實作之間】

PC 環境上三種編譯器對 C++ Standard 的支援

侯捷  jjhou@ccca.nctu.edu.tw
1999.12.29 第一次發表於
清大.楓橋驛站（140.114.87.5）.電腦書訊版（Computer/CompBook）

本文將於日後整理於 侯捷網站/答客問 /C++ Primer 中文版
侯捷網站：www.jjhou.com
----------------------------------------------------------------

●C++ Standard 相容編譯器

我想很多人關心，目前市面上哪些廠牌的 C++ 編譯器，完全
支援 C++ Standard。C/C++ User Journal, Nov. 1999 的
【C/C++ Stanadrd FAQ】專欄中，P.J. Plauger 對此問題
的回答是：目前還沒有完全支援 C++ Standard 的編譯器產品。
P.J. Plauger 閱歷廣泛，他的文章提到不同平台上的多種
C++ 編譯器（但並沒有深入談論，都只淺淺帶過）。

回憶歷史，C Standard 定案後，市面上立刻出現一大堆宣稱與標準規格
完全相容 的 C 編譯器。為什麼符合 C++ 標準規格的編譯器卻是如此
難產呢？我想因素之一是，C++ 遠比 C 複雜得多，後期導入的一些
性質（如 member templates, template partial specialization...）
在編譯器技術層面上更是高難度。因素之二是，C++ Standard library
是個浩大的工程，而編譯器通常是以 bundle 的方式搭配其他公司
的 C++ Standard Library，所以彼此的進度、技術、相容性都需要更多
時間來協調配合。因素之三是，C++ 編譯器的價值比較，已經不再只是
單純地比誰對 C++ Standard 的支援程度高（或甚至也不是比較誰的
編譯速度快），而是比較在特定平台上對客戶是否有更多的企業服務。
拿 Windows 環境上的 C++ 編譯器來說，「誰提供更好的 Windows 應用
軟體開發工具與開發資源」可能比「誰更貼近 C++ Standard」，對客戶
而言更為重要。

但是大家還是會很關心哪家編譯器最貼近 C++ Standard -- 即使這
不影響你對 C++ 編譯器的選擇。

●個人經驗

自從我將 L&L（Lippman & Lajoie）的《C++ Primer》譯出後，
面對 C++ Standard 所規範的許多嶄新性質，就有一股躍躍欲試
的衝動。其後由於個人興趣，也因為課程需要，把《C++ Primer 中文版》
整個重新檢閱一遍，並動手在三種不同的編譯器上進行測試
（都是 PC/Windows 平台）。以下整理我的個人經驗，供各位參考。

我儘量為每一個主題列出一份簡短而完整的測試碼。這些或許不是
太嚴謹的測試，但是如果這些符合 C++ Standard 的程式碼無法通過編譯，
我們說這個編譯器未能奉行 C++ Standard，並不過份。但反過來說，
通過我所列之簡易測試者，或許仍有可能在更複雜的情況中出錯（尤其是
template 相關主題）。如果您有相關經驗，歡迎提供出來造福大家。

沒有什麼好點子，可以對以下各個主題編號排序。所以我
以它們出現在《C++ Primer 中文版》上的頁次為序。
擁有英文版的讀者請注意，中文版和英文版頁次完全相同。


●測試環境

我的測試環境是：Intel Pentium，Windows 98，三套 C++ 編譯器：
(1) Microsoft Visual C++ 6.0（以下以 VC6 代表）
(2) Inprise Borland C++Builder 4.0  （以下以 BCB4 代表）
(3) GNU C++ egcs-2.91.57（以下以 G++ 代表）

請注意，GNU C++ 有著各種作業平台上的各種版本。我只用手上的
egcs-2.91.57(for win32) 來測試。

我在 Windows 98 文字模式（console mode）底下進行編譯。以下是
三種編譯器的環境設定（其中路徑可能與你不同。如欲循此方式設定，
請自行修改）：

★VC6 環境設定
@echo off
rem
set PATH=C:/MSDEV/VC98/BIN;C:/MSDEV/COMMON/MSDEV98/BIN
set INCLUDE=C:/MSDEV/VC98/INCLUDE
set LIB=C:/MSDEV/VC98/LIB

★BCB4 環境設定
@echo off
rem
set PATH=C:/inprise/CBuilder4/BIN
set INCLUDE=C:/inprise/CBuilder4/INCLUDE
set LIB=C:/inprise/CBuilder4/LIB

★G++ egcs-2.91.57 環境設定
@echo off
rem
set PATH=c:/CYGNUS/CYGWIN~1/H-I586~1/BIN
set INCLUDE=
set LIB=
cls

我的編譯選項（compile options）極其簡單，

★VC6  : cl -GX test.cpp
★BCB4 : bcc32 test.cpp
★G++  : g++ -o test.exe test.cpp


●發表

我把這份內容放在 BBS/News 上，歡迎傳佈，無需特別知會。

歡迎以下的討論與指正：

1. 如果加上任何編譯選項（compile options）即可解決（避免）
   所列之任何一個錯誤的話，歡迎（敬請）告知。
2. 如果我的文字或程式碼有任何問題，歡迎（敬請）告知。
3. 如果您有其他（未列於本文）的編譯器問題，歡迎（敬請）告知。

歡迎於 BBS/News 上討論。如能同時轉寄一份給我，以免除我
遺漏觀看的可能，最是感謝。如不欲公開討論，亦歡迎將意見
直接 email 給我。如欲討論，請寫實例，不要只是臆測。

我會註明對本文有助之朋友的大名及其意見，以示感謝。


■C++ Primer p213 下, p.393 下
主題：for loop 的 init-statement 區域內，所有 objects 皆為 local。
測試結果：VC6[x]  BCB4[o]  G++[o]
實例：

#001 void main()
#002 {
#003 for (int ival=0; ival< 10; ++ival);
#004 for (int ival=0; ival< 10; ++ival);
#005 }

注意：C/C++ User Journal, Oct.1999, p.94 曾提過在 VC 上的一個簡易
閃避辦法，這並且也是明載於 MSDN News（Vol7, Num6, Dr. GUI column）
上的作法。設計一個巨集如下即可解決：

#define for   if(0); else for

該文並說，在簡單情況下可以有效運作，但並未測試太過複雜的情況。


■C++ Primer p262 中
主題：STL list 建構時，直接給 list 的大小及初值（做為所有元素的相同初值）
測試結果：VC6[o]  BCB4[x]  G++[o]
實例：

#001 #include <list>
#002 ...
#003 const int list_size = 64;
#004 list<int> ilist1(list_size);      // BCB4 error.  VC6 ok. G++ ok
#005 list<string> ilist2(list_size);   // BCB4 ok.     VC6 ok. G++ ok
#006 list<int> ilist3(list_size, -1);  // BCB4 ok.     VC6 ok. G++ ok
#007 list<int> ilist4(list_size, 0);   // BCB4 error   VC6 ok. G++ ok
#008 list<int> ilist5(list_size, 1);   // BCB4 error   VC6 ok. G++ ok
#009 list<int> ilist6(list_size, -6);  // BCB4 ok.     VC6 ok. G++ ok

歸納：看來似乎 BCB4 不允許讓 list<int> 只獲得一個引數，也不允許
list<int> 獲得正值初值。很奇怪的行為。我疏忽了什麼嗎？

2001/08/22 補充：
BCB5[o]. 謝謝 Lianchao Xu




■C++ Primer p383 上
主題：透過指向「函式指標陣列」的指標，喚起該陣列中的函式指標，
      其型式有簡略式和明顯式兩種。
測試結果：VC6[x]  BCB4[x]  G++[x]  （都不支援簡略型式）
實例：

#001 #include <iostream.h>
#002
#003 typedef int (*PFV)();
#004 int f1() { return 1; }
#005 int f2() { return 2; }
#006
#007 PFV fFuncs[2] = { f1, f2 };
#008 PFV (*pfFuncs)[2] = &fFuncs;
#009
#010 void main()
#011 {
#012   cout << fFuncs[0]() << endl;  // 1
#013   cout << fFuncs[1]() << endl;  // 2
#014
#015   cout << pfFuncs[0]() << endl;  // 簡略式，VC6[x]  BCB4[x]  G++[x]
#016   cout << ((*pfFuncs)[1])() << endl;  // 2 （明顯式）
#017 }

2001/08/22 補充：
Lianchao Xu 建議我把：
#008 PFV (*pfFuncs)[2] = &fFuncs;
改為：
#008 PFV *pfFuncs = fFuncs;

再把：
#015   cout << pfFuncs[0]() << endl;  // 簡略式，VC6[x]  BCB4[x]  G++[x]
#016   cout << ((*pfFuncs)[1])() << endl;  // 2 （明顯式）
改為：
#015   cout << (*pfFuncs[0])() << endl;  // 1
#016   cout << (*pfFuncs[1])() << endl;  // 2

測試結果：VC6[o]  BCB4[o]  G++[o]
謝謝。不過這並不是我的測試初衷。




■C++ Primer p410 上
主題：各編譯器對 auto_ptr 的支援
測試結果：VC6[o]  BCB4[o]  G++[x]
實例：

#001 #include <memory>  // for auto_ptr
#002 using namespace std;
#003 int main()
#004 {
#005    auto_ptr<int> pi(new int(1024));  // G++ error: auto_ptr undeclared.
#006 }

讀者來函：我測試發現 vc6 的「語意」是錯的，它指派給另一個，會造成
          兩個 auto_ptr 都指向同一個物件。BCB5 的結果就正確。


■C++ Primer p411
主題：string* 的建構（直接指定以另一個 string*）
測試結果：VC6[x]  BCB4[o]  G++[o]
實例：

#001 #include <string>
#002 using namespace std;
#003 int main()
#004 {
#005   string *pstr_type = new string( "Brontosaurus" );
#006   string *pstr_type2( pstr_type );  // <== VC6 error.
#007   delete pstr_type;
#008   delete pstr_type2;
#009 }


■p.412 中下
主題：auto_ptr 的 reset() 動作
測試結果：VC6[x]  BCB4[o]  G++[x]
實例：

#001 #include <memory>  // for auto_ptr
#002 using namespace std;
#003 int main()
#004 {
#005   auto_ptr<int> p_auto_int;         // <== G++ error. 見前述 p.410 例
#006   p_auto_int.reset(new int(1024));  // <== VC6 and G++ error
#007 }


■C++ Primer p461
主題：lvalue-to-rvalue 轉換，rvalue-to-lvalue 轉換。
討論：lvalue-to-rvalue 屬於完全吻合（exact match）轉換的一種。
      但是 rvalue-to-lvalue 呢？例如以一個 literal constant 或
      temporary object 指派給一個 reference？應該不行，除非是
      指派給一個 const reference。
測試結果：我的經驗是，各編譯器對此一主題寬緊不一，且無定法（至少我歸納不出）
例一：

#001 int main()
#002 {
#003  int &i = 3;             // (1) should be error
#004                          // rvalue assign to non-const reference
#005  const int &i2 = 3;      // (2) should be ok
#006                          // rvalue assign to const reference
#007  int &i3 = int(3);       // (3) should be error
#008                          // rvalue (temp obj) assign to non-const reference
#009  const int &i4 = int(3); // (4) should be ok
#010                          // rvalue (temp obj) assign to const reference
#011 }
#012
#013 // G++ : (1),(3) warning: initialization of non-const reference `int &'
#014 //                        from rvalue `int'
#015 // jjhou 使用 G++ 2.91.57。
#016 // 據 jyhuang 說，G++ 2.92.2 並不允許通過 (1),(3)。
#017 //
#018 // VC6 : (1),(3) error: 'initializing' : cannot convert from 'const int'
#019 //                      to 'int &'. A reference that is not to 'const'
#020 //                      cannot be bound to a non-lvalue
#021 //
#022 // BCB4: (1),(2),(3),(4) warning: Temporary used to initialize 'i'
#023 //                                in function main ()

例二：

#001 void func1(int  i) { };           // pass by value
#002 void func2(int& i) { };           // pass by reference
#003 void func3(int* i) { };           // pass by pointer
#004 void func4(const int& i) { };     // pass by reference
#005
#006 void main()
#007 {
#008 int i;
#009 const int ci = 5;
#010
#011   func1(i);      // lvalue-to-rvalue, always ok.
#012   func1(ci);
#013   func2(i);
#014   func2(ci);     // (15)
#015   func3(&i);
#016   func3(&ci);    // (17)
#017   func4(i);
#018   func4(ci);
#019
#020   func2(int(6)); // (21), rvalue-to-nonconst-reference.
#021   func4(int(6)); // rvalue-to-const-reference, always ok.
#022 }
#023
#024 /*
#025 VC6 :
#026 (15) : error C2664: 'func2' : cannot convert parameter 1 from
#027        'const int' to 'int &'. Conversion loses qualifiers
#028 (17) : error C2664: 'func3' : cannot convert parameter 1 from
#029        'const int *' to 'int *'. Conversion loses qualifiers
#030 (21) : error C2664: 'func2' : cannot convert parameter 1 from
#031        'int' to 'int &'.
#032        A reference that is not to 'const' cannot be bound to a non-lvalue
#033
#034 BCB4 :
#035 Warning (15): Temporary used for parameter 'i' in call to 'func2(int &)'
#036 Error (17): Cannot convert 'const int *' to 'int *'
#037 Error (17): Type mismatch in parameter 'i' in call to 'func3(int*)'
#038 Warning (21): Temporary used for parameter 'i' in call to 'func2(int &)'
#039
#040 G++ :
#041 (15): warning: conversion from `const int' to `int &' discards const
#042 (3) : warning: in passing argument 1 of `func2(int &)'
#043 (17): warning: passing `const int *' as argument 1 of `func3(int *)' discards const
#044 (21): warning: initialization of non-const reference `int &' from rvalue `int'
#045 (3) : warning: in passing argument 1 of `func2(int &)'
#046 */

例三：詳見「C++ Primer 答客問 (19) part-3」


■p.492, p.499, p.500
主題：以 template nontype parameter 做為陣列尺度（dimension）
測試結果：VC6[x]  BCB4[o]  G++[o]
注意：G++ 對於型別的 const-ness 檢驗極嚴格。以下 (1) 必須改為
      const int ia[5] =...; 才能通過 G++。
實例：

#001 template <class Type, int size>
#002 Type min( const Type (&r_array)[size] ) // VC6 error C2057:
#003 { /* ... */ }                           //  expected constant expression
#004
#005 void main()
#006 {
#007   int ia[5]={40,20,49,17,28}; // (1) 注意，G++ 要求需為 const int ia[5]。
#008   min(ia);
#009 }


■C++ Primer p500 中上
主題：利用轉型運算子，將 template function 在模稜兩可（ambiguous）的環境下
      以某特定型別具現化（instantiated）。
測試結果：VC6[x]  BCB4[x]  G++[x]
實例：

#001 template <typename Type, int size>
#002 Type min( Type (&r_array)[size] ) { /*... */ }  // VC6 error C2057
#003
#004 typedef int (&rai)[10];    // rai："10 個 ints 組成之陣列" 的 reference.
#005 typedef double (&rad)[20]; // rad："20 個 doubles 組成之陣列" 的 reference
#006
#007 // overloaded functions
#008 void func( int (*)(rai) ) { };    // int(*)(rai) 是函式指標型別，
#009                                   // 該函式的參數型別是 rai。
#010 void func( double (*)(rad) ) { }; // double(*)(rad) 是函式指標型別，
#011                                   // 該函式的參數型別是 rad。
#012
#013 void main()
#014 {
#015    func(static_cast<double(*)(rad)>(&min));  // (1) 此行無法編譯
#016    // BCB4 E2335: Overloaded 'min' ambiguous in this context
#017    // G++: undefined reference to `func(double (*)(double (&)[19]))'
#018 }

解決之道：繞個道，就可以。將上述 (1)：

func(static_cast<double(*)(rad)>(&min));

改為以下即可：

double(*fp)(rad) = &min; // instantiate 'min', using specified type.
func(fp);


■C++ Primer p503
主題：如果 template function 的函式參數型別是一個 class template，
      而實際引數是一個 class，此 class 有個 base class，係從「被指定
      做為函式參數」之 class template 身上具現出來，那麼 template 的
      引數推導可以順利進行。
測試結果：VC6[x]  BCB4[x]  G++[x]
實例：

#001 template <class T>
#002 class Array {  };
#003
#004 template <class T>
#005 class ArrayRC : public Array<T>  {  };
#006
#007 template <class T>
#008 T min4(Array<T>& array) { return T(0); }
#009
#010 void main()
#011 {
#012   ArrayRC<int> ia_rc();
#013
#014   // min4() 的函式引數型別是 ArraryRC<int>，其 base class 為 Array<int>，
#015   // 正是 function template min4() 的函式參數型別 Array<T> 的
#016   // 一個具現體（instantiation），所以 min4() 應該可以接受它（書上說可以）
#017   min4(ia_rc);   // error in VC6, BCB4, G++2.51.97
#018 }

註：2003/01/04 讀者來函，指出將 #012 改為 ArrayRC<int> ia_rc; 即可。
經測試，正確。感謝 royal。

■C++ Primer p507
主題：明白指定 function template 的部份引數的型別，另一部份由編譯器推導而得。
測試結果：VC6[x]  BCB4[x]  G++[o]
實例：

#001 template <class T1, class T2, class T3>
#002    T1 sum( T2 v2, T3 v3)
#003    { return T1(v2+v3); }
#004
#005 typedef unsigned int ui_type;
#006
#007 ui_type calc( char ch, ui_type ui )
#008 {
#009    // 以下明白指定 T1 為 ui_type，
#010    // T2 被編譯器推導為 char，T3 被推導為 ui_type。
#011    ui_type (*pf)( char, ui_type ) = &sum< ui_type >;
#012
#013    ui_type loc = (*pf)(ch, ui);
#014    return loc;
#015 }
#016
#017 void main()
#018 {
#019   calc('c', ui_type(1024));
#020 }


■C++ Primer p508
主題：明白指定 function template 引數型別
測試結果：VC6[x]  BCB4[x]  G++[o]
實例：

#001 template <class T1, class T2, class T3>
#002    T1 sum( T2 op1, T3 op2 ) { /* ... */ return T1(10); }
#003
#004 void manipulate( int (*pf)( int,char ) ) { };
#005 void manipulate( double (*pf)( float,float ) ) { };
#006
#007 void main( )
#008 {
#009    manipulate( &sum< double, float, float > );
#010 }


■C++ Primer p511
主題：separate compilation model for function template
測試結果：VC6[x]  BCB4[x]  G++[x]
          VC6  不支援 export template
          BCB4 支援關鍵字 export，但 linking 時找不到
                temlate instantiation 在哪裡（unresolved external...）
          G++  不支援 export template


■C++ Primer p514
主題：funtion template explicit specialization
注意：書中以 max 為自定之 function template 的名稱。然而有些編譯器已內附
      max 函式（有的是屬於 runtime function，有的是屬於 generic algorithms），
      切莫以為沒有含入相應的 header file，就不會喚起編譯器內附的東西，
      因為有的 header files 會再含入其他 header files，那是表面看不出來的。
      所以，自己的碼千萬不要命名為 max/min，才不會混淆自己。
測試結果：VC6, BCB4, G++ 都支援 funtion template explicit specialization。
      然而在 char*, const char*, const char[], text literal 之間，
      相當混淆而令人迷亂。


■C++ Primer p516
主題：funtion template explicit specialization + argument deduction
測試結果：VC6 表現太寬鬆，不嚴謹。
實例：

#001 #include <iostream>
#002 using namespace std;
#003
#004 template <class T1, class T2, class T3>
#005 T1 sum(T2 op1, T3 op2)
#006 {
#007   cout << "generic form" << endl;
#008   return static_cast<T1>(op1+op2);
#009 }
#010
#011 template<> double sum(float, float);
#012 //上一行在 VC6 竟然可以通過，差勁。
#013 //上一行在 bcb4 出現 e2423: explicit specialization or instantiation
#014 //                          of non-existing template 'sum'
#015 //上一行在 G++ 出現 : template-id `sum<>' for `sum<>(float, float)'
#016 //                    does not match any template decaration
#017
#018 // T1 明白指定為 double, T2 推導為 float, T3 推導為 float
#019 template<> double sum<double>(float op1, float op2)
#020 {
#021   cout << "specialization form1" << endl;
#022   return static_cast<double>(op1+op2);
#023 }
#024
#025 // T1, T2, T3 明白指定為 int, char, char
#026 template<> int sum<int, char, char>(char op1, char op2)
#027 {
#028   cout << "specialization form2" << endl;
#029   return static_cast<int>(op1+op2);
#030 }
#031
#032 void main()
#033 {
#034 int i=5;
#035 char c='a';
#036 float f=4.5;
#037 double d=6.5;
#038
#039   cout << sum<int>(i, i) << endl;       // generic form  10
#040   cout << sum<double>(f, f) << endl;    // specialization form1  9
#041   cout << sum<int>(c, c) << endl;       // specialization form2  194
#042 }


■C++ Primer p554
主題：function try block
測試結果：VC6[x]  BCB4[x]  G++[o]
實例：

#001 #include <iostream>
#002 using namespace std;
#003
#004 class popOnEmpty { /* ... */ };
#005 class pushOnFull { /* ... */ };
#006
#007 int main()
#008 try {
#009     throw popOnEmpty();
#010     throw pushOnFull();
#011     return 0;
#012 }
#013 catch ( pushOnFull ) {
#014     cout << "catch pushOnFull" << endl;
#015 }
#016 catch ( popOnEmpty ) {
#017     cout << "catch popOnEmpty" << endl;   // <-- 執行結果：此行。
#018 }


■C++ Primer  p564
主題：exception specification
測試結果：BCB4 表現佳，G++ 尚可，VC6 粗糙
實例：

#001 #include <iostream>
#002 using namespace std;
#003
#004 class popOnEmpty { /* ... */ };
#005 class pushOnFull { /* ... */ };
#006
#007 void func1() throw (pushOnFull);
#008
#009 void func1() throw (pushOnFull)
#010 {
#011   throw popOnEmpty();  // BCB4 warning: Throw expression violates
#012                        //  exception specification in function
#013                        //  func1() throw(pushOnFull)
#014                        // VC6 : no error, no warning
#015                        // G++ : no error, no warning
#016
#017   throw pushOnFull();  // BCB4 Warning : Unreachable code in function
#018                        // func1() throw(pushOnFull)
#019                        // VC6 : no error, no warning
#020                        // G++ : no error, no warning
#021 }
#022
#023 int main()
#024 {
#025   try {
#026       func1();
#027       return 0;
#028   }
#029   catch ( pushOnFull ) {
#030       cout << "catch pushOnFull" << endl;
#031   }
#032   catch ( popOnEmpty ) {
#033       cout << "catch popOnEmpty" << endl;
#034   }
#035 }
#036 // 執行結果：
#037 // BCB4: Abnormal program termination
#038 // G++ : none（我想是喚起了 C++ standard library function unexpected()，
#039 //       後者喚起 terminate()，其內喚起 abort()。
#040 // VC6 : catch popOnEmpty（我認為 VC6 對於 exception spec. 的處理太粗糙）


■C++ Primer  p643 中
主題：直接在 class 內針對 static const integral data member 給予初值
      （所謂 in-class initialization）
測試結果：VC6[x]  BCB4[o]  G++[o]
實例：

#001 #include <iostream.h>
#002
#003 class Account {
#004 public:
#005   static const int namesize = 16;   // <== in-class initialization
#006 };
#007
#008 const int Account::namesize;
#009
#010 void main()
#011 {
#012   cout << Account::namesize << endl;
#013 }


■C++ Primer p834
主題：class templates 內的 friend function
測試結果：VC6[x]  BCB4[x]  G++[o]
參考：請見稍後 ■C++ Primer p1090 對於 "VC6 的 friend functions" 的深入說明。
實例：

#001 #include <iostream>
#002 using namespace std;
#003
#004 // 以下的 forward declaration 非常重要，見 p834 L-8
#005 template <typename T> class A;
#006 template <typename T> ostream& operator<< (ostream& os, const A<T>& a);
#007
#008 template <typename T> class B;
#009 template <typename T> ostream& operator<< (ostream& os, const B<T>& b);
#010
#011 // 以下以 class A 和 class B 模擬 class Queue 和 class QueueItem 之間的關係
#012
#013 template <typename T>
#014 class A
#015 {
#016   // 以下的 <T> 非常重要，見 p834 L-6
#017   friend ostream& operator<< <T>(ostream& os, const A<T>& a);
#018 public:
#019   A (T i) : _i(i) {
#020             front = new B<T>(i);
#021             back  = new B<T>(i);
#022   }
#023   // 為求完整，應再設計 dtor 以避免 memory leak.
#024
#025 private:
#026   T _i;
#027   B<T>* front;
#028   B<T>* back;
#029 };
#030
#031 template <typename T>
#032 ostream& operator<< (ostream& os, const A<T>& a)
#033 {
#034   os << '<' ;
#035   os << *(a.front) << ' ';
#036   os << *(a.back) << ' ' ;
#037   os << '>' << endl;
#038   return os;
#039 }
#040
#041 template <typename T>
#042 class B
#043 {
#044   friend ostream& operator<< <T>(ostream& os, const B<T>& b);
#045 public:
#046   B (T i) : _item(i) { }
#047 private:
#048   T _item;
#049 };
#050
#051 template <typename T>
#052 ostream& operator<< (ostream& os, const B<T>& b)
#053 {
#054   os << b._item;  // BCB4 error: _item is not accessible. why?
#055   return os;
#056 }
#057
#058 void main()
#059 {
#060   A<int>   a1(5);
#061   A<float> a2(5.4);
#062   A<char>  a3('a');
#063
#064   cout << a1 << a2 << a3 << endl;
#065   /* output :
#066      <5 5 >
#067      <5.4 5.4 >
#068      <a a >
#069   */
#070 }


■C++ Primer p842
主題：class templates（內含 nest types）的 friend functions。
測試結果：VC6[x]  BCB4[x]  G++[o]
實例：

#001 #include <iostream>
#002 using namespace std;
#003
#004 // 以下的 forward declaration 非常重要，見 p834 L-8
#005 template <typename T> class A;
#006 template <typename T> ostream& operator<< (ostream& os, const A<T>& a);
#007
#008 // 以下以 class A 和 class B 模擬 class Queue 和 class QueueItem 之間的關係
#009
#010 template <typename T>
#011 class A
#012 {
#013   // 以下的 <T> 非常重要，見 p834 L-6
#014   friend ostream& operator<< <T>(ostream& os, const A<T>& a);
#015
#016 private:
#017   class B   // nested class
#018   {
#019   public:
#020     B (T i) : _item(i) { }
#021     T _item;
#022   };
#023
#024 public:
#025   A (T i) : _i(i) {
#026             front = new B<T>(i);
#027             back  = new B<T>(i);
#028   }
#029   // 為求完整，應再設計 dtor 以避免 memory leak.
#030
#031 private:
#032   T _i;
#033   B<T>* front;
#034   B<T>* back;
#035 };
#036
#037 template <typename T>
#038 ostream& operator<< (ostream& os, const A<T>& a)
#039 {
#040   os << '<' ;
#041   os << (a.front)->_item << ' ';
#042   os << (a.back)->_item  << ' ' ;
#043   os << '>' << endl;
#044
#045   return os;
#046 }
#047
#048 void main()
#049 {
#050   A<int>   a1(5);
#051   A<float> a2(5.4);
#052   A<char>  a3('a');
#053
#054   cout << a1 << a2 << a3 << endl;
#055   /* output :
#056      <5 5 >
#057      <5.4 5.4 >
#058      <a a >
#059   */
#060 }


■C++ Primer p844
主題：member templates
測試結果：VC6[o]  BCB4[o]  G++[o]
實例：

#001 #include <iostream>
#002 #include <string>
#003 #include <vector>
#004 using namespace std;
#005
#006 template <class T>
#007 class Queue {
#008 public:
#009         // class member template
#010         template <class Type>
#011         class CL
#012         {
#013            Type member;
#014            T mem;
#015         };
#016 public:
#017         // function member template
#018         template <class Iter>
#019         void assign( Iter first, Iter last )
#020         {
#021           cout << "Queue<T>::assign()" << endl;
#022         }
#023 };
#024
#025 void main()
#026 {
#027   // nested types
#028   Queue<int>::CL<char> c;
#029   Queue<int>::CL<string> s;
#030
#031   // instantiation of Queue<int>
#032   Queue<int> qi;
#033
#034   // instantiation of Queue<int>::assign( int *, int * )
#035   int ai[4] = { 0, 3, 6, 9 };
#036   qi.assign(ai, ai+4);         // output: Queue<T>::assign()
#037
#038   // instantiation of Queue<int>::assign( vector<int>::iterator,
#039   //                                      vector<int>::iterator)
#040   vector<int> vi(ai, ai+4);
#041   qi.assign(vi.begin(), vi.end());  // output: Queue<T>::assign()
#042 }


■C++ Primer p853
主題：separate compilation model for class template
推論：既然 BCB4 and G++ and VC6 都未能支援 separate compilation model for
      function templates，我想它們也一定都沒有支援 separate compilation model
      for class templates。但我未做測試（挺煩人 :)）


■C++ Primer p856
主題：class template specializations
測試結果：VC6[o]  BCB4[o]  G++[o]


■C++ Primer p861
主題：class template partial specializations
測試結果：VC6[x]  BCB4[o]  G++[o]
實例：

#001 #include <iostream>
#002 using namespace std;
#003
#004 // form 1
#005 template <class T, int hi, int wid>
#006 class Screen {
#007 public:
#008   void print() { cout << hi << ' ' << wid << " form1" << endl; }
#009 };
#010
#011 // form 2 (template partial specialization)
#012 template <class T, int hi>
#013 class Screen <T, hi, 80> {
#014 public:
#015   void print() { cout << hi << " form2" << endl; }
#016 };  // VC6 error C2989
#017
#018 // form 3
#019 template <class T, int hi>
#020 class Screen <T*, hi, 25> {
#021 public:
#022   void print() { cout << hi << ' ' << sizeof(T*) << ' '
#023                       << sizeof(T) << " form3" << endl; }
#024 };
#025
#026 int main()
#027 {
#028   Screen<int, 100, 40>  s1;
#029   Screen<int, 100, 80>  s2;
#030   Screen<int, 500, 25>  s3;
#031   Screen<char*, 300, 25> s4;
#032   Screen<double*, 400, 25> s5;
#033
#034   s1.print(); // output: 100 40 form1
#035   s2.print(); // output: 100 form2
#036   s3.print(); // output: 500 25 form1
#037   s4.print(); // output: 300 4 1 form3
#038   s5.print(); // output: 400 4 8 form3
#039   return 0;
#040 }


■C++ Primer p904
主題：using declaration 可將 base class 內任何一個具名的 member
      （條件是 accessible）放進 derived class scope 內。
測試結果：VC6[x]  BCB4[o]  G++[x]
          但如果將下例的 using declaration 移到 Shy::mumble() 之前，則 VC6[o]
實例：

#001 #include <iostream>
#002 #include <string>
#003 using namespace std;
#004
#005 class Diffident {
#006 public:
#007     void mumble (int softnes)
#008     { cout << "Diffident::mumble" << endl; };
#009 };
#010
#011 class Shy : public Diffident {
#012 public:
#013     void mumble(string whatYaSay)
#014     { cout << "Shy::mumble" << endl; };
#015     using Diffident::mumble;
#016 };
#017
#018 void main()
#019 {
#020 Diffident d;
#021 Shy s;
#022 string str("jjhou");
#023
#024   d.mumble(5);     // Diffident::mumble
#025   s.mumble(5);     // should be "Diffident::mumble"
#026   s.mumble(str);   // Shy::mumble
#027 }


■C++ Primer p940
主題：設計 "virtual" new operator（亦即 clone）時所需
      的一個技術：如果虛擬函式的 base instance 傳回
      'A' class type（或為指標，或為 reference），那麼
      虛擬函式的 base instance 可以傳回 'A' type 或 'A'
      的 publicly derived class（或為指標，或為 reference）
測試結果：VC6[x]  BCB4[o]  G++[o]
實例：

#001 class Query {
#002 public:
#003   virtual Query* clone() = 0;
#004 };
#005
#006 class NameQuery : public Query {
#007 public:
#008   virtual NameQuery* clone() { return new NameQuery(*this); }
#009   // VC6 error C2555: 'NameQuery::clone' : overriding virtual function
#010   //   differs from 'Query::clone' only by return type or calling convention
#011   //   see declaration of 'Query'
#012 };
#013
#014 void main()
#015 {
#016   Query* pq  = new NameQuery();
#017   Query* pq2 = pq->clone();
#018
#019   NameQuery* pnq  = new NameQuery();
#020   NameQuery* pnq2 = pnq->clone();
#021 }



■C++ Primer p998
註：2001.08.22 新增
主題：虛擬繼承中的 base class ctor invocation 問題。
測試結果：
實例：gcc291[o], vc6[x], cb4[x], cb5[x]

#0001 // gcc[o], vc6[x], cb4[x], cb5[x]
#0002
#0003 #include <iostream>
#0004 #include <string>
#0005 using namespace std;
#0006
#0007 class ZooAnimal {
#0008 public:
#0009     ZooAnimal( string name, bool onExhibit, string fam_name )
#0010                : _name( name ),
#0011                  _onExhibit( onExhibit),
#0012                  _fam_name( fam_name )
#0013     {}
#0014
#0015     virtual ~ZooAnimal() { };
#0016     string name() const { return _name; };
#0017     string family_name() const { return _fam_name; }
#0018     // ...
#0019
#0020 protected:
#0021     bool   _onExhibit;
#0022     string _name;
#0023     string _fam_name;
#0024     // ...
#0025 };
#0026
#0027 class Bear : public virtual ZooAnimal {
#0028 public:
#0029     enum DanceType {
#0030          two_left_feet, macarena, fandango, waltz };
#0031
#0032     Bear( string name, bool onExhibit=true )
#0033         : ZooAnimal( name, onExhibit, "Bear" ),
#0034           _dance( two_left_feet )
#0035     {}
#0036
#0037     void dance( DanceType );
#0038     // ...
#0039
#0040 protected:
#0041     DanceType _dance;
#0042     // ...
#0043 };
#0044
#0045
#0046 class Raccoon : public virtual ZooAnimal {
#0047 public:
#0048     Raccoon( string name, bool onExhibit=true )
#0049            : ZooAnimal( name, onExhibit, "Raccoon" ),
#0050              _pettable( false )
#0051     {}
#0052
#0053     bool pettable() const { return _pettable;   }
#0054     void pettable( bool petval ) { _pettable = petval; }
#0055     // ...
#0056
#0057 protected:
#0058     bool _pettable;
#0059     // ...
#0060 };
#0061
#0062
#0063 class Panda : public Bear,
#0064               public Raccoon {
#0065 public:
#0066     Panda( string name, bool onExhibit=true );
#0067     bool sleeping() const { return _sleeping; }
#0068     void sleeping( bool newval ) { _sleeping = newval; }
#0069     // ...
#0070
#0071 protected:
#0072     bool _sleeping;
#0073     // ...
#0074 };
#0075
#0076 Panda::Panda( string name, bool onExhibit=true )
#0077       : ZooAnimal( name, onExhibit, "Panda" ),    // <<-- note
#0078         Bear( name, onExhibit ),
#0079         Raccoon( name, onExhibit ),
#0080         _sleeping( false )
#0081 {}
#0082
#0083
#0084 int main()
#0085 {
#0086   Bear winnie("Pooh");
#0087   Raccoon meeko("meeko");
#0088   Panda yolo("yolo");
#0089 }

注意：如果將 #0076 的 =true 去除，則 gcc291[o], vc6[o], cb4[o], cb5[o]




■C++ Primer p1090
主題：friend operator<<
測試結果：VC6[x]  BCB4[o]  G++[o]
注意：如果使用 <iostream.h> 而不是 <iostream>，在 VC6 中
      運用 friend 就比較沒有問題。但如果這麼做的話，由於下例
      用到 <string>，一定得 using namespace std; 而這在 VC6 中似乎
      導至暗中含入 <iostream>，於是與 <iostream.h> 起衝突。總之，
      挖東補西，很煩。VC6 在這主題上表現不佳。
實例：

#001 #include <iostream>
#002 #include <string>
#003 using namespace std;
#004
#005 class WordCount {
#006     friend ostream& operator<<(ostream&, const WordCount&);
#007 public:
#008     WordCount( string& word, int cnt=1 )
#009     : _word(word), _occurs(cnt)
#010     { };
#011 private:
#012     string _word;
#013     int _occurs;
#014 };
#015
#016 ostream& operator <<( ostream& os, const WordCount& wd )
#017 {    // format: <occurs> word
#018      os << "< " << wd._occurs << " > " << wd._word;  // VC error!
#019      return os;
#020 }
#021
#022 void main()
#023 {
#024   string s1("Hello");
#025   string s2("jjhou");
#026   WordCount w1(s1, 5);
#027   WordCount w2(s2, 7);
#028   cout << w1 << endl;   // < 5 > Hello
#029   cout << w2 << endl;   // < 7 > jjhou
#030 }


■C++ Primer p1126 下
主題：list<T> 的 object initialization
測試結果：VC6[o]  BCB4[x](有瑕疵) G++[o]
實例：
    以下這行可通過 VC6 和 G++
    list<int> ilist_result(ilist.size());

    為了在 BCB4 中通過，需改為：
    int i = ilist.size();
    list<int> ilist_result(i, -1);


■C++ Primer p1156~p1157
主題：generic algorithms max() 和 min()
測試結果：VC6 所附的 STL 竟未支援 max 和 min 這兩個 generic algorithms。
聯想：試看這個程式：

(01) #include <iostream>
(02) #include <string>
(03) using namespace std;
(04)
(05) template <typename T>
(06) T min( T v1, T v2)       // <-- note
(07) {
(08)    return (v1 < v2 ? v1 : v2);
(09) }
(10)
(11) class Rect {
(12)   friend ostream& operator<<(ostream& os, Rect& r);
(13) public:
(14)   Rect(int i) : _i(i) {  }
(15)   bool operator<(Rect& rhs)
(16)     { return (this->_i < rhs._i ? true : false); }
(17) private:
(18)   int _i;
(19) };
(20)
(21) ostream& operator<<(ostream& os, Rect& r)
(22) {
(23)    os << r._i;
(24)    return os;
(25) }
(26)
(27) void main()
(28) {
(29)    cout << min( 17, 15) << endl;           // 15
(30)    cout << min(13.5, 13.57) << endl;       // 13.5
(31)    cout << min('a', 'e') << endl;          // a
(32)    cout << min("jjhou", "allan") << endl;  // allan
(33)
(34)    Rect r1(6), r2(3), r3(9);
(35)    cout << r1 << r2 << r3 << endl;         // 639
(36)    cout << min(r1, r2) << endl;            // 3
(37) }

檢討：
一 此程式在 VC6 中失敗，但如果改為 #include<iostream.h>
並移除 using namespace std; 則成功，這是 VC6 的 bug！
（見先前對 friend 的討論，C++ Primer p1090）

二 此程式在 BCB4 中失敗，錯誤訊息如下：
Error E2094 T1.CPP 36: 'operator<<' not implemented in type
'ostream' for arguments of type 'Rect' in function main()

這是因為我們的 template function min() 和 BCB4 提供之 STL 中
的 gemeric algorithm min() 名稱一樣。程式中喚起的其實是 STL 的
gemeric algorithm min()，而其 parameter list 內對於 parameters
的 constness 的要求，導至編譯器在進行 template argument deduction 時，
不接受我所提供的 Rect。只要將程式中的 min() 改為 mymin()，並將
(12) 和 (21) 的最後一個參數型別改為 const Rect&，即可。

注意：有時候雖然你並未明白含入某些 header files，或是你並未明白
使用 using namespace std; 編譯器卻會暗自加上。前者是由於 header files
一個含入一個…導至，後者請看 BCB4 的每一個 header files 的最後面，
幾乎都有這一行：

#ifndef __USING_STD_NAMES__
  using namespace std;
#endif

三 此程式在 G++ 中獲得警告訊息如下：
t1.cpp:36: warning: initialization of non-const reference
'class Rect &' from rvalue 'Rect'
t1.cpp:22: warning: in passing argument 2 of
'operator <<(ostream &, Rect &)'

其道理與修改方法，和上述二相同：將 min() 改名為 mymin() 即可。

心得：程式中不要出現任何命名與 C++ standard library 內的 components 同名。


■C++ Primer p1169
主題：generic algorithms random_shuffle()
測試結果：G++ 所附的 STL 對 random_shuffle() 的支援有問題


■Effective C++ 2/e  p70
主題：如果 base class 的 operator= 係由編譯器產生，亦即所謂
      default operator=，某些編譯器會拒絕讓你明白喚起 base class operator=，
      這不是好現象。
測試結果：VC6[o]  BCB4[x]  G++[o] （BCB4 表現不佳，拒絕我們喚起上述 operator=）
實例：

#001 class Base {
#002 ...
#003   // no defined operator=
#004 };
#005
#006 class Derived : public Base {
#007 ...
#008   Derived& operator=(const Derived& rhs);
#009 };
#010
#011 Derived& Derived::operator=(const Derived& rhs)
#012 {
#013   if (this == &rhs) return *this;
#014
#015   // explicitly invoke Base operator=。VC6[o]  BCB4[x]  G++[o]
#016   Base::operator=(rhs);
#017   ...
#018 }



以下是 2001/03/03 新增：

■C++ Primer p688
主題：local class
測試結果：VC6 不符 C++ Standard

(01) // VC6[x]  CB4[x]  G++[x]
(02)
(03) int a, val;
(04)
(05) void foo( int val )
(06) {
(07)     static int si;
(08)     enum Loc { a = 1024, b };
(09)     class Bar {
(10)     public:
(11)         Loc locVal; // ok;
(12)         int barVal;
(13)         void fooBar( Loc l = a ) { // ok: Loc::a
(14)             barVal = val;    // error: local object
(15)             barVal = ::val;  // ok: global object
(16)             barVal = si;     // ok: static local object
(17)             locVal = b;      // ok: enumerator
(18)         }
(19)     };
(20)     // ...
(21) }
(22)
(23) int main()
(24) {
(25)   foo(5);
(26) }

編譯結果

[VC6]:
../688.cpp(16) : error C2065: 'si' : undeclared identifier
../688.cpp(17) : error C2065: 'b' : undeclared identifier
../688.cpp(17) : error C2440: '=' : cannot convert from 'int' to
                                    'enum foo::Loc'
  Conversion to enumeration type requires an explicit cast (static_cast,
C-style cast or function-style cast)
結論：VC6 不符合 C++ standard.

[BCB4]:
Error E2451 ../688.CPP 14: Undefined symbol 'val' in function Bar::fooBar(Loc)
結論：BCB4 符合 C++ standard.

[GCC]:
..//688.cpp: In method `void foo(int)::Bar::fooBar(enum foo(int)::Loc = a)':
..//688.cpp:14: use of parameter from containing function
..//688.cpp:6:   `int val' declared here
結論：GCC 符合 C++ standard.


--- the end