※ 引述《iamstudent.bbs@wretch.twbbs.org (有空來下棋喔！됩》之銘言：
> ※ 引述《Wiseman.bbs@bbs.cs.nthu.edu.tw (benqer)》之銘言：
> > c/c++ 並沒有 int[] x; 的語法
> > 喔, 就因為java有多種宣告陣列的語法嗎?
> > 你真是太小看c++了 , 以語言描述多樣性來說,
> > c++有運算子多載,泛型編程, 多重繼承, java一個都沒有.
> > 平心而論, c++比起java來說是複雜了點,
> > 但c++有豐富的語言設施, 可以直接以程式表達設計理念,
> > 比起java過於簡化的編程模型, 可以說"進步"太多了
> 這樣講可能會引起筆戰喔
> 這些功能被移除其實是有原因的
不管移除的原因是什麼,
這移除顯示了java並非一個如上面網友所說的,具有語言描述的豐富性
> 運算子多載
> 多重繼承
> 我覺得其實用處不大
java因為沒有運算子多載, 簡單的 a + b*c都得寫成 a.add(b.multiply(c))
你覺得用處不大, 那麼做數值運算的人呢?
沒有泛型編程 , 所以java的容器在取出元素時得動用轉型, 遇到得以型別
訂製class時, 只能對每個型別製作一個語法幾乎一樣的class.
沒有多重繼承(c#也一樣), 所以如果你的class要繼承兩個class的"介面與實作"
就得用interface來代替另一個class, composite此class之物件, 再動用delegate
實作出此interface的所有methods, 跟vb沒有繼承時候的情形一模一樣
也許以上所說, 很多人都還是覺得用處不大, 所以移除無傷大雅.
但是別忘了sun發展java的目標除了簡單,productive之外, 更重要的是
cross platform, 統一運算平台. 結果java為了簡化的理由把以上功能全都拿掉
嗯 真不知道這樣的做法要如何說服"所有人"採用java.
而java自身的缺點也讓其他競爭對手見縫插針.
.NET platform已經針對java的缺點做出改進, .NET把operator overloading納入
但不強迫所有語言都使用, for example, c#支援operator overloading, 但VB並不支援
.NET framework 2.0也將加入template機制, 當然同樣的, 以簡單做號召的VB不
一定會支援.
多重繼承雖然.NET不直接支援, 但語言仍可自行實作出多重繼承, 例如
managed c++依然可以使用多重繼承.
so , 結論就是.net平台依然享有java的簡單編程模型(use vb),同時也有結合
java+vb的簡單與c++的語言設施之c#, 如果programmer還是不滿意, 他們還可以
退回到最powerful的c++, 同時依然享有.net的優勢
而java呢, programer得到的只有一個簡化過的編程模型.
--
※ Origin: 楓橋驛站<bbs.cs.nthu.edu.tw> ◆ From: NK219-91-117-21.adsl.dynamic.apol.com.tw
> -------------------------------------------------------------------------- <
發信人: Corroson@kkcity.com.tw (藍月楓鈴), 看板: java
標 題: Re: 請問陣列的宣告…
發信站: KKCITY (Sun Jun 20 05:38:00 2004)
轉信站: ptt!ctu-reader!ctu-peer!Spring!news.nctu!news.ntu!bbs.ee.ntu!news.kkci
※ 引述《Wiseman.bbs@bbs.cs.nthu.edu.tw (benqer)》之銘言：
> script 是著重在runtime的動態, 彈性很大, 但相對來說型別的使用一有錯誤,
> 會在runtime出現無法預期的錯誤, 這種錯誤很難debug. 這就是為何type-safety重要
> 的原因.
> 泛型則是著重在compile-time的動態, 型別在compiler-time具現時一旦有錯,
> 也只是compile-time error, 夠格的compiler都能夠直接指出錯在哪裡. 不需要
> 等到runtime再來debug.
很贊同 Wiseman 所言。
但我現在想說的，是一個發展方向，而不是現狀。
嚴格的型別定義，與編程彈性，一直使編譯器有很大的困擾，但並非不可解決。
我舉兩個簡單的例子，第一個例子是導引，第二個例子是深入。
導引範例：
int fa(int x)
{
if (x % 1)
{
cout << "Yes!";
return 1;
} else {
cout << "No!";
return 0;
}
}
我一直希望 C/C++ 能夠把他化簡成
function fa (x)
{
if (x % 1)
{
cout << "Yes!";
return 1;
} else {
cout << "No!";
return 0;
}
}
提問一：
或許有人說，那怎麼知道要 return 什麼呢？
這就是編譯器的工作了，編譯器負責檢查「回傳型態的一致性」。
如果回傳型態具有一致性，那就應該要知道回傳什麼了吧。
提問二：
那怎麼給定 x 的型態？
這也是編譯器的工作。目前不是發展了 template 技術嗎？
把他想成隱式 template 不就達成了。
不過編譯器會很累，必須要檢查該型別是否滿足所有算子(甚至成員)。
不過要滿足上述兩項功能，自動型別轉換有必要作檢討。
深入範例：(很重要的編程風格範例)
嘗試思考下面這個例子：
function dynamic (x)
{
if (x % 1)
return Bicycle(x);
else
return Car(x);
}
這可好了，編譯器該如何做？我嘗試著將上面的函式翻譯成 C++
解法一：使用基礎類別再加以繼承之。
class CC { …略… } ;
class Bicycle : CC { …略… };
class Car : CC { …略… };
template<class T>
CC * dynamic(T x)
{
if (x%1)
return new Bicycle(x);
else
return new Car(x);
}
解法二：利用 union
此法建議在兩者所使用的空間差異不大時使用，
此解法還必須使這三個先備類別支援 (type &) 建構子才行
struct UBC
{
char * style_name;
union cont { Bicycle b; Car c; };
}
template<class T>
UBC dynamic(T x)
{
if (x % 1)
return (UBC) {"bicycle", Bicycle(x)}; // C99 新增語法
else
return (UBC) {"car", Car(x)};
}
天啊！一個簡潔的編程樣式，翻譯成 C++ 居然要如此的麻煩！
用了 script 之後的小小感想。這並不是理論上的困難，而是技術量太大。
--
┌─────◆程式設計樂園◆─────┐ ╱ ╱ ￣ ▌￣ ￣ ╲╱ ＢＢＳ 城邦
│ CSZone.kkcity.com.tw │ ╲ ╲ ╴ ▌ ▌ ▏ ＫＫ免費撥接
└──《From:61.231.190.51 》──┘ 電話:449-1999 帳號:kkcity 密碼:kkcity
> -------------------------------------------------------------------------- <
發信人: mark00lui.bbs@whshs.cs.nccu.edu.tw (RE->NFA->DFA), 看板: java
標 題: Re: 請問陣列的宣告…
發信站: 政大狂狷年少 (Sun Jun 20 12:03:32 2004)
轉信站: ptt!ctu-reader!ctu-peer!news.nctu!news.csie.ncyu!news.cs.nthu!WHSHS
1.這個討論串似乎偏離原題
2.在討論C++跟java的比較似乎意義有所偏離
2.1
把C++的多重繼承變成java來寫並不是單純的extends + interface
java之所以這樣做是想解決一般C++programmer為了方便而亂用繼承的問題
一般來說, 你想會用繼承的時候, 其實80~90%是包含關係, 並不是繼承
因此java強迫只能使用單一繼承, 希望programmer想出比較合邏輯的程式
2.2
operator其實在java中一直存在(如字串可以作加法), 只是被拿掉而矣
又是同一個理由, 解決C++programmer亂用的情況
2.3
template在VM中實行需要code sharing的機制, 在VM語言中有dynamic code loading,
在code的記憶體管理上確實java, C# 會比 C++來得好一點 (請參考OS課本)
總結:C++由於功能太過強大, 真正會寫得好的實在是太難太少了,
這方面只能祈求programmer具有高度編程素養
java正是想解決這方面的問題希望限制設計的思路, 至少把往地獄方向的路關了
,但並不代表程式會寫得好和寫得出來
(p.s. 1.5出來以後suger語法又再增加了)
--
郎勒呷咪 哩勒話休
╔═══╮╭═══╮╔═══╮╔═╗╔╗
║ ║║ ║║ ║║ ║║║
║ ║║ ═ ║║ ═ ║║ ╚╯╝
║ ║║║║ ╔╗║║ ╔╮╯║ ╔╮╗
╚═╝╝╝╚═╝╚╝╚═╝╚╝╚═╝╚╝
--
╔═══╗ ┼────────────────────────╮
║狂狷 ║ │＊ Origin：[ 狂 狷 年 少 ] whshs.cs.nccu.edu.tw ╰─╮
║ 年少║ ┼╮ < IP：140.119.164.16 > ╰─╮
╚╦═╦╝ ╰ ＊ From：mulan.cs.nccu.edu.tw
─╨─╨─ ＫＧＢＢＳ ─ ◎ 遨翔"BBS"的狂狷不馴；屬於年少的輕狂色彩 ◎
> -------------------------------------------------------------------------- <
發信人: Wiseman.bbs@bbs.cs.nthu.edu.tw (benqer), 看板: java
標 題: Re: 請問陣列的宣告…
發信站: 清華資訊(楓橋驛站) (Mon Jun 21 03:40:39 2004)
轉信站: ptt!ctu-reader!ctu-peer!news.nctu!news.csie.ncyu!news.cs.nthu!maple
> 我一直希望 C/C++ 能夠把他化簡成
> function fa (x)
> {
> if (x % 1)
> {
> cout << "Yes!";
> return 1;
> } else {
> cout << "No!";
> return 0;
> }
> }
用template+轉型設施已經可以達成你要的效果, 而且還有type-safe的優
點
如下:
template<typename P>
int fa(P& x)
{
if (x % 1) {...return 1;} else{return 0;}
}
int i= fa(1);
class1 c1= fa(1); //class1中必須定義建構式 class1(int i),
// operator=(int i);
class2 c2= fa(class3()); //class2 中必須定義建構式 class2(int i) ,
// operator=(int i);
// class3必須定義 operator %
這樣的作法跟script的差別就在於script用一個共通的type來函括所有type
(如vb的variant, js的var) 所以當函式回一個共通的type時,他可能是
int, 可能是char, 可能是一個object, 這時程式要怎麼處理就完全依靠
程式"內隱"的規則. 例如,
function func(x)
{ if (x==1) return CreateObject("xxx.xxx");
else return 1;}
請問, 呼叫func的客戶端要怎麼能知道他拿到的是int還是 object?
答案是客戶端得去了解func的實作內容. 這樣的情形嚴重的傷害到程式
的封裝與抽像特性. 所以script並不適合開發大型程式.
而使用c++, 你可以使用template讓function享有類似script的彈性
又不損及type-safety及runtime performace. 댊 high-level, type-safety, efficiency是c++的特性, 要讓c++改用
script的方式就好像叫c++自廢武功一樣
至於你下面所提的例子, 事實上script的變數並非沒有型別,
而是他們都是繼承至同一個共通的型別,好比是java跟.net的共同基底類別
vb的variant也是類似的觀念. 而script把這類別的宣告藏了起來,好讓程式
簡化. 所以以下面的c++程式來看, c++也只是把這之間的關係描述出來.
你可說c++很繁瑣, 但是至少, 在程式中描述出來的繼承關係, 可以讓
compiler提早揪出錯誤的型別使用. 減少在runtime出錯的可能. 更可加強
程式的可讀性,結構性,邏輯性. 你可以想像一下, 如果dynamic傳回
的一定是bicycle or car之類的交通工具, 為何不在程式明確的指出
dynamic只會回傳交通工具這件事 ,卻要讓使用者冒著可能不小心把回傳
的交通工具當成建築物來使用的風險, 其道理何在?
另外, union的作法絕對是最差的,完全不用考慮.
> 深入範例：(很重要的編程風格範例)
> 嘗試思考下面這個例子：
> function dynamic (x)
> {
> if (x % 1)
> return Bicycle(x);
> else
> return Car(x);
> }
> 這可好了，編譯器該如何做？我嘗試著將上面的函式翻譯成 C++
> 解法一：使用基礎類別再加以繼承之。
> class CC { …略… } ;
> class Bicycle : CC { …略… };
> class Car : CC { …略… };
> template<class T>
> CC * dynamic(T x)
> {
> if (x%1)
> return new Bicycle(x);
> else
> return new Car(x);
> }
--
※ Origin: 楓橋驛站<bbs.cs.nthu.edu.tw> ◆ From: NK219-91-119-85.adsl.dynamic.apol.com.tw
> -------------------------------------------------------------------------- <
發信人: Corroson@kkcity.com.tw (藍月楓鈴), 看板: java
標 題: Re: 請問陣列的宣告…
發信站: KKCITY (Mon Jun 21 12:41:30 2004)
轉信站: ptt!ctu-reader!ctu-peer!news.csie.ncyu!news.ncyu!news.ccu!Yuntech-News
※ 引述《Wiseman.bbs@bbs.cs.nthu.edu.tw (benqer)》之銘言：
> > 我一直希望 C/C++ 能夠把他化簡成
> > function fa (x)
> > {
> > if (x % 1)
> > {
> > cout << "Yes!";
> > return 1;
> > } else {
> > cout << "No!";
> > return 0;
> > }
> > }
> 用template+轉型設施已經可以達成你要的效果, 而且還有type-safe的優
> 點
> 如下:
> template<typename P>
> int fa(P& x)
> {
> if (x % 1) {...return 1;} else{return 0;}
> }
> int i= fa(1);
> class1 c1= fa(1); //class1中必須定義建構式 class1(int i),
> // operator=(int i);
> class2 c2= fa(class3()); //class2 中必須定義建構式 class2(int i) ,
> // operator=(int i);
> // class3必須定義 operator %
fa 只是一個函數。
> 這樣的作法跟script的差別就在於script用一個共通的type來函括所有type
NO, function(x) 並不是用一個共通的 type ，而是使用「隱式 template」！
我的 script 是可以編譯為執行檔的。
> (如vb的variant, js的var) 所以當函式回一個共通的type時,他可能是
> int, 可能是char, 可能是一個object, 這時程式要怎麼處理就完全依靠
> 程式"內隱"的規則. 例如,
> function func(x)
> { if (x==1) return CreateObject("xxx.xxx");
> else return 1;}
> 請問, 呼叫func的客戶端要怎麼能知道他拿到的是int還是 object?
> 答案是客戶端得去了解func的實作內容. 這樣的情形嚴重的傷害到程式
NO, 編譯時期無法確定其型別，但是執行時期可確定。
因為我們不必在編譯時期就確定他的型別！例如 cout << fb(x);
！！！！！！！！！！！！！！！！
> 的封裝與抽像特性. 所以script並不適合開發大型程式.
> 而使用c++, 你可以使用template讓function享有類似script的彈性
> 又不損及type-safety及runtime performace. 댊
script 可以不損及型別安全和效能。這就是我對 C++ 不甚滿意的地方。
> high-level, type-safety, efficiency是c++的特性, 要讓c++改用
> script的方式就好像叫c++自廢武功一樣
> 至於你下面所提的例子, 事實上script的變數並非沒有型別,
> 而是他們都是繼承至同一個共通的型別,好比是java跟.net的共同基底類別
如上所述，並非使用共通型別，而是使用「隱式 template」，
再由編譯器檢查是否符合所有算子以及成員。 時下的 template 不也如此？
> vb的variant也是類似的觀念. 而script把這類別的宣告藏了起來,好讓程式
> 簡化. 所以以下面的c++程式來看, c++也只是把這之間的關係描述出來.
> 你可說c++很繁瑣, 但是至少, 在程式中描述出來的繼承關係, 可以讓
> compiler提早揪出錯誤的型別使用. 減少在runtime出錯的可能. 更可加強
> 程式的可讀性,結構性,邏輯性. 你可以想像一下, 如果dynamic傳回
> 的一定是bicycle or car之類的交通工具, 為何不在程式明確的指出
> dynamic只會回傳交通工具這件事 ,卻要讓使用者冒著可能不小心把回傳
> 的交通工具當成建築物來使用的風險, 其道理何在?
已經說過原因了，我們並不需要在編譯時期就確定他的型別！
時下 C++ 的 virtual 不也如此？我只能說 C++ 太嫩。
> 另外, union的作法絕對是最差的,完全不用考慮.
> > 深入範例：(很重要的編程風格範例)
> > 嘗試思考下面這個例子：
> > function dynamic (x)
> > {
> > if (x % 1)
> > return Bicycle(x);
> > else
> > return Car(x);
> > }
> > 這可好了，編譯器該如何做？我嘗試著將上面的函式翻譯成 C++
> > 解法一：使用基礎類別再加以繼承之。
> > class CC { …略… } ;
> > class Bicycle : CC { …略… };
> > class Car : CC { …略… };
> > template<class T>
> > CC * dynamic(T x)
> > {
> > if (x%1)
> > return new Bicycle(x);
> > else
> > return new Car(x);
> > }
--
┌─────◆程式設計樂園◆─────┐ ╱ ╱ ￣ ▌￣ ￣ ╲╱ ＢＢＳ 城邦
│ CSZone.kkcity.com.tw │ ╲ ╲ ╴ ▌ ▌ ▏ ＫＫ免費撥接
└──《From:61.231.188.131 》──┘ 電話:449-1999 帳號:kkcity 密碼:kkcity
> -------------------------------------------------------------------------- <
發信人: Wiseman.bbs@bbs.cs.nthu.edu.tw (benqer), 看板: java
標 題: Re: 請問陣列的宣告…
發信站: 清華資訊(楓橋驛站) (Tue Jun 22 12:52:51 2004)
轉信站: ptt!ctu-reader!ctu-peer!news.nctu!news.csie.ncyu!news.cs.nthu!maple
※ 引述《Corroson@kkcity.com.tw (藍月楓鈴)》之銘言：
> > // class3必須定義 operator %
> fa 只是一個函數。
> > 這樣的作法跟script的差別就在於script用一個共通的type來函括所有type
> NO, function(x) 並不是用一個共通的 type ，而是使用「隱式 template」！
> 我的 script 是可以編譯為執行檔的。
隱式template? 沒聽過這種東西, 也不知道用處在哪
> > (如vb的variant, js的var) 所以當函式回一個共通的type時,他可能是
> > int, 可能是char, 可能是一個object, 這時程式要怎麼處理就完全依靠
> > 程式"內隱"的規則. 例如,
> > function func(x)
> > { if (x==1) return CreateObject("xxx.xxx");
> > else return 1;}
> > 請問, 呼叫func的客戶端要怎麼能知道他拿到的是int還是 object?
> > 答案是客戶端得去了解func的實作內容. 這樣的情形嚴重的傷害到程式
> NO, 編譯時期無法確定其型別，但是執行時期可確定。
> 因為我們不必在編譯時期就確定他的型別！例如 cout << fb(x);
使用template就意謂者型別必須於編譯期決定, (多型型別除外), ex
cout 是ostream type的物件, 但他的實作並不是去處理執行期才確定的物件
而是針對每種物件定義出不同版本的function, 再由compiler辨析該採用的版本
> script 可以不損及型別安全和效能。這就是我對 C++ 不甚滿意的地方。
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
你真是說了天大的笑話了, 型別安全和效能恰巧就是scrip的缺點,
你如果要說服大家的話,就拿出理由來證明吧
> > high-level, type-safety, efficiency是c++的特性, 要讓c++改用
> > script的方式就好像叫c++自廢武功一樣
> > 至於你下面所提的例子, 事實上script的變數並非沒有型別,
> > 而是他們都是繼承至同一個共通的型別,好比是java跟.net的共同基底類別
> 如上所述，並非使用共通型別，而是使用「隱式 template」，
> 再由編譯器檢查是否符合所有算子以及成員。 時下的 template 不也如此？
既然說是template, 又說是由compiler檢查type-safety,
那又何來以上所說runtime才確定型別的說法?
你的觀念很矛盾
> > dynamic只會回傳交通工具這件事 ,卻要讓使用者冒著可能不小心把回傳
> > 的交通工具當成建築物來使用的風險, 其道理何在?
> 已經說過原因了，我們並不需要在編譯時期就確定他的型別！
> 時下 C++ 的 virtual 不也如此？我只能說 C++ 太嫩。
c++太嫩? 我看是你太嫩, 你根本不了解c++的多型跟泛型的意義 就在此妄下斷言
virtual/多型 允許物件的確切型別可以在runtime決定, 但是在compile-time,
多型物件仍會遵循其base class的規則,由compiler進行檢查, 正因為多型物件
在runtime是以base class物件的方式來使用, 所以即使compiler不知道多型物件
的確切型別,也沒有違反type-safety的危險.
(多型物件以concret type object來使用時當然也就遵循各別多型物件的規則)
> > 另外, union的作法絕對是最差的,完全不用考慮.
--
※ Origin: 楓橋驛站<bbs.cs.nthu.edu.tw> ◆ From: NK219-91-104-168.adsl.dynamic.apol.com.tw
> -------------------------------------------------------------------------- <
發信人: Corroson@kkcity.com.tw (藍月楓鈴), 看板: java
標 題: Re: 請問陣列的宣告…
發信站: KKCITY (Wed Jun 23 14:39:50 2004)
轉信站: ptt!ctu-reader!ctu-peer!news.nctu!netnews.csie.nctu!news.ee.ttu!news.n
※ 引述《Wiseman.bbs@bbs.cs.nthu.edu.tw (benqer)》之銘言：
> ※ 引述《Corroson@kkcity.com.tw (藍月楓鈴)》之銘言：
> > fa 只是一個函數。
> > NO, function(x) 並不是用一個共通的 type ，而是使用「隱式 template」！
> > 我的 script 是可以編譯為執行檔的。
> 隱式template? 沒聽過這種東西, 也不知道用處在哪
就是把本來該寫出 template 的地方省略不寫。
> > NO, 編譯時期無法確定其型別，但是執行時期可確定。
> > 因為我們不必在編譯時期就確定他的型別！例如 cout << fb(x);
> 使用template就意謂者型別必須於編譯期決定, (多型型別除外), ex
> cout 是ostream type的物件, 但他的實作並不是去處理執行期才確定的物件
> 而是針對每種物件定義出不同版本的function, 再由compiler辨析該採用的版本
正是如此。 fb(x) 不必在編譯時期確定其型別！
> > script 可以不損及型別安全和效能。這就是我對 C++ 不甚滿意的地方。
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> 你真是說了天大的笑話了, 型別安全和效能恰巧就是scrip的缺點,
> 你如果要說服大家的話,就拿出理由來證明吧
在本文之初，就已經說明，並非指現狀，而是指出一個發展方向。
它可以是同時滿足型別安全與執行效能的。
> > 如上所述，並非使用共通型別，而是使用「隱式 template」，
> > 再由編譯器檢查是否符合所有算子以及成員。 時下的 template 不也如此？
> 既然說是template, 又說是由compiler檢查type-safety,
> 那又何來以上所說runtime才確定型別的說法?
> 你的觀念很矛盾
就如同 C++ 的指標可以 new 初衍生類別一樣。只不過這樣還不夠彈性。
understand?
> > 已經說過原因了，我們並不需要在編譯時期就確定他的型別！
> > 時下 C++ 的 virtual 不也如此？我只能說 C++ 太嫩。
> c++太嫩? 我看是你太嫩, 你根本不了解c++的多型跟泛型的意義 就在此妄下斷言
> virtual/多型 允許物件的確切型別可以在runtime決定, 但是在compile-time,
> 多型物件仍會遵循其base class的規則,由compiler進行檢查, 正因為多型物件
> 在runtime是以base class物件的方式來使用, 所以即使compiler不知道多型物件
> 的確切型別,也沒有違反type-safety的危險.
> (多型物件以concret type object來使用時當然也就遵循各別多型物件的規則)
C++ 的缺點，就是必須要以人工的方式作類別正規化。
function dynamic(x)
{
if (x%1)
return Circle(x);
else
return Square(x);
}
以這個例子來說，編譯器至少應該自動去找他的基礎類別才是。
--
┌─────◆程式設計樂園◆─────┐ ╱ ╱ ￣ ▌￣ ￣ ╲╱ ＢＢＳ 城邦
│ CSZone.kkcity.com.tw │ ╲ ╲ ╴ ▌ ▌ ▏ ＫＫ免費撥接
└──《From:220.138.225.5 》──┘ 電話:449-1999 帳號:kkcity 密碼:kkcity
> -------------------------------------------------------------------------- <
發信人: Wiseman.bbs@bbs.cs.nthu.edu.tw (benqer), 看板: java
標 題: Re: 請問陣列的宣告…
發信站: 清華資訊(楓橋驛站) (Thu Jun 24 01:52:27 2004)
轉信站: ptt!ctu-reader!ctu-peer!news.nctu!netnews.csie.nctu!news.cs.nthu!maple
※ 引述《Corroson@kkcity.com.tw (藍月楓鈴)》之銘言：
> ※ 引述《Wiseman.bbs@bbs.cs.nthu.edu.tw (benqer)》之銘言：
> > 隱式template? 沒聽過這種東西, 也不知道用處在哪
> 就是把本來該寫出 template 的地方省略不寫。
那你要如何處理以下的問題
1. template<typename T>
void func(T p)
{
typename T::size_type i= p.size();
}
現在你說可以把template省略, T也可以省略,
那請問省略之後, 要如何才能取得參數p的型別(原本為T)的typedef ?
如同上例, 我們原本可以用typename T::來取得關於T type的其他資訊
現在你把這些重要資訊都省略了, 要如何解決以上的問題?
2. template的template parameter不一定只用在函式的參數上, 也可能是
用在函式的區域變數 ex
template<typename T>
T max(T p1, T p2)
{
T result;
if (p2>p1) result = p2;
else result= p1;
return result;
}
如同上例, 請問如果template跟T都省略了, 你如何指定result跟
p1,p2同type這個事實?
> > 使用template就意謂者型別必須於編譯期決定, (多型型別除外), ex
> > cout 是ostream type的物件, 但他的實作並不是去處理執行期才確定的物件
> > 而是針對每種物件定義出不同版本的function, 再由compiler辨析該採用的版本
> 正是如此。 fb(x) 不必在編譯時期確定其型別！
"由compiler辨析該採用的版本"這句話說得還不夠清楚嗎?
你要不要再回去K一下c++的書再來討論?
> > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> > 你真是說了天大的笑話了, 型別安全和效能恰巧就是scrip的缺點,
> > 你如果要說服大家的話,就拿出理由來證明吧
> 在本文之初，就已經說明，並非指現狀，而是指出一個發展方向。
> 它可以是同時滿足型別安全與執行效能的。
根本就是屁話, 你有什麼知識跟經驗夠格為大家指出c++的未來發展方向?
連基礎知識都不夠, 只是看了script的動態彈性就一廂情願的自以為是靈
丹妙藥, 如果你這麼喜歡script, 請改用smalltalk, static type的c++
是不合你胃口的
> > 既然說是template, 又說是由compiler檢查type-safety,
> > 那又何來以上所說runtime才確定型別的說法?
> > 你的觀念很矛盾
> 就如同 C++ 的指標可以 new 初衍生類別一樣。只不過這樣還不夠彈性。
> understand?
什麼彈性? 你可以用那樣的彈性應用在那裡?
有彈性就一定好喔 ? , 自己再想想吧
> > c++太嫩? 我看是你太嫩, 你根本不了解c++的多型跟泛型的意義 就在此妄下斷言
> > virtual/多型 允許物件的確切型別可以在runtime決定, 但是在compile-time,
> > 多型物件仍會遵循其base class的規則,由compiler進行檢查, 正因為多型物件
> > 在runtime是以base class物件的方式來使用, 所以即使compiler不知道多型物件
> > 的確切型別,也沒有違反type-safety的危險.
> > (多型物件以concret type object來使用時當然也就遵循各別多型物件的規則)
> C++ 的缺點，就是必須要以人工的方式作類別正規化。
> function dynamic(x)
> {
> if (x%1)
> return Circle(x);
> else
> return Square(x);
> }
> 以這個例子來說，編譯器至少應該自動去找他的基礎類別才是。
蠢得要命, function signature不指定回傳的type, 要讓compiler自己猜
就為了少打幾個字, 使用此function的人從此得從function的comment or document
猜回傳的型別.
我想你乾脆就把c++改成type-less, 所有的type都由compiler
從程式中粹取導出定義好了.
--
※ Origin: 楓橋驛站<bbs.cs.nthu.edu.tw> ◆ From: NK219-91-116-171.adsl.dynamic.apol.com.tw
> -------------------------------------------------------------------------- <
發信人: Wiseman.bbs@bbs.cs.nthu.edu.tw (benqer), 看板: java
標 題: Re: 請問陣列的宣告…
發信站: 清華資訊(楓橋驛站) (Thu Jun 24 02:46:01 2004)
轉信站: ptt!ctu-reader!ctu-peer!news.nctu!netnews.csie.nctu!news.cs.nthu!maple
※ 引述《Wiseman (benqer)》之銘言：
> > C++ 的缺點，就是必須要以人工的方式作類別正規化。
> > function dynamic(x)
> > {
> > if (x%1)
> > return Circle(x);
> > else
> > return Square(x);
> > }
> > 以這個例子來說，編譯器至少應該自動去找他的基礎類別才是。
> 蠢得要命, function signature不指定回傳的type, 要讓compiler自己猜
> 就為了少打幾個字, 使用此function的人從此得從function的comment or document
> 猜回傳的型別.
再補充一個問題, 別忘了c++採個別編譯的方式來build,
如果採取你的方法的話, 那麼使用dynamic function的module不知道dynamic
的回傳type,compiler在compile此module之時就無法以return type來檢查
是否符合type safety.
總之,除非有顯著的利益(而不是只有少打幾個字)
否則你提的方案根本不切實際
> 我想你乾脆就把c++改成type-less, 所有的type都由compiler
> 從程式中粹取導出定義好了.
--
※ Origin: 楓橋驛站<bbs.cs.nthu.edu.tw> ◆ From: NK219-91-116-171.adsl.dynamic.apol.com.tw
> -------------------------------------------------------------------------- <
發信人: Wiseman.bbs@bbs.cs.nthu.edu.tw (benqer), 看板: java
標 題: Re: 請問陣列的宣告…
發信站: 清華資訊(楓橋驛站) (Fri Jun 25 04:29:16 2004)
轉信站: ptt!ctu-reader!ctu-peer!news.nctu!news.csie.ncyu!news.cs.nthu!maple
※ 引述《wripery@kkcity.com.tw (平淡)》之銘言：
> ※ 引述《Wiseman.bbs@bbs.cs.nthu.edu.tw (benqer)》之銘言：
> > 那你要如何處理以下的問題
> 這很容易吧：
> 需要加的時候才加就行了！
> Take it easy.
既然有需要加的時候, 為何又多此一舉把template省略?
就為了少打幾個字? 為了讓程式看起來像script?
> > 1. template<typename T>
> > void func(T p)
> > {
> > typename T::size_type i= p.size();
> > }
> > 現在你說可以把template省略, T也可以省略,
> > 那請問省略之後, 要如何才能取得參數p的型別(原本為T)的typedef ?
> > 如同上例, 我們原本可以用typename T::來取得關於T type的其他資訊
> > 現在你把這些重要資訊都省略了, 要如何解決以上的問題?
> > 2. template的template parameter不一定只用在函式的參數上, 也可能是
> > 用在函式的區域變數 ex
> > template<typename T>
> > T max(T p1, T p2)
> > {
> > T result;
> > if (p2>p1) result = p2;
> > else result= p1;
> > return result;
> > }
> > 如同上例, 請問如果template跟T都省略了, 你如何指定result跟
> > p1,p2同type這個事實?
> > "由compiler辨析該採用的版本"這句話說得還不夠清楚嗎?
> > 你要不要再回去K一下c++的書再來討論?
> "由compiler辨析該採用的版本"中，
> template 字眼的確是有時可省略的。
根本沒回答問題, template省略了, compiler如何知道T是template parameter
而不是type name?, 如果T也省略了, programmer如何指定p1,p2, local variable
的type?
這麼喜歡省略, 那你為何不建議把class也省略, 反正class沒有return type,
沒有return type, }後面有分號的 的 C { };就可以辨析為class了囉?
> > 根本就是屁話, 你有什麼知識跟經驗夠格為大家指出c++的未來發展方向?
> > 連基礎知識都不夠, 只是看了script的動態彈性就一廂情願的自以為是靈
> > 丹妙藥, 如果你這麼喜歡script, 請改用smalltalk, static type的c++
> > 是不合你胃口的
> 嗯…看起來這已經不是 script 了，而是比 C++ 更進步的語言。
這麼有遠見的話可以去c++標準委員會提案,
看你怎麼說服c++委員會何以用了十年的template可以省略,
以及script特性為何是c++未來發展的方向
> > 什麼彈性? 你可以用那樣的彈性應用在那裡?
> > 有彈性就一定好喔 ? , 自己再想想吧
> 在「程式發展的過程」中，有彈性是很重要的！
彈性不是絕對的優點.
> > 蠢得要命, function signature不指定回傳的type, 要讓compiler自己猜
> 不是讓 compiler 自己猜，而是從 return 中尋找，這個功能蠻好的啊。
不要活在自己的世界裡. 請仔細想一下,不然也可以問一下專家,
不指定return type的優點跟缺點相比, 到底何者為大
> > 就為了少打幾個字, 使用此function的人從此得從function的comment or document
> > 猜回傳的型別.
> > 我想你乾脆就把c++改成type-less, 所有的type都由compiler
> > 從程式中粹取導出定義好了.
> 程式語言的最終目的，本來就是要讓人類輕鬆簡易的表達出所需要的計算功能。
> 一起朝這個方向來努力吧！讓 C++ 達到「容易表達」的境地吧。
把return type 省略就叫做容易表達 嗎?
我覺得是無法表達吧, 沒有return type所以programmer無法表達明確的return type
再提醒一次, 你們的想法真是蠢到爆, 要不要修正就看你們了
--
※ Origin: 楓橋驛站<bbs.cs.nthu.edu.tw> ◆ From: NK219-91-114-115.adsl.dynamic.apol.com.tw
> -------------------------------------------------------------------------- <
發信人: Corroson@kkcity.com.tw (藍月楓鈴), 看板: java
標 題: Re: 請問陣列的宣告…
發信站: KKCITY (Sun Jun 27 07:03:49 2004)
轉信站: ptt!ctu-reader!ctu-peer!news.nctu!netnews.csie.nctu!news.ee.ttu!news.n
※ 引述《wripery@kkcity.com.tw (平淡)》之銘言：
> 我們在思考問題的時候，經常不是先思考計算結果的結構，而是思考演算的過程；
> 因此這樣的彈性很容易的讓我們以臨時決定的方式，來決定回傳的結構，
> 這在「軟體發展過程」中，是一個重要的特性。 (很切實際)
這種回傳值，首先發難的，仍然可能是 C++ 或者 Java 之一，
因為他們各持其中的特點，現在缺乏將兩造融合的機制：
C++ 特點： template 技術
JAVA特點： 匿名類別，特別是可回傳內嵌的匿名類別。
不過將此兩者融合，有一個根本性的問題，
那就是必須在此下述問題中做一個抉擇：
是否要將所有物件，衍生自單一根類別。
這會造成核心技術的不同。
我以下面的觀點做結尾：
如果依目前的機器來說，我傾向於 C++ 不衍生自單一根類別的做法。
不過若連晶片設計都考慮進去，那我傾向於 JAVA 衍生自單一根類別的做法。
--
┌─────◆程式設計樂園◆─────┐ ◢ ◤ ★ 線上音樂新震撼 ★ ◢ ◤
│ CSZone.kkcity.com.tw │ ^_^ / 隨選隨播免等待 KKBOX◤ ^_^ /
└──《From:61.231.174.35 》──┘ ◤ http://www.kkbox.com.tw ◤