C++和JAVA的區別 -- 給初學者看

C++和JAVA的區別 -- 給初學者看

JAVA和C＋＋的區別介紹框架綱領如下：

(一) 序言：

(二) 我學習二者的個人感受：

(三) 個人建議：

(四) 用JAVA中繼承的特性來描述C＋＋和JAVA的關係圖示：

(五) JAVA和C＋＋的區別（前言導讀）：

(六) JAVA和C++的基本區別(開始華山論劍)

1)JAVA摒棄的C＋＋內容。

2)JAVA的新特性。

3)JAVA和C＋＋都有卻不同的特性.

(七) JAVA和C＋＋的區別詳細介紹（對部分知識點的擴充）：

(八) C＋＋與JAVA區別小總結：

開始進行：

（一）序言：本人整理的資料幾乎涵蓋了所有的方面，也可以說包含了用百度搜索能搜到的幾乎所有的內容，並參考有關書籍資料，耗時將近12個小時。可以說它 是互聯網上資料最全面、最具有代表性的二者的區別總彙，當然它沒有一本專門介紹二者區別的書更具有權威性和全面性，但是我相信你通過這些內容足以解決你在 實際工作或學習中遇到的編程問題！

其中所涉及到的內容不乏有拷貝的內容，但大部分是經過自己分析和思考而整理出來的，並對某些別人上傳到互聯網上的資料做了進一步的修改和說明。不是說我們從別人那裏ctrl+c一下放到自己的家門兒就算是ok了，我們儘可能的要向資料的準確性和版權性付相應的責任。　　

這樣一方面對自己有很大的提高，另一方面只有這樣才能給廣大同仁提供更準確和更豐富的信息內容，大家才能共同提高和進步.

（二）我學習二者的個人感受：

我最初學習的是Java，後來又學習C＋＋，雖然二者都是面向對象的語言(C＋＋是半面嚮對象語言)，但是在C＋＋的學習過程中，C＋＋“幾乎完全”沒有規則性或者超靈活性的語法讓一個之前學過JAVA語言的人感到很不爽！！！　　

Java確實是個很不錯的東西，尤其是其背後有強大的類庫做支撐，用起來感覺那是相當的爽，但速度也確實是個問題。幸好現在的Java語言，其執行方式已經不僅僅是解釋執行方式了，即時編譯器（JITC、just-in-time compiler）技術和原型編譯技術的出現大大提高了JAVA的運行效率。　　

C＋＋靈活無比，但純屬高級玩具或者高深的九陽神功，假如玩不好，就把自己繞進去，如練奇門遁甲一般走火入魔，如果玩好了，那可就是強大致極啊！　　

C++在設計時因爲必須完全兼容C語言又必須提供所有的面向對象特性所以最終它的結構變得特別複雜，當引入泛型編程STL（標準模板庫）之後顯得更加複雜。　　

Java是在C++的基礎上開發出來的，比C++簡化很多，容易使用很多，但是在有些方面特別是泛型方面明顯沒有C++使用起來靈活。在某些功能上也稍遜於C++，例如對於圖像的剪切等方面的技術。

（三）個人建議：所以我認爲如果先學習C＋＋再來學習JAVA會容易很多。先學C＋＋就好比一開始你是穿着褲子進行110米跨欄，再學習JAVA就好比你是穿着褲衩進行跨欄，沒有那麼多的亂七八糟的東西或者越弄越複雜的東西，顯得乾淨利落，在增加了多個新特性後又不失功能的強大。要不有人曾經打比方說：Java就是C++這個超級重裝騎兵脫下盔甲下了馬換上短劍拿起輕盾再背一把可替換的AK47。　　

當然，如果有人想學習JAVA，也沒有必要非得從C＋＋開始學起，我說的是如果有人需要兩種語言都學的話，這個流程還是可以考慮的!

（四）下面我用一個JAVA中繼承的特性來描述C＋＋和JAVA的關係：

class C＋＋

{ 　　

protected String attribute=”構造函數、new關鍵字等等”; 　　

C++( ){System.out.println(“我C＋＋是JAVA的爸爸！”);

} 　　

void C＋＋的家產( )

{ 　　

System.out.println(“我有家財萬貫：結構體或聯合體、枚舉、指針、操作符重載、預處理、支持自動的類型轉換、全局變量或全局函數、多 繼承析構函數、支持typedef、可以聲明無符號整數、goto語句、delete操作符、標準庫函數、wchar_t型、支持異常處理等等”);

}

}

class Java extends C＋＋ { 　　

//我完全繼承了父親的屬性　　

Java( ){System.out.println(“我JAVA是C＋＋的兒子！”);

} 　　

void C＋＋的家產( )//兒子重寫C＋＋的家產( )這個方法

{ 　　

System.out.println(“我有更值錢的東西：我用類來代替結構體、我有API來代替標準庫函數、我有finalize( )函數來代替析構函數、我的char類型是16位的Unicode字符來代替wchar_t型、內置的字符串類型String來代替C＋＋中的string類、我捕捉一個被引發的異常來代替C＋＋的異常處理機制。”);

} 　　

void JAVA新屬性( )

 {

System.out.println(“我不單單和父親在相同的領域做的比他更好，我還涉及了他沒有涉及到的領域：我擁有自己的包、多線程和接口、自動 內存管理機制、>>>操作完成無符號的右移、文檔註釋等等多元化的市場策略，涉及到了房地產、金融、健身美容、生物醫藥等領域，呵 呵！”);

 } }

（五）JAVA和C＋＋的區別（前言導讀）：

　JAVA和C++都是面嚮對象語言。也就是說，它們都能夠實現面向對象思想（封裝，繼乘，多態）。而由於c++爲了照顧大量的C語言使用者，從而兼容了C，使得自身僅僅成爲了帶類的C語言，多多少少影響了其面向對象的徹底性！JAVA則是完全的面嚮對象語言，它句法更清晰，規模更小，更易學。它是在對多種程序設計語言進行了深入細緻研究的基礎上，摒棄了其他語言的不足之處，從根本上解決了c++的固有缺陷。　　

用C++可以使用純過程化的編程，也可以是基於對象的編程，還可以是面向對象的編程，當然大部分是混合編程，c++可以跨平臺（我強調一下必須是用標準C＋＋，就是調用標準庫函數寫的程序跨平臺才能非常容易，不能跨平臺的是VC++等IDE（也就是說你用VC＋＋寫出來的C＋＋程序就不能跨平臺，其實Linux下的G++編譯器對標準C++支持得很好，注意：不要混淆C＋＋和VC＋＋的概念。）[/color]java是純面向對象的語言，其最大的特色Write once ,Run anywhere！　　

作爲一名C++程序員，我們早已掌握了面向對象程序設計的基本概念，而且Java的語法無疑是非常熟悉的。事實上，Java本來就是從C++衍生出來的， 而且Java語言的對象模型幾乎就是C++對象模型的簡化版。然而，C++和Java之間仍存在一些顯著的差異。可以這樣說，這些差異代表着技術的極大進 步。一旦我們弄清楚了這些差異，就會理解爲什麼說Java是一種優秀的程序設計語言。

Java和c++的相似之處多於不同之處，但兩種語言因爲有幾處主要的不同使得Java更容易學習，並且編程環境更爲簡單。

（六）JAVA和C++的基本區別(開始華山論劍)

先來探討一下C＋＋和JAVA的基本區別。　　

這些不同之處大致分爲三類：　　

1)JAVA不支持的C＋＋特性。　　

2)JAVA的獨特之處。　　

3)C＋＋和JAVA都有但是卻不相同的特性。

詳細討論這三類： 1)JAVA摒棄的C＋＋內容.

有些C＋＋的內容特性JAVA並不再支持。在某些情況下，一個特殊的C＋＋特性和JAVA的運行環境不相關。另一些情況下，JAVA的設計者捨棄了C＋＋中某些重複的內容。還有一些情況是，出於對Internet applet的運行安全問題的考慮，JAVA不再支持某些C＋＋的特點。　　

C＋＋和JAVA之間的最大不同可能是JAVA不再支持指針。指針使C＋＋語言成爲功能最強大最重要的一種編程語言。但同時指針在使用不正確的情況下也是C＋＋中最危險的部分。JAVA不支持指針的原因主要有兩點：　　

(1)指針本身就非常不安全。例如，使用C＋＋的狀態指針，可以訪問程序代碼和數據段外的內存地址，一個惡意程序可以利用這個特點破壞系統，完成非法訪問(如獲取口令等)，或者違反安全限制。　　(2)即使指針可以被限制在JAVA的運行系統中(這在理論上是可行的，因爲JAVA程序是解釋執行的)，JAVA的設計者相信它們仍然是麻煩所在。　　

注意：既然JAVA中不存在指針，那麼也不存在－>操作符。這裏還有一些非常重要的”省略”：

a)JAVA不再支持操作符重載。

操作符重載在某些情況下造成類C＋＋程序的含糊不清，JAVA的設計人員感覺它帶來的麻煩要比它帶來的好處多。

b)JAVA不再包含結構或者聯合。在可以完全包含它們的類出現後，這些結構成爲冗餘部分。

c)JAVA不再包括預處理，也不再支持預處理指令。預處理在C＋＋語言中已經不如C中那麼重要，JAVA的設計者認爲是徹底消除預處理的時候了。　　

d)JAVA不支持自動的類型轉換，因爲這種類型轉換導致精度降低例如當從長整型轉換爲整型時，必須顯示強制執行類型轉換。　　

e)在JAVA中的代碼必須封裝在一個或者多個類中。因此JAVA中不再包含所謂的全局變量或者全局函數。　　

f)JAVA不再允許默認參數。在C＋＋中，當過程調用時存在沒有對應值的參數時可以使用一個預先指定的值。JAVA不再允許這樣的操作。　　

g)JAVA不支持多繼承，即不允許一個子類繼承多個父類。

h)雖然JAVA支持構造函數，但是不再支持析構函數[/b]。但是，JAVA增加了finalize( )函數。

i)JAVA不再支持typedef. 　　

j)在JAVA中不再可能聲明無符號整數。　　

k)JAVA不再支持goto語句。　　

l)JAVA不再有delete操作符。　　

m)JAVA中的<>不再重載I/O操作。　　

n)JAVA中，對象只能由引用傳遞，C＋＋中對象可由值或引用傳遞.

2)、JAVA的新特性。

　JAVA中的許多特性是C＋＋中沒有的。其中最重要的三個方面是多線程、包和接口，還有其他的許多獨特之處都豐富了JAVA編程環境。　　

1)多線程允許兩個或者多個相同的線程併發運行。

而且，這是一種在語言級支持的併發機制。C＋＋中沒有類似的機制，或者說C＋＋採用的是單線程的體系結構。如果需要併發執行一個C＋＋程序，必須利用操作系統的功能手工啓動。雖然這兩種方法都可以同時執行兩個或者多個線程，但是JAVA的方法清楚而且便於使用。　

2)C＋＋中沒有可以與JAVA包對應的特性。[/b]最近似的是用一個公用頭文件的一組庫函數。然而，在C＋＋中構建和使用庫函數與在JAVA中構建包和使用包是完全不同的。　　

3)JAVA的接口與C＋＋的抽象類相似（C＋＋中的抽象類是包括至少一個純虛函數的類）。[/b]例如，C＋＋的抽象類和JAVA的接口都不能創建實例。兩者都用於指定一個子類實現的一致接口。兩者之間最大的不同之處在於接口更清晰的表明了這個概念。　　

4)JAVA提供一個流線型的內存分配機制。

與C＋＋類似，JAVA支持new這個關鍵字。但是，不支持delete關鍵字。當對象的最後一個引用撤銷時，對象本身被自動地刪除，並進行內存垃圾回收。　　

5)JAVA丟棄了C＋＋的標準庫，將它替換成自己的API類集合。[/b]它們功能上有相似之處，但是名字和參數有顯著的不同。同時，因爲所有的JAVA API庫都是面向對象的，而C＋＋庫只有部分是，所以庫例程調用的方式不同。　　

6)JAVA增強了break和continue語句以接收標記。

　JAVA中的char類型是國際通用的16位Unicode字符集，所以能自動錶達大多數國家的字符。這與C＋＋中的wchar_t型相似。使用Unicode字符增強了代碼的可移植性。　　

7)JAVA增加了>>>操作，完成無符號的右移。　　

8)除支持單行和多行的註釋之外，JAVA增加了第三種註釋方法：文檔註釋。文檔註釋以結尾。　　9)JAVA包含一個內置的字符串類型叫做String。

String在某種程度上和C＋＋提供的標準string類很相似。當然C＋＋中的string只有在程序中聲明後方可使用，它並不是內置的類型

3)、JAVA和C＋＋的不同的特性。

1)JAVA和C＋＋都支持布爾類型的數據，但是JAVA實現true和false的方式和C＋＋不同。在C＋＋中，true是非零值，false是零。在JAVA中，true and false都是預先定義好的常量，並且是一個布爾表達式能得到的唯一的兩個值。雖然C＋＋也定義了true and false ，並指定爲布爾變量，但是C＋＋自動將非零值轉換爲true,零值轉換爲false。這種情況在JAVA中不會出現。　　

2)在創建C＋＋類時，訪問說明符應用到一組聲明中。而JAVA中，訪問說明符僅應用於其限定的聲明中。　　

3)C＋＋支持異常處理，這與JAVA類似，但是在C＋＋中無需捕捉一個被引發的異常。

（七）JAVA和C＋＋的區別詳細介紹（對部分知識點的擴充）　

(1) JAVA的運行速度（JAVA最大的障礙在於速度）

解釋過的Java要比C的執行速度慢上約20倍。無論什麼都不能阻止Java語言進行編譯。當時剛剛出現了一些準實時編譯器，它們能顯著加快速度。當然， 我們完全有理由認爲會出現適用於更多流行平臺的純固有編譯器，但假若沒有那些編譯器，由於速度的限制，必須有些問題是Java不能解決的。　　

許多企業的應用開發人員非常喜愛Java的語言特性，但是在開發重要系統時，語言特性和執行效率之間的抉擇往往令人傷透腦筋。在關鍵計算中，用戶可能並不 在乎數據如何壓縮或者運行的延遲關係如何設置，但是對程序的運行速度卻非常重視，這使廠商將Java的編譯策略開發放在了首位。現在的Java語言，其執 行方式已經不僅僅是解釋執行方式了，即時編譯器（JITC、just-in-time compiler）技術和原型編譯技術已經被許多廠家採用，包括Sun、IBM、Oracle以及Netscape等公司在內的技術提供商正在利用這些技 術逐步提高Java的執行速度，其中IBM公司早已將Java虛擬機（JVM，JavaVirtual Machine）、操作系統和硬件的特性有機的結合在一起，非常有效地提高了Java的執行效率。　　

(2)JAVA所有東西都必須置入一個類.

Java是完全面向對象的語言，它不再支持C++程序時所使用的過程式的設計方法，所有函數和變量部必須是類的一部分。除了基本數據類型（例如整型、字符型、布爾型等）之外，其他的數據對Java來說都是對象，包括數組。　　

對象將數據和方法結合起來，把它們封裝在類中，這樣每個對象都可實現自己的特點和行爲。JAVA不存在全局函數或者全局數據。如果想獲得與全局函數等價的 功能，可考慮將static方法和static數據置入一個類裏。而c++允許將函數和變量定義爲全局的。此外，Java中取消了c／c++中的結構和聯 合、枚舉這一類的東西，一切只有“類”（Class），消除了不必要的麻煩。　　

JAVA的語法其實是參照c++的語法誕生的，但是她去除了c++中的多重繼承，指針，delete等難於掌握的技術，爲了便於移植和安全性，java採用了純面向對象技術，即使是主函數public static void main(String[] args）{}也要放在主類中，可以看出和C＋＋的明顯區別。　　

(3) 在Java中，類定義採取幾乎和C++同樣的形式。

但沒有標誌結束的分號。沒有類聲明，只有類定義。　

(4) Java中沒有作用域範圍運算符“::”.

Java利用點號做所有的事情，但可以不用考慮它，因爲只能在一個類裏定義元素。即使那些方法定義，也必須在一個類的內部，所以根本沒有必要指定作用域的範圍。我們注意到的一項差異是對static方法的調用:使用ClassName.methodName()。　　

除此以外，package（包）的名字是用點號建立的，並能用import關鍵字實現C++的“#include”的一部分功能。　　

例如下面這個語句：

import java.awt.*; 　　

#include並不直接映射成import，但在使用時有類似的感覺。若想使用另一個庫裏的類，只需使用import命令，並指定庫名即可。不存在類似於預處理機的宏。　　

c／c十十在編譯過程中都有一個預編譯階段，即衆所周知的預處理器。預處理器爲開發人員提供了方便，但增加了編譯的複雜性。JAVA虛擬機沒有預處理器， 但它提供的引入語句(import)與c十十預處理器(#include)的功能類似。（注意：只是類似而已）　(5)JAVA中沒有預處理功能的詳細介 紹

不再有#define、#include等預處理程序(Preprocessor)的功能。C++語言很重要的一個特點就是它的預處理程序。有些其他程序 語言雖然也加入了#include的功能，但是還是欠缺處理宏(Macro)的能力。#define的功能在Java中我們可以用定義常數 (constant)的方式來取代，而#include在Java中是不需要的，因爲在Java中程序在執行時，會把類型數據記錄在對象實體之中，我們不 需要靠一些標頭文件(header file)來知道我們使用的對象或數值是屬於什麼數據類型。　　

如果你使用C++語言時，只使用預處理程序的#include和#define功能的話，那麼你大概不會覺得Java這樣的設計對你產生什麼樣的困擾，但是如果你是使用C++語言預處理程序中宏功能的高手，你可能會覺得很不方便，進而懷疑Java如此設計的意義何在。　　

使用預處理程序雖然可以很方便地達到許多功能，但是站在軟件工程的角度上看，對整個軟件的維護其實是很不利的。由於C++語言中預處理程序的功能太過強 大，厲害的程序設計高手常會自行開發一套只有自己看的懂的宏語言，一旦整個軟件要交給其他人去維護，後繼者很難在短時間內瞭解前一個人所寫下的宏功能，增 加軟件開發時團隊工作及日後維護的困難度。　　

另外一點則是C++語言的編譯器所看到的程序代碼，其實和程序設計者看到的程序代碼是不同的。程序設計者看到的是尚未經過預處理程序處理過的程序代碼，而 編譯器看到的則是預處理程序處理過的程序代碼，一旦交給預處理程序處理的宏內容有誤，編譯器產生的錯誤信息將不會是程序設計師所預料的。而這一點自然也增 加了程序在排錯時的困難度。　　

預處理程序的存在也造成了閱讀程序的不便。如果你想使用別人已經完成的C++語言程序，那麼通常你不但要閱讀他所寫下的文件，還必須一併查閱上文件，才能瞭解其程序的全貌。如果換成是Java程序，只要查看java的程序文件就夠了。　　

(6)與C++類似，Java含有一系列“主類型”（Primitive type），以實現更有效率的訪問 　　在Java中，這些類型包括boolean，char，byte，short，int，long，float以及double.所有主類型的大小都是 固有的，且與具體的機器無關（考慮到移植的問題）。這肯定會對性能造成一定的影響，具體取決於不同的機器。對類型的檢查和要求在Java裏變得更苛刻。　 　

例如：　　

條件表達式只能是boolean（布爾）類型，不可使用整數。　　

必須使用象X+Y這樣的一個表達式的結果；不能僅僅用“X+Y”來實現“副作用”。　　

(7)Java靜態引用的字串會自動轉換成String對象。[/b][/color] 　　java和C及C++不同，沒有獨立的靜態字符數組字串可供使用。　　

c和c十十不支持字符串變量，在c和c十十程序中使用Null終止符代表字符串的結束，在Java中字符串是用類對象(string和stringBuffer)來實現的，這些類對象是Java語言的核心，用類對象實現字符串有以下幾個優點：　　

a)在整個系統中建立字符串和訪問字符串元素的方法是一致的；　　

b)Java字符串類是作爲Java語言的一部分定義的，而不是作爲外加的延伸部分；　　

c)Java字符串執行運行時檢查，可幫助排除一些運行時發生的錯誤；　　

d)可對字符串用“十”號進行連接操作。

(8) Java增添了三個右移位運算符“>>>”，具有與“邏輯”右移位運算符類似的功用，可在最末尾插入零值。“>>”則會在移位的同時插入符號位（即“算術”移位）。

(9) 儘管表面上類似，但與C++相比，Java數組採用的是一個頗爲不同的結構，並具有獨特的行爲。就是說Java提供數據下標越界檢查，而C++沒有提供.

有一個只讀的length成員，通過它可知道數組有多大。而且一旦超過數組邊界，運行期檢查會自動丟棄一個異常。所有數組都是在內存“堆”裏創建的，我們 可將一個數組分配給另一個（只是簡單地複製數組句柄）。數組標識符屬於第一級對象，它的所有方法通常都適用於其他所有對象。　

(10) 對於所有不屬於主類型的對象，都只能通過new命令創建　和C++不同，Java沒有相應的命令可以“在堆棧上”創建不屬於主類型的對象。所有主類型都只 能在堆棧上創建，同時不使用new命令。所有主要的類都有自己的“封裝（器）”類，所以能夠通過new創建等價的、以內存“堆”爲基礎的對象（主類型數組 是一個例外：它們可象C++那樣通過集合初始化進行分配，或者使用new).

(11) Java中不必進行提前聲明方法。 　　

若想在定義前使用一個類或方法，只需直接使用它即可——編譯器會保證使用恰當的定義。所以和在C++中不同，我們不會碰到任何涉及提前引用的問題。　　

(12) Java用包代替了命名空間。 　　

由於將所有東西都置入一個類，而且由於採用了一種名爲 “封裝”的機制，它能針對類名進行類似於命名空間分解的操作，所以命名的問題不再進入我們的考慮之列。數據包也會在單獨一個庫名下收集庫的組件。我們只需簡單地“import“（導入）一個包，剩下的工作會由編譯器自動完成。　　

(13) 被定義成類成員的對象句柄會自動初始化成null。 　

對基本類數據成員的初始化在Java裏得到了可靠的保障。若不明確地進行初始化，它們就會得到一個默認值（零或等價的值）可對它們進行明確的初始化（顯式 初始化）：要麼在類內定義它們，要麼在構建器中定義。採用的語法比C++的語法更容易理解，而且對於static和非static成員來說都是固定不變 的。我們不必從外部定義static成員的存儲方式，這和C++是不同的。　　

(14) 在Java裏，沒有象C和C++那樣的指針。 　　

用new創建一個對象的時候，會獲得一個引用（或者叫句柄）　　例如： Strings = new String("helloworld"); 　　

然而，C++引用在創建時必須進行初始化，而且不可重定義到一個不同的位置。但Java引用並不一定侷限於創建時的位置。它們可根據情況任意定義，這便消除了對指針的部分需求。　　

在C和C++裏大量採用指針的另一個原因是爲了能指向任意一個內存位置（這同時會使它們變得不安全，也是Java不提供這一支持的原因）。指針通常被看作 在基本變量數組中四處移動的一種有效手段。Java允許我們以更安全的形式達到相同的目標。解決指針問題的終極方法是“固有方法”。將指針傳遞給方法時， 通常不會帶來太大的問題，因爲此時沒有全局函數，只有類。而且我們可傳遞對對象的引用。Java語言最開始聲稱自己“完全不採用指針！”但隨着許多程序員 都質問沒有指針如何工作？於是後來又聲明“採用受到限制的指針”（有人管它叫隱藏了的指針）。大家可自行判斷它是否“真”的是一個指針。但不管在何種情況 下，都不存在指針“算術”。　　

JAVA語言讓編程者無法找到指針來直接訪問內存無指針，並且增添了自動的內存管理功能，從而有效地防止了c／c++語言中指針操作失誤，如野指針所造成 的系統崩潰。但也不是說JAVA沒有指針，虛擬機內部還是使用了指針，只是外人不得使用而已。這有利於Java程序的安全。　　　　

其實，取消指針(Pointer)這樣數據類型，可能會讓許多熟悉C++語言的程序設計師大吃一驚。在C++語言裏，靈活地運用指針是許多程序設計師的得 意之作，但是佔整個除錯時間最久的也是指針的問題。配合上C++對內存管理的態度，程序設計師必須要自己去追蹤自己向系統要到的內存，最後確實地交還給系 統，並且在使用指針時，要小心翼翼地注意不要跨過合法的記憶空間，造成Segmentation Fault或General Protection Fault之類的問題。　　

Java去掉了指針類型，並不表示程序設計師在開發高級數據結構，像堆棧(stack)、隊列(queue)、二元樹(binarytree)時，都必須要像在傳統Basic上，利用大範圍的數組來自行模擬系統內存，自行建構類似指針的表示方式。　　

相反地，Java提供了和Lisp語言中相似的Reference類型，通過Reference去讀取配置到的內存內容，可以確保不會去讀取到不屬於自己 的內存空間，而另一方面，程序的執行系統也可以動態地去做內存垃圾回收的工作，將沒有被reference參考到的內存空間回收給系統使用。　　 ff(15) Java提供了與C++類似的“構建器”（Constructor）。　　　　

如果不自己定義一個，就會獲得一個默認構建器。而如果定義了一個非默認的構建器，就不會爲我們自動定義默認構建器。這和C++是一樣的。注意沒有複製構建器，因爲所有自變量都是按引用傳遞的（注意：而C＋＋中對象可由值或引用傳遞。）　　

(16) Java中沒有“破壞器”（Destructor）。 　　

變量不存在“作用域”的問題。一個對象的“存在時間”是由對象的存在時間決定的，並非由垃圾收集器決定。有個finalize()方法是每一個類的成員， 它在某種程度上類似於C++的“破壞器（就是析構函數的使用）”。但finalize()是由垃圾收集器調用的，而且只負責釋放“資源”（如打開的文件、 套接字、端口、URL等等）。如需在一個特定的地點做某樣事情，必須創建一個特殊的方法，並調用它，不能依賴finalize()。而在另一方面，C++ 中的所有對象都會（或者說“應該”）破壞，但並非Java中的所有對象都會被當作“垃圾”收集掉。由於Java不支持破壞器的概念，所以在必要的時候，必 須謹慎地創建一個清除方法。而且針對類內的基礎類以及成員對象，需要明確調用所有清除方法。　　

(17) Java具有方法“重載”機制，它的工作原理與C++函數的重載載幾乎是完全相同的。　　

(18) Java不支持默認自變量。 　　

(19) Java中沒有goto語句。

Java一方面移除了Goto的功能，它採取的無條件跳轉機制是“break 標籤”或者“continue 標籤” ，另一方面同時擴大了break和continue的功能，可以允許多層循環的break或continue。如此一來不但避免了濫用Goto的可能性，同時也保存下Goto的好處。　　

“可怕”的goto語句是c和c++的“遺物”，它是該語言技術上的合法部分，引用goto語句引起了程序結構的混亂，不易理解，goto語句主要用於無 條件轉移子程序和多結構分支技術。鑑於以上理由，Java不提供goto語句，也不提供goto關鍵字和of、const關鍵字，使程序簡潔易讀。（注 意：有些書上會說java也提供goto關鍵字，但是不使用，我不知道以前的說法如何，你只要記住java裏邊沒有goto這個東西就可以了。而且不能用 goto做爲對象名字、引用或方法名、類名等。）　　

在程序語言的發展史上，Goto一直是譭譽參半的一項功能。在很多時候使用Goto可以大幅減少不必要的程序代碼，但是也由於Goto可以很自由地改變程 序的流程，如果冒然地使用，更可能造成程序結構混亂的情況。一般來說，正確使用Goto的例子多出現在循環內部，想要提早結束某一層循環。在C語言中，我 們可以使用break 或contine來改變某一層循環的流程，但如果想要改變兩層以上的環執行流程，不是使用Goto就是以多餘的布爾(boolean)變量，配合上一串 if-then-else的判斷來達成。　　

(20) Java採用了一種單根式的分級結構，因此所有對象都是從根類Object統一繼承的。 　　

而在C++中，我們可在任何地方啓動一個新的繼承樹，所以最後往往看到包含了大量樹的“一片森林”。在Java中，我們無論如何都只有一個分級結構。儘管 這表面上看似乎造成了限制，但由於我們知道每個對象肯定至少有一個Object接口，所以往往能獲得更強大的能力。C++目前似乎是唯一沒有強制單根結構 的唯一一種OO（面向對象）語言。　　

(21) Java沒有模板或者參數化類型的其他形式。 　　

它提供了一系列集合：Vector（向量），Stack（堆棧）以及Hashtable（散列表），用於容納Object引用。利用這些集合，我們的一系列要求可得到滿足。但這些集合並非是爲實現象C++“標準模板庫”（STL）那樣的快速調用而設計的。Java 1.2中的新集合顯得更加完整，但仍不具備正宗模板那樣的高效率使用手段。　　

(22)“垃圾收集”意味着在Java中出現內存漏洞的情況會少得多，但也並非完全不可能。　　　　

若調用一個用於分配存儲空間的固有方法，垃圾收集器就不能對其進行跟蹤監視。　　

然而，內存漏洞和資源漏洞多是由於編寫不當的finalize()造成的，或是由於在已分配的一個塊尾釋放一種資源造成的（“破壞器”在此時顯得特別方 便）。垃圾收集器是在C++基礎上的一種極大進步，使許多編程問題消彌於無形之中。但對少數幾個垃圾收集器力有不逮的問題，它卻是不大適合的。但垃圾收集 器的大量優點也使這一處缺點顯得微不足道。　　

(23) Java內建了對多線程的支持。 　　

利用一個特殊的Thread類，我們可通過繼承創建一個新線程（放棄了run()方法）。若將synchronized（同步）關鍵字作爲方法的一個類型 限制符使用，相互排斥現象會在對象這一級發生。在任何給定的時間，只有一個線程能使用一個對象的synchronized方法。在另一方面，一個 synchronized方法進入以後，它首先會“鎖定”對象，防止其他任何synchronized方法再使用那個對象。只有退出了這個方法，纔會將對 象“解鎖”。在線程之間，我們仍然要負責實現更復雜的同步機制，方法是創建自己的“監視器”類。遞歸的synchronized方法可以正常運作。若線程 的優先等級相同，則時間的“分片”不能得到保證。　　(24)我們不是象C++那樣控制聲明代碼塊，而是將訪問限定符（public，private和 protected）置入每個類成員的定義裏。　　　　

JAVA中若未規定一個“顯式”（明確的）限定符，就會默認爲“友好的”（friendly）。這意味着同一個包裏的其他元素也可以訪問它（相當於它們都成爲 C++的“friends”——朋友），但不可由包外的任何元素訪問。而在C＋＋中如果未規定就會默認爲私有的private。　　

類——以及類內的每個方法——都有一個訪問限定符，決定它是否能在文件的外部“可見”private關鍵字通常很少在Java中使用，因爲與排斥同一個包 內其他類的訪問相比，“友好的”訪問通常更加有用。　　然而，在多線程的環境中，對private的恰當運用是非常重要的。Java的protected 關鍵字意味着“可由繼承者訪問，亦可由包內其他元素訪問”。注意Java沒有與C++的protected關鍵字等價的元素，後者意味着“只能由繼承者訪 問”（以前可用“private protected”實現這個目的，但這一對關鍵字的組合已被取消了）　　

(25) 嵌套的類。　　　　

在C++中，對類進行嵌套有助於隱藏名稱，並便於代碼的組織（但C++的“命名空間”已使名稱的隱藏顯得多餘）。Java的“封裝”或“打包”概念等價於 C++的命名空間，所以不再是一個問題。Java 1.1引入了“內部類”的概念，它祕密保持指向外部類的一個句柄——創建內部類對象的時候需要用到。這意味着內部類對象也許能訪問外部類對象的成員，毋需 任何條件——就好象那些成員直接隸屬於內部類對象一樣。這樣便爲回調問題提供了一個更優秀的方案——C++是用指向成員的指針解決的。(由於存在前面介紹 的那種內部類，所以Java裏沒有指向成員的指針。 ) 　　

(26) Java不存在“嵌入”（inline）方法。 　　

JAVA所有方法都是在類的主體定義的。所以用C++的眼光看，似乎所有函數都已嵌入，但實情並非如此。Java編譯器也許會自行決定嵌入一個方法，但我 們對此沒有更多的控制權力。在Java中，可爲一個方法使用final關鍵字，從而“建議”進行嵌入操作。然而，嵌入函數對於C++的編譯器來說也只是一 種建議。　　

(27) Java中的繼承具有與C++相同的效果，但採用的語法不同。 　　

Java用extends關鍵字標誌從一個基礎類的繼承，並用super關鍵字指出準備在基礎類中調用的方法，它與我們當前所在的方法具有相同的名字（然 而，Java中的super關鍵字只允許我們訪問父類的方法——亦即分級結構的上一級）。通過在C++中設定基礎類的作用域，我們可訪問位於分級結構較深 處的方法。亦可用super關鍵字調用基礎類構建器。正如早先指出的那樣，所有類最終都會從Object裏自動繼承。和C++不同，不存在明確的構建器初 始化列表。但編譯器會強迫我們在構建器主體的開頭進行全部的基礎類初始化，而且不允許我們在主體的後面部分進行這一工作。通過組合運用自動初始化以及來自 未初始化對象句柄的異常，成員的初始化可得到有效的保證。　　

b舉例說明

public class Foo extends Bar

{ 　　

publicFoo(String msg)

 { 　　

   super(msg);  Calls base constructor } 　　

   public baz(int i)

   {  Override 　　

      super.baz(i); 

       Calls base method

    }

  } 　　

(28) Java中的繼承不會改變基礎類成員的保護級別。 　　

我們不能在Java中指定public，priv ate或者protected繼承，這一點與C++是相同的。此外，在衍生類中的優先方法不能減少對基礎類方法的訪問。例如，假設一個成員在基礎類中屬於public，而我們用另一個方法代替了它，那麼用於替換的方法也必須屬於public（編譯器會自動檢查）。　　

(29) Java提供了一個interface關鍵字，它的作用是創建抽象基礎類的一個等價物。　　　　

在其中填充抽象方法，且沒有數據成員。這樣一來，對於僅僅設計成一個接口的東西，以及對於用extends關鍵字在現有功能基礎上的擴展，兩者之間便產生 了一個明顯的差異。不值得用abstract關鍵字產生一種類似的效果，因爲我們不能創建屬於那個類的一個對象。一個abstract（抽象）類可包含抽 象方法（儘管並不要求在它裏面包含什麼東西），但它也能包含用於具體實現的代碼。因此，它被限制成一個單一的繼承。通過與接口聯合使用，這一方案避免了對 類似於C++虛擬基礎類那樣的一些機制的需要。　　

爲創建可進行“例示”（即創建一個實例）的一個interface（接口）的版本，需使用implements關鍵字。它的語法類似於繼承的語法，如下所示：

public interface Face

{ 　　

   public void smile();

} public class Baz extends Bar implements Face

{ 　　

   public void smile( )

  { 　

  　System.out.println("a warm smile");

   }

} 　　

(30) Java中沒有virtual關鍵字，因爲所有非static方法都肯定會用到動態綁定。　　　　

在Java中，程序員不必自行決定是否使用動態綁定。C++之所以採用了virtual，是由於我們對性能進行調整的時候，可通過將其省略，從而獲得執行 效率的少量提升（或者換句話說：“如果不用，就沒必要爲它付出代價”）。virtual經常會造成一定程度的混淆，而且獲得令人不快的結果。final關 鍵字爲性能的調整規定了一些範圍——它向編譯器指出這種方法不能被取代，所以它的範圍可能被靜態約束（而且成爲嵌入狀態，所以使用C++非virtual 調用的等價方式）。這些優化工作是由編譯器完成的。　　

(31) Java不提供多重繼承機制（MI），至少不象C++那樣做。 　　

與protected類似，MI表面上是一個很不錯的主意，但只有真正面對一個特定的設計問題時，才知道自己需要它。由於Java使用的是“單根”分級結構，所以只有在極少的場合才需要用到MI。interface關鍵字會幫助我們自動完成多個接口的合併工作。　　

c++支持多重繼承，這是c++的一個特徵，它允許多父類派生一個類。儘管多重繼承功能很強，但使用複雜，而且會引起許多麻煩，編譯程序實現它也很不容 易。Java不支持多重繼承，但允許一個類繼承多個接口(extends+implement)，實現了c++多重繼承的功能，又避免了c++中的多重繼 承實現方式帶來的諸多不便。

所謂的interface基本上定義了一個類的對外溝通的方法原型，以及類內部的常數，和多重繼承不同之處在於interface並不會定義類方法的內容，以及類中的變量數據。　　

(32) 運行期的類型標識功能與C++極爲相似。 　　

例如，爲獲得與句柄X有關的信息，可使用下述代碼：　　

X.getClass().getName(); 　　

爲進行一個“類型安全”的緊縮造型，可使用：　　derived d = (derived)base; 　　

這與舊式風格的C造型是一樣的。編譯器會自動調用動態造型機制，不要求使用額外的語法。儘管它並不象C++的“new casts”那樣具有易於定位造型的優點，但Java會檢查使用情況，並丟棄那些“異常”，所以它不會象C++那樣允許壞造型的存在。　　

(33) Java採取了不同的異常控制機制，因爲此時已經不存在構建器。 　　

可添加一個finally從句，強制執行特定的語句，以便進行必要的清除工作。Java中的所有異常都是從基礎類Throwable裏繼承而來的，所以可確保我們得到的是一個通用接口。

public void f(Obj b) throws IOException

{ 　　

   myresource mr = b.createResource(); 　　

   try

   { 　

   　mr.UseResource(); 　　　

 　} catch(MyException e)

   {  handle my exception

   } 　　　　

   catch(Throwable e)

    { 

        handle all other exceptions

    } 　　　　

    finally{ mr.dispose();  special cleanup }

 } 　　

(34) Java的異常規範比C++的出色得多。 　　

JAVA中的異常機制用於捕獲例外事件，增強系統容錯能力　　

如代碼所示：

try

{ 　　

   可能產生例外的代碼　　

} catch(exceptionType name)

其中exceptionType表示異常類型。

{ 處理 } 　　

而C++則沒有如此方便的機制。　　

java丟棄一個錯誤的異常後，不是象C++那樣在運行期間調用一個函數，Java異常規範是在編譯期間檢查並執行的。除此以外，被取代的方法必須遵守那 一方法的基礎類版本的異常規範：它們可丟棄指定的異常或者從那些異常衍生出來的其他異常。這樣一來，我們最終得到的是更爲“健壯”的異常控制代碼。

(35) Java具有方法重載的能力，但不允許運算符（操作符）重新載OperatorOverloading 　　

String類不能用+和+=運算符連接不同的字串，而且String表達式使用自動的類型轉換，但那是一種特殊的內建情況。（備註：在c++中的string是小寫的）　　

Java不支持操作符重載。操作符重載被認爲是c++的突出特徵，在Java中雖然類大體上可以實現這樣的功能，但操作符重載的方便性仍然丟失了不少。　　

Java語言不支持操作符重載是爲了保持Java語言儘可能簡單。 C++中使用操作符重載主要是可以使你的程序看起來更爲自然。　　

如下面是一個程序自定義的複數類：　　

C++中自定義的複數類及

0pemtor Overloading class Complex

{ 　　public： 　　Complex(double real,double image)

{ 　　

  Real_number=real； 　　Image_number=image；

} Complex operator+(Complex&rhs)

{ 　　

Return Complex(rhs．real_number+real_number，rhs.image_number+image_，nulnbef)；

} 　　

private： 　　

doublereal_number 實部　　

doublejmage_nunmber； 虛部

 } 　　

在這裏，如果你使用+來作爲複數的加法符號，大家都不會有疑義，但是如果你使用的是*或》這樣的符號，那麼別人看到你的程序之後，難保不會產生認識上的錯誤。這也是Operator Overloading一大問題，當大家都對運算符賦予自己的定義後，整個程序的可讀性就會大受影響。Operator Overloading的存在並不是必要的，我們一樣可以定義類中的方法來達到同樣的目的.

 

(36) 通過事先的約定，C++中經常出現的const問題在Java裏已得到了控制。　　　　

我們只能傳遞指向對象的句柄，本地副本永遠不會爲我們自動生成。若希望使用類似C++按值傳遞那樣的技術，可調用clone()，生成自變量的一個本地副 本（儘管clone()的設計依然尚顯粗糙）。根本不存在被自動調用的副本構建器。爲創建一個編譯期的常數值，可象下面這樣編碼：　　

static finalint  = 255 　　

static finalint B = 8 *  　　

(37) 由於安全方面的原因，“應用程序”的編程與“程序片”的編程之間存在着顯著的差異。 　　一個最明顯的問題是程序片不允許我們進行磁盤的寫操作，因爲這樣做會造成從遠程站點下載的、不明來歷的程序可能胡亂改寫我們的磁盤。隨着Java 1.1對數字簽名技術的引用，這一情況已有所改觀。根據數字簽名，我們可確切知道一個程序片的全部作者，並驗證他們是否已獲得授權。Java 1.2會進一步增強程序片的能力。　　

(38) 由於Java在某些場合可能顯得限制太多，所以有時不願用它執行象直接訪問硬件這樣的重要任務。 　　

Java解決這個問題的方案是“固有方法”，允許我們調用由其他語言寫成的函數（目前只支持C和C++）。這樣一來，我們就肯定能夠解決與平臺有關的問題（採用一種不可移植的形式，但那些代碼隨後會被隔離起來）。程序片不能調用固有方法，只有應用程序纔可以。　　

(39) Java提供對註釋文檔的內建支持，所以源碼文件也可以包含它們自己的文檔。 　　

通過一個單獨的程序，這些文檔信息可以提取出來，並重新格式化成HTML。這無疑是文檔管理及應用的極大進步。　　

(40) Java包含了一些標準庫，用於完成特定的任務。 　　

C++則依靠一些非標準的、由其他廠商提供的庫。這些任務包括（或不久就要包括）：　　

a)連網　　

b)數據庫連接（通過JDBC） 　　

c)多線程　　

d)分佈式對象（通過RMI和CORBA） 　　

e)壓縮　　

f)商貿　　

由於這些庫簡單易用，而且非常標準，所以能極大加快應用程序的開發速度。　　

(41) Java 1.1包含了Java Beans標準，後者可創建在可視編程環境中使用的組件。　　　　

由於遵守同樣的標準，所以可視組件能夠在所有廠商的開發環境中使用。由於我們並不依賴一家廠商的方案進行可視組件的設計，所以組件的選擇餘地會加大，並可提高組件的效能。除此之外，Java Beans的設計非常簡單，便於程序員理解；而那些由不同的廠商開發的專用組件框架則要求進行更深入的學習。　　(42) 若訪問Java句柄失敗，就會丟棄一次異常。 　　

這種丟棄測試並不一定要正好在使用一個句柄之前進行。根據Java的設計規範，只是說異常必須以某種形式丟棄。許多C++運行期系統也能丟棄那些由於指針錯誤造成的異常。　　

(43) Java通常顯得更爲健壯，爲此採取的手段如下：  　　

a)對象句柄初始化成null（一個關鍵字）　　

b)句柄肯定會得到檢查，並在出錯時丟棄異常　　

c)所有數組訪問都會得到檢查，及時發現邊界違例情況　　

d)自動垃圾收集，防止出現內存漏洞　　

e)明確、“傻瓜式”的異常控制機制　　

f)爲多線程提供了簡單的語言支持　　

g)對網絡程序片進行字節碼校驗　　

（44）自動內存管理機制 　　

Java程序中所有的對象都是用new操作符建立在內存堆棧上，這個操作符類似於c++的new操作符。下面的語句由一個建立了一個類Read的對象，然後調用該對象的work方法：　　

Readr＝new Read()；　　

r.work()； 　　

語句Readr＝new Read()；在堆棧結構上建立了一個Read的實例。Java自動進行無用內存回收操作，不需要程序員進行刪除。而c十十中必須由程序來釋放內存資源 （就是通過new和delete運算符來分配和釋放內存），增加了程序設計者的負擔。Java中當一個對象不被再用到時，無用內存回收器將給它加上標籤以 示刪除。JAVA裏無用內存回收程序是以線程方式在後臺運行的，利用空閒時間工作。　　

C++有棧內存與堆內存兩種分配方式，程序員可以根據自己的需要來選擇使用哪種內存分配的方式，Java中對象只有堆分配。區別是C++中的堆分配必須程 序員手動釋放，Java通過垃圾收集器自動釋放。其實Java和C++的區別也主要在這裏：對於一個問題，C++實現了幾乎所有的解決方法，程序員可以根 據自己的需要來選擇一種實現方法；而Java只提供一兩種實現方法，但通常是他認爲最容易用最靈活的方法。　　

（45）Java不支持缺省函數參數，而c十十支持  　　

在c中，代碼組織在函數中，函數可以訪問程序的全局變量。c十十增加了類，提供了類算法，該算法是與類相連的函數，c十十類方法與Java類方法十分相 似，然而，由於c十十仍然支持c，所以不能阻止c十十開發人員使用函數，結果函數和方法混合使用使得程序比較混亂。（#ff0000也就是說C＋＋裏邊既 有方法又有函數，我認爲不能作爲等同的概念來把二者混爲一談。）　　

Java不再有函數在Java程序語言中，去掉了程序嚮導語言中最重要的單元--函數(Function)。如果我們以對象嚮導的觀念來看待函數，就可以 瞭解函數在對象嚮導的概念中，是不必要的。在對象嚮導的程序觀念裏，對象的數據纔是真正的主體，而處理對象數據的方法則必須依附在對象內纔有意義。因此， 去掉函數並不表示不再有子程序等模組化程序的概念，相反地，是利用對象中的方法來取代函數，再一次強化對嚮導的發展策略。　　

Java沒有函數，作爲一個比c十十更純的面向對象的語言，Java強迫開發人員把所有例行程序包括在類中，事實上，用方法實現例行程序可激勵開發人員更好地組織編碼。　　

(46) 類型轉換  　　

在c和c十十中有時出現數據類型的隱含轉換，這就涉及了自動強制類型轉換問題。例如，在c十十中可將一浮點值賦予整型變量，並去掉其尾數。Java不支持c十十中的自動強制類型轉換，如果需要，必須由程序顯式進行強制類型轉換。　　

Java是一個嚴格進行類型檢查的程序語言，對於下面這樣的程序，在C++的編譯器上編譯時最多隻會出現警告的信息，但是在Java裏則不予通過：　　

Int aInteger； Double aDouble=2.71828； AInteger = aDouble；　　

雖然這樣的轉型在C++裏是合法的，但是也會造成數據精確度的損失。Java爲了要確定寫程序的人充分地瞭解這點，必須要程序設計強制轉型(type casting)，Java的編譯器纔會接受： 　　

int aInteger；　　

doublea Double=2.71828； 　　

aInteger=(int)aDouble；　　

（47）對C++而言，類庫一旦升級，則必須對應用程序進行重新編譯，否則就無法使用升級後類庫的新增功能。而Java語言在其支持的類庫升級後，只需要直接覆蓋上已有的類庫，不需要重新編譯相應的應用程序。 　　

（48）java不再有structure、union及typedef  　　

事實上，早在C++中就可以去掉C語言中的structure和union等對複雜數據的自定結構類型，因爲類(Class)的定義方式可以完全做到這項 功能。而typedef也是不必要的，一切都用類就可以了。雖然C++這樣的設計是爲了和C語言兼容，但是使用多餘的語言特點不但不必要，而且容易造成對 程序認識的混淆。　　

（49）和C++連接  　　

不管Java是多麼強大，總是有人需要把它和C++連接起來。因爲只要有一個新的程序語言或是軟件開發工具一出現，大家就會問："它是否具有和原有程序庫 連接的能力呢?"也因爲C++語言在電腦界中佔了很重要的地位。大家的問題其實就等於是直接問"它是否可以和C++連接?"。目前在Java中，的確提供 了和C++語言連接的方法，它的做法基本上是先將C++語言所寫的程序建構成動態鏈接函數庫(DynamicLinking Library，DLL)，再由Java程序去調用DLL裏的函數。　　

這種連接的方式，使得DLL中的函數，從Java的眼光看就是一個"方法"。不過因爲這種方法是直接由其他的程序語言所提供，而不是以Java語言所寫的，所以它被稱之爲"原生方法"(NativeMethod)。由於Java Applet一些安全上的限制，所以這種連接外部程序的方法只能用在Java Application內

50）C＋＋的跨平臺問題！ 　　

Java編譯器所生成的代碼可以不基於任何具體的硬件平臺，而是基於一種抽象的機器---虛擬機。而c,c++的源程序要在不同平臺上運行，必須重新編譯。　　

不論是C還是C++都會有依賴平臺與實現的不同比如int的大小。　　

由於C以及C++庫功能基本都是最簡化的。所以基本沒法開發什麼比較有用處的可移植代碼.比如GUI的不同,socket實現的不同等等都制約了C++的可移植性　　

如果你要寫一個完全可以跨平臺編譯的代碼，只能依靠標準庫來寫,那樣這個程序的功能就一定非常有限.當然也有一些跨平臺的庫可以使用.比如GUI方面的 wxWidgets等等　　不過儘管如此.我們還是可以做一些工作來方便移植工作。不要假想平臺的硬件環境,如果你要做一些對字節操作或者位操作的內容， 最好注意big endian以及small endian問題不同的平臺實現不同.不要假想字節長度，int的大小是32,但是不同實現裏面可能有不同的長度.這依賴實現,雖然大多數的實現都使用幾 乎相同的標準。儘量不要操作底層的內容　　基於上面兩條,我們可以得出可移植性最高的代碼，應該是那些不對位或者字節進行直接操作的.不對指針內容進行修 改的,大多調用標準庫函數的.不使用高級模板功能的代碼。　　

Linux下的G++編譯器對標準C++支持得很好。如果做手機遊戲，要用C++，nokia需要Symbian提供的C＋＋開發環 境，smartphone則可以用vs.net提供的。這些環境開發出來的代碼，都是與平臺相關的。然而如果是遊戲的話想跨平臺就用J2ME吧！　　

純c++代碼的話，跨平臺十分簡單，重新編譯就是了。但實際上哪有純c++的軟件？c++算是較底層的語言，所以用它寫軟件難免要出現平臺相關的東西，這就是移植時要修改的重點。　　

總的來說，跨平臺性還是不錯的　　C++的跨平臺就只有兩點。　　

1，遵循標準。特定的平臺除外。　　

2，禁用reinterpret_cast和C風格的強制轉換。 　　#ff0000當然上邊說的兩點只是針對與跨編譯器。但是，如果說 OS 平臺，那麼基本所有功能都是與平臺相關的，包括網絡、文件系統等顯而易見的功能，以及 IO、內存分配等那麼不顯而易見的。要讓 C++ 代碼跨平臺，我們只能通過包裝庫來掩蓋不同平臺的區別，這樣，基於這些包裝庫的 C++ 程序才能在【源碼級別】實現“跨平臺”。　　

跨平臺當然要注意避免使用依賴系統的操作：　　

1. 基本類型的長度以及相對這些類型的操作,如wchar_t。　　

2. 字符操作，特別是漢字類的寬字符。　　

3. IO操作　　另外不同編譯器對C++的實現是不同的，這就要編譯一下試驗一下，不過這種問題都很容易修改的！　　

我感覺越涉及到底層的東西，越難實現跨平臺。不同的硬件體系結構，不同的編譯器和編譯環境，都給跨平臺帶來了很多的困難。如果要寫出跨平臺的程序，儘量使用跨平臺的函數庫（STL+boost），儘量避免涉及到底層的編程。　　

c如果涉及到跨操作系統的東西，可以使用ace，這個東西是對系統的封裝的程序包。還是不錯的（備註：什麼是ACE？ace的全名是adaptive communication environment(可適應的通信環境)，它是一個通信中間件，具有良好的可移植性；winsock只是一個socket編程的api庫，僅僅提供一組api給你調用，但是ace還提供了一個性能優異的框架，也就是說，ace已經把底層的socket api包裝成一個具有邏輯性的框架，你只需要按照調用規範去使用就可以獲得較好的性能）　　

在應用表示層上做到跨平臺,低層實現上或多或少都是與平臺相關的. （

八）C＋＋與JAVA區別小總結： 　　

事實上，constant和typedef這兩條語句包含了#define語句的作用。現在，結構和聯合已經被Java的類所代替。刪除這些特性的原因 是:由於其希望維持與C語言的向後兼容性，C ++的語言規範包含了大量冗餘。比如，類實際上就已經包括了結構和聯合的作用，因此這兩種數據結構完全可以取消。關於#define語句，Java語言規 範的制訂者認爲:儘管該語句的出發點是爲了增強程序的可讀性，但實際效果卻恰恰相反，它常常導致難讀的代碼，故應該予以取消。Java不再支持獨立函數， 因此任何函數都必須封裝到某個類中。由於人們普遍認爲， C++所用的超類是非常不穩定的，因此Java拋棄了C++中的多繼承並代之以接口。Java的接口指的是，在別的類看來一個類所能實現的方法。它所顯示 的只是一個類的方法或常量和變量，而不是這個類的全部結構。　　

最後，Java還取消了C++中的GOTO語句、操作符重載、自動類型轉換及指針數據類型。 GOTO語句引起的爭議已經有很多年了，可一直陰魂不散，這跟某些程序員對該語句一直情有獨鍾有關。C++仍然支持數據類型的自動轉換，但Java要求編 程人員顯式實現數據類型之間的轉換。自動數據類型轉換使得兩個數據類型互不兼容的變量可以相互賦值，而不需要給出顯式說明。這有時會導致一些問題，其中最 常見的是精確度損失。比方說，如果把一個帶符號的32位整數賦給一個無符號整數，則所有的結果均爲正數。Java的設計者們認爲這很容易引起程序錯誤，從 而決定不支持這種轉換方式。 

到此已經全部結束．全劇終