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了，我們盡可能的要向資料的準確性和版權性付相應的責任?！ ?/p>
這樣一方面對自己有很大的提高，另一方面只有這樣才能給廣大同仁提供更準確和更豐富的信息內容，大家才能共同提高和進步.
（二）我學習二者的個人感受：
我最初學習的是Java，后來又學習C＋＋，雖然二者都是面向對象的語言(C＋＋是半面向對象語言)，但是在C＋＋的學習過程中，C＋＋“幾乎完全”沒有規則性或者超靈活性的語法讓一個之前學過JAVA語言的人感到很不爽！！！
Java確實是個很不錯的東西，尤其是其背后有強大的類庫做支撐，用起來感覺那是相當的爽，但速度也確實是個問題。幸好現在的Java語言，其執行方式已經不僅僅是解釋執行方式了，即時編譯器（JITC、just-in-time compiler）技術和原型編譯技術的出現大大提高了JAVA的運行效率?！ ?/p>
C＋＋靈活無比，但純屬高級玩具或者高深的九陽神功，假如玩不好，就把自己繞進去，如練奇門遁甲一般走火入魔，如果玩好了，那可就是強大致極啊！
C++在設計時因為必須完全兼容C語言又必須提供所有的面向對象特性所以最終它的結構變得特別復雜，當引入泛型編程STL（標準模板庫）之后顯得更加復雜。
Java是在C++的基礎上開發出來的，比C++簡化很多，容易使用很多，但是在有些方面特別是泛型方面明顯沒有C++使用起來靈活。在某些功能上也稍遜于C++，例如對于圖像的剪切等方面的技術。
（三）個人建議：所以我認為如果先學習C＋＋再來學習JAVA會容易很多。先學C＋＋就好比一開始你是穿著褲子進行110米跨欄，再學習JAVA就好比你是穿著褲衩進行跨欄，沒有那么多的亂七八糟的東西或者越弄越復雜的東西，顯得干凈利落，在增加了多個新特性后又不失功能的強大。要不有人曾經打比方說：Java就是C++這個超級重裝騎兵脫下盔甲下了馬換上短劍拿起輕盾再背一把可替換的AK47?！ ?/p>
當然，如果有人想學習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++的固有缺陷?！ ?/p>
用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的基本區別?！ ?/p>
這些不同之處大致分為三類：
1)JAVA不支持的C＋＋特性?！ ?/p>
2)JAVA的獨特之處?！ ?/p>
3)C＋＋和JAVA都有但是卻不相同的特性。
詳細討論這三類： 1)JAVA摒棄的C＋＋內容.
有些C＋＋的內容特性JAVA并不再支持。在某些情況下，一個特殊的C＋＋特性和JAVA的運行環境不相關。另一些情況下，JAVA的設計者舍棄了C＋＋中某些重復的內容。還有一些情況是，出于對Internet applet的運行安全問題的考慮，JAVA不再支持某些C＋＋的特點?！ ?/p>
C＋＋和JAVA之間的最大不同可能是JAVA不再支持指針。指針使C＋＋語言成為功能最強大最重要的一種編程語言。但同時指針在使用不正確的情況下也是C＋＋中最危險的部分。JAVA不支持指針的原因主要有兩點：
(1)指針本身就非常不安全。例如，使用C＋＋的狀態指針，可以訪問程序代碼和數據段外的內存地址，一個惡意程序可以利用這個特點破壞系統，完成非法訪問(如獲取口令等)，或者違反安全限制?！ ?2)即使指針可以被限制在JAVA的運行系統中(這在理論上是可行的，因為JAVA程序是解釋執行的)，JAVA的設計者相信它們仍然是麻煩所在?！ ?/p>
注意：既然JAVA中不存在指針，那么也不存在－>操作符。這里還有一些非常重要的”省略”：
a)JAVA不再支持操作符重載。
操作符重載在某些情況下造成類C＋＋程序的含糊不清，JAVA的設計人員感覺它帶來的麻煩要比它帶來的好處多。
b)JAVA不再包含結構或者聯合。在可以完全包含它們的類出現后，這些結構成為冗余部分。
c)JAVA不再包括預處理，也不再支持預處理指令。預處理在C＋＋語言中已經不如C中那么重要，JAVA的設計者認為是徹底消除預處理的時候了?！ ?/p>
d)JAVA不支持自動的類型轉換，因為這種類型轉換導致精度降低例如當從長整型轉換為整型時，必須顯示強制執行類型轉換?！ ?/p>
e)在JAVA中的代碼必須封裝在一個或者多個類中。因此JAVA中不再包含所謂的全局變量或者全局函數?！ ?/p>
f)JAVA不再允許默認參數。在C＋＋中，當過程調用時存在沒有對應值的參數時可以使用一個預先指定的值。JAVA不再允許這樣的操作?！ ?/p>
g)JAVA不支持多繼承，即不允許一個子類繼承多個父類。
h)雖然JAVA支持構造函數，但是不再支持析構函數[/b]。但是，JAVA增加了finalize( )函數。
i)JAVA不再支持typedef.
j)在JAVA中不再可能聲明無符號整數?！ ?/p>
k)JAVA不再支持goto語句?！ ?/p>
l)JAVA不再有delete操作符?！ ?/p>
m)JAVA中的<>不再重載I/O操作?！ ?/p>
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字符增強了代碼的可移植性?！ ?/p>
7)JAVA增加了>>>操作，完成無符號的右移。
8)除支持單行和多行的注釋之外，JAVA增加了第三種注釋方法：文檔注釋。文檔注釋以結尾?！ ?)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中，訪問說明符僅應用于其限定的聲明中?！ ?/p>
3)C＋＋支持異常處理，這與JAVA類似，但是在C＋＋中無需捕捉一個被引發的異常。
（七）JAVA和C＋＋的區別詳細介紹（對部分知識點的擴充）
(1) JAVA的運行速度（JAVA最大的障礙在于速度）
解釋過的Java要比C的執行速度慢上約20倍。無論什么都不能阻止Java語言進行編譯。當時剛剛出現了一些準實時編譯器，它們能顯著加快速度。當然， 我們完全有理由認為會出現適用于更多流行平臺的純固有編譯器，但假若沒有那些編譯器，由于速度的限制，必須有些問題是Java不能解決的?！ ?/p>
許多企業的應用開發人員非常喜愛Java的語言特性，但是在開發重要系統時，語言特性和執行效率之間的抉擇往往令人傷透腦筋。在關鍵計算中，用戶可能并不 在乎數據如何壓縮或者運行的延遲關系如何設置，但是對程序的運行速度卻非常重視，這使廠商將Java的編譯策略開發放在了首位?，F在的Java語言，其執 行方式已經不僅僅是解釋執行方式了，即時編譯器（JITC、just-in-time compiler）技術和原型編譯技術已經被許多廠家采用，包括Sun、IBM、Oracle以及Netscape等公司在內的技術提供商正在利用這些技 術逐步提高Java的執行速度，其中IBM公司早已將Java虛擬機（JVM，JavaVirtual Machine）、操作系統和硬件的特性有機的結合在一起，非常有效地提高了Java的執行效率?！ ?/p>
(2)JAVA所有東西都必須置入一個類.
Java是完全面向對象的語言，它不再支持C++程序時所使用的過程式的設計方法，所有函數和變量部必須是類的一部分。除了基本數據類型（例如整型、字符型、布爾型等）之外，其他的數據對Java來說都是對象，包括數組。
對象將數據和方法結合起來，把它們封裝在類中，這樣每個對象都可實現自己的特點和行為。JAVA不存在全局函數或者全局數據。如果想獲得與全局函數等價的 功能，可考慮將static方法和static數據置入一個類里。而c++允許將函數和變量定義為全局的。此外，Java中取消了c／c++中的結構和聯 合、枚舉這一類的東西，一切只有“類”（Class），消除了不必要的麻煩?！ ?/p>
JAVA的語法其實是參照c++的語法誕生的，但是她去除了c++中的多重繼承，指針，delete等難于掌握的技術，為了便于移植和安全性，java采用了純面向對象技術，即使是主函數public static void main(String[] args）{}也要放在主類中，可以看出和C＋＋的明顯區別?！ ?/p>
(3) 在Java中，類定義采取幾乎和C++同樣的形式。
但沒有標志結束的分號。沒有類聲明，只有類定義?！?/p>
(4) Java中沒有作用域范圍運算符“::”.
Java利用點號做所有的事情，但可以不用考慮它，因為只能在一個類里定義元素。即使那些方法定義，也必須在一個類的內部，所以根本沒有必要指定作用域的范圍。我們注意到的一項差異是對static方法的調用:使用ClassName.methodName()?！ ?/p>
除此以外，package（包）的名字是用點號建立的，并能用import關鍵字實現C++的“#include”的一部分功能?！ ?/p>
例如下面這個語句：
import java.awt.*;
#include并不直接映射成import，但在使用時有類似的感覺。若想使用另一個庫里的類，只需使用import命令，并指定庫名即可。不存在類似于預處理機的宏?！ ?/p>
c／c十十在編譯過程中都有一個預編譯階段，即眾所周知的預處理器。預處理器為開發人員提供了方便，但增加了編譯的復雜性。JAVA虛擬機沒有預處理器， 但它提供的引入語句(import)與c十十預處理器(#include)的功能類似。（注意：只是類似而已） (5)JAVA中沒有預處理功能的詳細介 紹
不再有#define、#include等預處理程序(Preprocessor)的功能。C++語言很重要的一個特點就是它的預處理程序。有些其他程序 語言雖然也加入了#include的功能，但是還是欠缺處理宏(Macro)的能力。#define的功能在Java中我們可以用定義常數 (constant)的方式來取代，而#include在Java中是不需要的，因為在Java中程序在執行時，會把類型數據記錄在對象實體之中，我們不 需要靠一些標頭文件(header file)來知道我們使用的對象或數值是屬于什么數據類型?！ ?/p>
如果你使用C++語言時，只使用預處理程序的#include和#define功能的話，那么你大概不會覺得Java這樣的設計對你產生什么樣的困擾，但是如果你是使用C++語言預處理程序中宏功能的高手，你可能會覺得很不方便，進而懷疑Java如此設計的意義何在?！ ?/p>
使用預處理程序雖然可以很方便地達到許多功能，但是站在軟件工程的角度上看，對整個軟件的維護其實是很不利的。由于C++語言中預處理程序的功能太過強 大，厲害的程序設計高手常會自行開發一套只有自己看的懂的宏語言，一旦整個軟件要交給其他人去維護，后繼者很難在短時間內了解前一個人所寫下的宏功能，增 加軟件開發時團隊工作及日后維護的困難度。
另外一點則是C++語言的編譯器所看到的程序代碼，其實和程序設計者看到的程序代碼是不同的。程序設計者看到的是尚未經過預處理程序處理過的程序代碼，而 編譯器看到的則是預處理程序處理過的程序代碼，一旦交給預處理程序處理的宏內容有誤，編譯器產生的錯誤信息將不會是程序設計師所預料的。而這一點自然也增 加了程序在排錯時的困難度?！ ?/p>
預處理程序的存在也造成了閱讀程序的不便。如果你想使用別人已經完成的C++語言程序，那么通常你不但要閱讀他所寫下的文件，還必須一并查閱上文件，才能了解其程序的全貌。如果換成是Java程序，只要查看java的程序文件就夠了?！ ?/p>
(6)與C++類似，Java含有一系列“主類型”（Primitive type），以實現更有效率的訪問 在Java中，這些類型包括boolean，char，byte，short，int，long，float以及double.所有主類型的大小都是 固有的，且與具體的機器無關（考慮到移植的問題）。這肯定會對性能造成一定的影響，具體取決于不同的機器。對類型的檢查和要求在Java里變得更苛刻?！?
例如：
條件表達式只能是boolean（布爾）類型，不可使用整數。
必須使用象X+Y這樣的一個表達式的結果；不能僅僅用“X+Y”來實現“副作用”?！ ?/p>
(7)Java靜態引用的字串會自動轉換成String對象。[/b][/color] java和C及C++不同，沒有獨立的靜態字符數組字串可供使用?！ ?/p>
c和c十十不支持字符串變量，在c和c十十程序中使用Null終止符代表字符串的結束，在Java中字符串是用類對象(string和stringBuffer)來實現的，這些類對象是Java語言的核心，用類對象實現字符串有以下幾個優點：
a)在整個系統中建立字符串和訪問字符串元素的方法是一致的；
b)Java字符串類是作為Java語言的一部分定義的，而不是作為外加的延伸部分；
c)Java字符串執行運行時檢查，可幫助排除一些運行時發生的錯誤；
d)可對字符串用“十”號進行連接操作。
(8) Java增添了三個右移位運算符“>>>”，具有與“邏輯”右移位運算符類似的功用，可在最末尾插入零值?！?gt;>”則會在移位的同時插入符號位（即“算術”移位）。
(9) 盡管表面上類似，但與C++相比，Java數組采用的是一個頗為不同的結構，并具有獨特的行為。就是說Java提供數據下標越界檢查，而C++沒有提供.
有一個只讀的length成員，通過它可知道數組有多大。而且一旦超過數組邊界，運行期檢查會自動丟棄一個異常。所有數組都是在內存“堆”里創建的，我們 可將一個數組分配給另一個（只是簡單地復制數組句柄）。數組標識符屬于第一級對象，它的所有方法通常都適用于其他所有對象。
(10) 對于所有不屬于主類型的對象，都只能通過new命令創建 和C++不同，Java沒有相應的命令可以“在堆棧上”創建不屬于主類型的對象。所有主類型都只 能在堆棧上創建，同時不使用new命令。所有主要的類都有自己的“封裝（器）”類，所以能夠通過new創建等價的、以內存“堆”為基礎的對象（主類型數組 是一個例外：它們可象C++那樣通過集合初始化進行分配，或者使用new).
(11) Java中不必進行提前聲明方法。
若想在定義前使用一個類或方法，只需直接使用它即可——編譯器會保證使用恰當的定義。所以和在C++中不同，我們不會碰到任何涉及提前引用的問題?！ ?/p>
(12) Java用包代替了命名空間。
由于將所有東西都置入一個類，而且由于采用了一種名為 “封裝”的機制，它能針對類名進行類似于命名空間分解的操作，所以命名的問題不再進入我們的考慮之列。數據包也會在單獨一個庫名下收集庫的組件。我們只需簡單地“import“（導入）一個包，剩下的工作會由編譯器自動完成?！ ?/p>
(13) 被定義成類成員的對象句柄會自動初始化成null。
對基本類數據成員的初始化在Java里得到了可靠的保障。若不明確地進行初始化，它們就會得到一個默認值（零或等價的值）可對它們進行明確的初始化（顯式 初始化）：要么在類內定義它們，要么在構建器中定義。采用的語法比C++的語法更容易理解，而且對于static和非static成員來說都是固定不變 的。我們不必從外部定義static成員的存儲方式，這和C++是不同的?！ ?/p>
(14) 在Java里，沒有象C和C++那樣的指針。
用new創建一個對象的時候，會獲得一個引用（或者叫句柄） 例如： Strings = new String("helloworld");
然而，C++引用在創建時必須進行初始化，而且不可重定義到一個不同的位置。但Java引用并不一定局限于創建時的位置。它們可根據情況任意定義，這便消除了對指針的部分需求。
在C和C++里大量采用指針的另一個原因是為了能指向任意一個內存位置（這同時會使它們變得不安全，也是Java不提供這一支持的原因）。指針通常被看作 在基本變量數組中四處移動的一種有效手段。Java允許我們以更安全的形式達到相同的目標。解決指針問題的終極方法是“固有方法”。將指針傳遞給方法時， 通常不會帶來太大的問題，因為此時沒有全局函數，只有類。而且我們可傳遞對對象的引用。Java語言最開始聲稱自己“完全不采用指針！”但隨著許多程序員 都質問沒有指針如何工作？于是后來又聲明“采用受到限制的指針”（有人管它叫隱藏了的指針）。大家可自行判斷它是否“真”的是一個指針。但不管在何種情況 下，都不存在指針“算術”?！ ?/p>
JAVA語言讓編程者無法找到指針來直接訪問內存無指針，并且增添了自動的內存管理功能，從而有效地防止了c／c++語言中指針操作失誤，如野指針所造成 的系統崩潰。但也不是說JAVA沒有指針，虛擬機內部還是使用了指針，只是外人不得使用而已。這有利于Java程序的安全?！ ?/p>
其實，取消指針(Pointer)這樣數據類型，可能會讓許多熟悉C++語言的程序設計師大吃一驚。在C++語言里，靈活地運用指針是許多程序設計師的得 意之作，但是占整個除錯時間最久的也是指針的問題。配合上C++對內存管理的態度，程序設計師必須要自己去追蹤自己向系統要到的內存，最后確實地交還給系 統，并且在使用指針時，要小心翼翼地注意不要跨過合法的記憶空間，造成Segmentation Fault或General Protection Fault之類的問題。
Java去掉了指針類型，并不表示程序設計師在開發高級數據結構，像堆棧(stack)、隊列(queue)、二元樹(binarytree)時，都必須要像在傳統Basic上，利用大范圍的數組來自行模擬系統內存，自行建構類似指針的表示方式?！ ?/p>
相反地，Java提供了和Lisp語言中相似的Reference類型，通過Reference去讀取配置到的內存內容，可以確保不會去讀取到不屬于自己 的內存空間，而另一方面，程序的執行系統也可以動態地去做內存垃圾回收的工作，將沒有被reference參考到的內存空間回收給系統使用。 ff(15) Java提供了與C++類似的“構建器”（Constructor）?！ ?/p>
如果不自己定義一個，就會獲得一個默認構建器。而如果定義了一個非默認的構建器，就不會為我們自動定義默認構建器。這和C++是一樣的。注意沒有復制構建器，因為所有自變量都是按引用傳遞的（注意：而C＋＋中對象可由值或引用傳遞。）
(16) Java中沒有“破壞器”（Destructor）。
變量不存在“作用域”的問題。一個對象的“存在時間”是由對象的存在時間決定的，并非由垃圾收集器決定。有個finalize()方法是每一個類的成員， 它在某種程度上類似于C++的“破壞器（就是析構函數的使用）”。但finalize()是由垃圾收集器調用的，而且只負責釋放“資源”（如打開的文件、 套接字、端口、URL等等）。如需在一個特定的地點做某樣事情，必須創建一個特殊的方法，并調用它，不能依賴finalize()。而在另一方面，C++ 中的所有對象都會（或者說“應該”）破壞，但并非Java中的所有對象都會被當作“垃圾”收集掉。由于Java不支持破壞器的概念，所以在必要的時候，必 須謹慎地創建一個清除方法。而且針對類內的基礎類以及成員對象，需要明確調用所有清除方法。
(17) Java具有方法“重載”機制，它的工作原理與C++函數的重載載幾乎是完全相同的?！ ?/p>
(18) Java不支持默認自變量。
(19) Java中沒有goto語句。
Java一方面移除了Goto的功能，它采取的無條件跳轉機制是“break 標簽”或者“continue 標簽” ，另一方面同時擴大了break和continue的功能，可以允許多層循環的break或continue。如此一來不但避免了濫用Goto的可能性，同時也保存下Goto的好處?！ ?/p>
“可怕”的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的判斷來達成?！ ?/p>
(20) Java采用了一種單根式的分級結構，因此所有對象都是從根類Object統一繼承的。
而在C++中，我們可在任何地方啟動一個新的繼承樹，所以最后往往看到包含了大量樹的“一片森林”。在Java中，我們無論如何都只有一個分級結構。盡管 這表面上看似乎造成了限制，但由于我們知道每個對象肯定至少有一個Object接口，所以往往能獲得更強大的能力。C++目前似乎是唯一沒有強制單根結構 的唯一一種OO（面向對象）語言?！ ?/p>
(21) Java沒有模板或者參數化類型的其他形式。
它提供了一系列集合：Vector（向量），Stack（堆棧）以及Hashtable（散列表），用于容納Object引用。利用這些集合，我們的一系列要求可得到滿足。但這些集合并非是為實現象C++“標準模板庫”（STL）那樣的快速調用而設計的。Java 1.2中的新集合顯得更加完整，但仍不具備正宗模板那樣的高效率使用手段。
(22)“垃圾收集”意味著在Java中出現內存漏洞的情況會少得多，但也并非完全不可能?！ ?/p>
若調用一個用于分配存儲空間的固有方法，垃圾收集器就不能對其進行跟蹤監視?！ ?/p>
然而，內存漏洞和資源漏洞多是由于編寫不當的finalize()造成的，或是由于在已分配的一個塊尾釋放一種資源造成的（“破壞器”在此時顯得特別方 便）。垃圾收集器是在C++基礎上的一種極大進步，使許多編程問題消彌于無形之中。但對少數幾個垃圾收集器力有不逮的問題，它卻是不大適合的。但垃圾收集 器的大量優點也使這一處缺點顯得微不足道?！ ?/p>
(23) Java內建了對多線程的支持。
利用一個特殊的Thread類，我們可通過繼承創建一個新線程（放棄了run()方法）。若將synchronized（同步）關鍵字作為方法的一個類型 限制符使用，相互排斥現象會在對象這一級發生。在任何給定的時間，只有一個線程能使用一個對象的synchronized方法。在另一方面，一個 synchronized方法進入以后，它首先會“鎖定”對象，防止其他任何synchronized方法再使用那個對象。只有退出了這個方法，才會將對 象“解鎖”。在線程之間，我們仍然要負責實現更復雜的同步機制，方法是創建自己的“監視器”類。遞歸的synchronized方法可以正常運作。若線程 的優先等級相同，則時間的“分片”不能得到保證?！ ?24)我們不是象C++那樣控制聲明代碼塊，而是將訪問限定符（public，private和 protected）置入每個類成員的定義里。
JAVA中若未規定一個“顯式”（明確的）限定符，就會默認為“友好的”（friendly）。這意味著同一個包里的其他元素也可以訪問它（相當于它們都成為 C++的“friends”——朋友），但不可由包外的任何元素訪問。而在C＋＋中如果未規定就會默認為私有的private?！ ?/p>
類——以及類內的每個方法——都有一個訪問限定符，決定它是否能在文件的外部“可見”private關鍵字通常很少在Java中使用，因為與排斥同一個包 內其他類的訪問相比，“友好的”訪問通常更加有用?！ ∪欢?#xff0c;在多線程的環境中，對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++的編譯器來說也只是一 種建議?！ ?/p>
(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（編譯器會自動檢查）?！ ?/p>
(29) Java提供了一個interface關鍵字，它的作用是創建抽象基礎類的一個等價物?！ ?/p>
在其中填充抽象方法，且沒有數據成員。這樣一來，對于僅僅設計成一個接口的東西，以及對于用extends關鍵字在現有功能基礎上的擴展，兩者之間便產生 了一個明顯的差異。不值得用abstract關鍵字產生一種類似的效果，因為我們不能創建屬于那個類的一個對象。一個abstract（抽象）類可包含抽 象方法（盡管并不要求在它里面包含什么東西），但它也能包含用于具體實現的代碼。因此，它被限制成一個單一的繼承。通過與接口聯合使用，這一方案避免了對 類似于C++虛擬基礎類那樣的一些機制的需要?！ ?/p>
為創建可進行“例示”（即創建一個實例）的一個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 調用的等價方式）。這些優化工作是由編譯器完成的?！ ?/p>
(31) Java不提供多重繼承機制（MI），至少不象C++那樣做。
與protected類似，MI表面上是一個很不錯的主意，但只有真正面對一個特定的設計問題時，才知道自己需要它。由于Java使用的是“單根”分級結構，所以只有在極少的場合才需要用到MI。interface關鍵字會幫助我們自動完成多個接口的合并工作?！ ?/p>
c++支持多重繼承，這是c++的一個特征，它允許多父類派生一個類。盡管多重繼承功能很強，但使用復雜，而且會引起許多麻煩，編譯程序實現它也很不容 易。Java不支持多重繼承，但允許一個類繼承多個接口(extends+implement)，實現了c++多重繼承的功能，又避免了c++中的多重繼 承實現方式帶來的諸多不便。
所謂的interface基本上定義了一個類的對外溝通的方法原型，以及類內部的常數，和多重繼承不同之處在于interface并不會定義類方法的內容，以及類中的變量數據?！ ?/p>
(32) 運行期的類型標識功能與C++極為相似。
例如，為獲得與句柄X有關的信息，可使用下述代碼：
X.getClass().getName();
為進行一個“類型安全”的緊縮造型，可使用： derived d = (derived)base;
這與舊式風格的C造型是一樣的。編譯器會自動調用動態造型機制，不要求使用額外的語法。盡管它并不象C++的“new casts”那樣具有易于定位造型的優點，但Java會檢查使用情況，并丟棄那些“異?！?#xff0c;所以它不會象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++則沒有如此方便的機制?！ ?/p>
java丟棄一個錯誤的異常后，不是象C++那樣在運行期間調用一個函數，Java異常規范是在編譯期間檢查并執行的。除此以外，被取代的方法必須遵守那 一方法的基礎類版本的異常規范：它們可丟棄指定的異常或者從那些異常衍生出來的其他異常。這樣一來，我們最終得到的是更為“健壯”的異?？刂拼a。
(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里已得到了控制?！ ?/p>
我們只能傳遞指向對象的句柄，本地副本永遠不會為我們自動生成。若希望使用類似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。這無疑是文檔管理及應用的極大進步?！ ?/p>
(40) Java包含了一些標準庫，用于完成特定的任務。
C++則依靠一些非標準的、由其他廠商提供的庫。這些任務包括（或不久就要包括）：
a)連網
b)數據庫連接（通過JDBC）
c)多線程
d)分布式對象（通過RMI和CORBA）
e)壓縮
f)商貿
由于這些庫簡單易用，而且非常標準，所以能極大加快應用程序的開發速度。
(41) Java 1.1包含了Java Beans標準，后者可創建在可視編程環境中使用的組件。
由于遵守同樣的標準，所以可視組件能夠在所有廠商的開發環境中使用。由于我們并不依賴一家廠商的方案進行可視組件的設計，所以組件的選擇余地會加大，并可提高組件的效能。除此之外，Java Beans的設計非常簡單，便于程序員理解；而那些由不同的廠商開發的專用組件框架則要求進行更深入的學習。 (42) 若訪問Java句柄失敗，就會丟棄一次異常。
這種丟棄測試并不一定要正好在使用一個句柄之前進行。根據Java的設計規范，只是說異常必須以某種形式丟棄。許多C++運行期系統也能丟棄那些由于指針錯誤造成的異常?！ ?/p>
(43) Java通常顯得更為健壯，為此采取的手段如下：?
a)對象句柄初始化成null（一個關鍵字）
b)句柄肯定會得到檢查，并在出錯時丟棄異?！ ?/p>
c)所有數組訪問都會得到檢查，及時發現邊界違例情況
d)自動垃圾收集，防止出現內存漏洞
e)明確、“傻瓜式”的異?？刂茩C制
f)為多線程提供了簡單的語言支持
g)對網絡程序片進行字節碼校驗
（44）自動內存管理機制
Java程序中所有的對象都是用new操作符建立在內存堆棧上，這個操作符類似于c++的new操作符。下面的語句由一個建立了一個類Read的對象，然后調用該對象的work方法：
Readr＝new Read()；
r.work()；
語句Readr＝new Read()；在堆棧結構上建立了一個Read的實例。Java自動進行無用內存回收操作，不需要程序員進行刪除。而c十十中必須由程序來釋放內存資源 （就是通過new和delete運算符來分配和釋放內存），增加了程序設計者的負擔。Java中當一個對象不被再用到時，無用內存回收器將給它加上標簽以 示刪除。JAVA里無用內存回收程序是以線程方式在后臺運行的，利用空閑時間工作?！ ?/p>
C++有棧內存與堆內存兩種分配方式，程序員可以根據自己的需要來選擇使用哪種內存分配的方式，Java中對象只有堆分配。區別是C++中的堆分配必須程 序員手動釋放，Java通過垃圾收集器自動釋放。其實Java和C++的區別也主要在這里：對于一個問題，C++實現了幾乎所有的解決方法，程序員可以根 據自己的需要來選擇一種實現方法；而Java只提供一兩種實現方法，但通常是他認為最容易用最靈活的方法?！ ?/p>
（45）Java不支持缺省函數參數，而c十十支持?
在c中，代碼組織在函數中，函數可以訪問程序的全局變量。c十十增加了類，提供了類算法，該算法是與類相連的函數，c十十類方法與Java類方法十分相 似，然而，由于c十十仍然支持c，所以不能阻止c十十開發人員使用函數，結果函數和方法混合使用使得程序比較混亂。（#ff0000也就是說C＋＋里邊既 有方法又有函數，我認為不能作為等同的概念來把二者混為一談。）
Java不再有函數在Java程序語言中，去掉了程序向導語言中最重要的單元--函數(Function)。如果我們以對象向導的觀念來看待函數，就可以 了解函數在對象向導的概念中，是不必要的。在對象向導的程序觀念里，對象的數據才是真正的主體，而處理對象數據的方法則必須依附在對象內才有意義。因此， 去掉函數并不表示不再有子程序等模組化程序的概念，相反地，是利用對象中的方法來取代函數，再一次強化對向導的發展策略?！ ?/p>
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語言兼容，但是使用多余的語言特點不但不必要，而且容易造成對 程序認識的混淆?！ ?/p>
（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,但是不同實現里面可能有不同的長度.這依賴實現,雖然大多數的實現都使用幾 乎相同的標準。盡量不要操作底層的內容 基于上面兩條,我們可以得出可移植性最高的代碼，應該是那些不對位或者字節進行直接操作的.不對指針內容進行修 改的,大多調用標準庫函數的.不使用高級模板功能的代碼?！ ?/p>
Linux下的G++編譯器對標準C++支持得很好。如果做手機游戲，要用C++，nokia需要Symbian提供的C＋＋開發環 境，smartphone則可以用vs.net提供的。這些環境開發出來的代碼，都是與平臺相關的。然而如果是游戲的話想跨平臺就用J2ME吧！
純c++代碼的話，跨平臺十分簡單，重新編譯就是了。但實際上哪有純c++的軟件？c++算是較底層的語言，所以用它寫軟件難免要出現平臺相關的東西，這就是移植時要修改的重點?！ ?/p>
總的來說，跨平臺性還是不錯的 C++的跨平臺就只有兩點?！ ?/p>
1，遵循標準。特定的平臺除外?！ ?/p>
2，禁用reinterpret_cast和C風格的強制轉換。 #ff0000當然上邊說的兩點只是針對與跨編譯器。但是，如果說 OS 平臺，那么基本所有功能都是與平臺相關的，包括網絡、文件系統等顯而易見的功能，以及 IO、內存分配等那么不顯而易見的。要讓 C++ 代碼跨平臺，我們只能通過包裝庫來掩蓋不同平臺的區別，這樣，基于這些包裝庫的 C++ 程序才能在【源碼級別】實現“跨平臺”?！ ?/p>
跨平臺當然要注意避免使用依賴系統的操作：
1. 基本類型的長度以及相對這些類型的操作,如wchar_t。
2. 字符操作，特別是漢字類的寬字符?！ ?/p>
3. IO操作 另外不同編譯器對C++的實現是不同的，這就要編譯一下試驗一下，不過這種問題都很容易修改的！
我感覺越涉及到底層的東西，越難實現跨平臺。不同的硬件體系結構，不同的編譯器和編譯環境，都給跨平臺帶來了很多的困難。如果要寫出跨平臺的程序，盡量使用跨平臺的函數庫（STL+boost），盡量避免涉及到底層的編程?！ ?/p>
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的接口指的是，在別的類看來一個類所能實現的方法。它所顯示 的只是一個類的方法或常量和變量，而不是這個類的全部結構?！ ?/p>
最后，Java還取消了C++中的GOTO語句、操作符重載、自動類型轉換及指針數據類型。 GOTO語句引起的爭議已經有很多年了，可一直陰魂不散，這跟某些程序員對該語句一直情有獨鐘有關。C++仍然支持數據類型的自動轉換，但Java要求編 程人員顯式實現數據類型之間的轉換。自動數據類型轉換使得兩個數據類型互不兼容的變量可以相互賦值，而不需要給出顯式說明。這有時會導致一些問題，其中最 常見的是精確度損失。比方說，如果把一個帶符號的32位整數賦給一個無符號整數，則所有的結果均為正數。Java的設計者們認為這很容易引起程序錯誤，從 而決定不支持這種轉換方式。
總結
以上是生活随笔為你收集整理的java和C++的区别的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： linux 编译C++错误整理
- 下一篇： 面试题总结14 动态规划