維基百科

Java和C++的對照

本條目為Java語言和C++語言之間的比較。

設計目標

編輯

C++和Java語言之間的不同可以追溯到它們各自的傳統，它們有着不同的設計目標。

  • C++ 被設計成主要用在系統性應用程式設計上的語言，對C語言進行了擴展。基於C語言這個為執行效率設計的過程式程式設計語言，C++添加了對這些特性的支援：靜態類型的物件導向程式設計的支援、異常處理、RAII以及泛型。另外它還添加了一個包含泛型容器和演算法的C++庫函數。
  • Java 最初被設計用來支援網絡計算。它依賴一個虛擬機來保證安全和可移植性。Java包含一個可延伸的庫以提供一個完整的下層平台抽象。Java是一種靜態面向對象語言，它使用的語法和C++類似，但並不與之相容。為了使更多的人到使用更易用的語言，它進行了全新的設計。

不同的開發目標導致C++和Java這兩種語言的不同的規則以及設計上的平衡點不同。如下列出不同點：

C++ Java
除了一些比較少見的情況之外和C語言相容 沒有對任何之前的語言向前相容。但在語法上受C/C++的影響很大
一次編寫多處編譯 一次編寫多處運行
允許過程式程式設計、面向對象程式設計、泛型程式設計、函數式程式設計 必須使用面向對象的程式設計方式
允許直接呼叫原生的系統庫 要通過JNI調用，或者JNA
能直接使用底層系統介面 在一個保護模式下的虛擬機中運行
只提供物件的類型和類型名 是反射的，允許元程式設計和運行時的動態生成代碼
有多種二進制相容標準（例如：微軟和Itanium/GNU） 一種二進制相容標準，允許運行時庫的正確性檢查
可選的自動邊界檢查.（例如：vector 和 string 這兩個容器的 at() 方法） 一般都有做邊界檢查。HotSpot (java)（Sun 的虛擬機實現）可以去掉邊界檢查
支援原生的無符號數學運算 不支援原生的無符號數學運算
對所有的數字類型有標準的範圍限制，但位元組長度是跟實現相關的。標準化的類型可以用 typdef 定義 (uint8_t, ..., uintptr_t) 在所有平台上對所有的基本類型都有標準的範圍限制和位元組長度
支援指標，參照，傳值調用 基本類型總是使用傳值調用。物件以可以為空的參照的方式傳遞（相當於在C++里使用指向 class 或者 struct 參數的指標）。[1]
顯式的記憶體管理，但有第三方的框架可以提供垃圾搜集的支援。支援析搆函數。 自動垃圾搜集（可以手動觸發）。沒有析構函數的概念，對 finalize() 的使用是不推薦的
支援類class，結構struct，聯合union，可以在堆疊或者堆里為它們動態分配記憶體 只支援類別，只在堆中為物件分配記憶體。Java SE 6在棧為一些物件分配記憶體的使用了逃逸分析的優化方法
允許顯示的覆蓋（也叫重寫）類型 嚴格的類型安全，除了變寬的類型轉換。Java 1.5開始支援自動類型包裝和解包裝(Autoboxing/Unboxing)
C++函式庫包括：語言支援，診斷工具，常用工具，字串，本地化，容器，演算法，迭代器，數值，輸入/輸出，C函式庫。Boost庫提供了更多的功能，包括線程和網絡I/O。用戶必須在一大堆（大部分互相不相容）第三方GUI或者其他功能庫中進行選擇 函式庫在每次 Java 發佈新版本的時候都會更新並增強功能。1.6版本支援：本地化，日誌系統，容器和迭代器，演算法，GUI 程式設計（但沒有用到系統的GUI），圖形，多線程，網絡，平台安全，自省機制，動態類別載入，阻塞和非阻塞的I/O，對於XML、XSLT、MIDI也提供了相關介面或者支援類別，數據庫，命名服務（例如 LDAP），密碼學，安全服務（例如 Kerberos），列印服務，WEB 服務。SWT 提供了一個系統相關的GUI的抽象
大部分運算子可以運算子重載 運算子的意義一般來說是不可變的，例外是+和+=運算子被字串多載了
完全的多重繼承，包括虛擬繼承 類別只允許單繼承，需要多繼承的情況要使用介面
支援編譯期模板 泛型（英語：Generics in Java）被用來達到和C++模板類似的效果，但由於類型消除（英語：Type Erasure）它們不能在編譯期間從代碼被編譯成位元組碼
支援函數指標，函數物件，lambda(C++11)和介面 沒有函數指標機制。替代的概念是介面，Adapter 和 Listener也是被廣泛使用的
沒有標準的代碼內嵌文件機制。不過有第三方的軟件（例如 Doxygen） Javadoc 標準文件生成系統
const 關鍵字用來定義不可改變的常數和成員函數 final 提供了一個限制版本的 const，等價於 type* const 的物件指標或者 const的基本類型數據。沒有 const 成員函數，也沒有const type* 指標的等價物
支援 goto 陳述式 支援循環標簽(label)和陳述式塊
原始碼可以寫成平台無關的（可以被 Windows、BSD、Linux、Mac OS X、Solaris 等編譯，不用修改），也可以寫成利用平台特有的特性。通常被編譯成原生的機械碼 被編譯成Java虛擬機的位元組碼。和Java平台相關，但是原始碼一般來說是不依賴操作系統特有的特性的

C++ 是一門強大的語言，設計用在系統程式設計方面。Java語言是設計成簡單易用易學習，並有一個強大的跨平台的庫。Java函式庫對一個函式庫來說相當的大。但Java並不會提供所在平台的所有特性和介面。C++函式庫簡單健壯，提供容器和關聯數組的支援。[2]

語言特性

編輯

語法

編輯
  • Java語法是上下文無關文法，可以用一個簡單的LALR語法剖析器來分析。而分析C++就複雜多了；例如 Foo<1>(3); ，如果 Foo 是一個變數，那麼它是一個比較的運算式，但如果 Foo 是一個類範本的名字，那麼它會創建一個物件。
  • C++允許命名空間級別的常數，變數和函數. 而所有這樣的 Java 聲明必須在一個類或者介面當中。
  • 在 C++ 的聲明中，一個類名可以用來聲明一個此類物件的值。 Java 裏沒辦法做到這點，在Java裏對象不是值。在 Java 的聲明中，一個類名聲明的是對此類的一個物件的參照。而在 C++ 裏與之等價的做法是用 "*" 來聲明一個指標。
  • 在 C++ 裏，"."運算子將一個物件作為一個左指令引數來訪問這個物件的成員。因為對象在 Java 裏不是值，所有的對象都通過參照來訪問，剛才的做法在 Java 裏是無法實現的。在 Java 裏，"." 運算子是將一個物件的參照作為左指令引數來訪問這個物件的成員，在C++中和這種做法等價的是 "->"。
C++ Java 
class Foo {          // 定义 Foo 类
public:
    int x;           // 成员变量

    Foo(): x(0) {    // Foo 的构造函数
    }                //  初始化 x

    int bar(int i) { // 成员函数 bar()
        return 3*i + x;
    }
};

class Foo {               // 定义 Foo类
    public int x = 0;     // 成员变量,
                          //  以及其值的初始化
    public Foo() {        // Foo的 构造函数
    }

    public int bar(int i) {// 成员方法 bar()
        return 3*i + x;
    }
}

Foo a;
// 定义 a 为一个 Foo 类的对象,
// 使用其缺省的构造函数
// 如果你想要用其他的构造函数,
// 你可以用 "Foo a(args);"

Foo a;
// 定义 a 为一个 Foo 类的对象的引用
a = new Foo();
// 使用缺省的构造函数初始化
// 如果你想要用其他的构造函数,
// 你可以用 "Foo a = new Foo(args);"

Foo b = a;
// 拷贝 a 的內容到一个新的 Foo 类的变量 b 当中;
// 另一种可以选择的語法是 "Foo b(a)" 或者 "Foo b{a}"

Foo b = a.clone();
// 拷贝所有a这个实例的成员到b,当且仅当,
// Foo 实现了一个 public 的 clone() 方法,
// 并且 clone() 返回一个新的这个对象的拷贝

a.x = 5; // 修改 a 對象

a.x = 5; // 修改 a 對象

cout << b.x << endl;
// 輸出 0,因為 b 和 a 是兩個物件

System.out.println(b.x);
// 輸出 0,因為 b 和 a 是兩個物件

Foo *c;
// 定義 c 為指向一個 Foo 類物件的指標(初始值是
// 未定義的;可能指向任何地方)

Foo c;
// 定義 c 為一個指向 Foo 物件的指標
// (如果 c 是一個類的成員,那麼初始值為空;
// 如果 c 是一個區域變數那麼你在使用之前必須
// 對它進行初始化)

c = new Foo();
// 將 c 綁定為一個新的 Foo 物件的引用

c = new Foo();
// 將 c 綁定為一個新的 Foo 物件的引用

Foo *d = c;
// 將 d 綁定為和 c 同一個對象的引用

Foo d = c;
// 將 d 綁定為和 c 同一個對象的引用

c->x = 5;
// 修改 c 指向的對象

c.x = 5;
// 修改 c 指向的對象

a.bar(5);  // 對 a 調用 Foo::bar()
c->bar(5); // 對 *c 調用 Foo::bar()

a.bar(5); // 對 a 調用 Foo.bar()
c.bar(5); // 對 c 調用 Foo.bar()

cout << d->x << endl;
// 輸出 5,因為 d 引用的物件和 c 一樣

System.out.println(d.x);
// 輸出 5,因為 d 引用的物件和 c 一樣
  • 在 C++ 裏，定義一個指向常數的指標（唯讀指標）是可能的，也就是說，你不能修改這個指標指向的物件的內容。函數和方法也都保證不會修改用 "const" 關鍵字的指標指向的物件的內容,是強制常數正確性（英語：const-correctness）的。在 Java 裏這是不可能做到的，你可以定義一個參照為 "final"（就像在 C++ 裏定義一個指標"常數"），但這只是阻止你重新綁定這個參照；你還是可以修改這個 "final" 參照指向的物件的。
C++ Java 
const Foo *a; // 你不能通過 a 修改 a 指向的對象

final Foo a; // 你可以通過 a 修改 a 指向的物件

a = new Foo();

a = new Foo(); // 只能在構造函數裡

a->x = 5;
// 非法

a.x = 5;
// 合法, 你仍然可以修改這個物件

Foo *const b = new Foo();
// 你可以定義一個 "const" 指標

final Foo b = new Foo();
// 你可以定義一個 "final" 引用

b = new Foo();
// 非法, 你不能對它再次綁定

b = new Foo();
// 非法, 你不能對它再次綁定

b->x = 5;
// 合法,你還是可以修改這個物件

b.x = 5;
// 合法,你還是可以修改這個物件
  • C++ 支援 goto 陳述式；Java 強制結構化流程控制（structured control flow），依賴break標籤 和 continue標籤 陳述式來提供類似於 goto 的部分。. 一些評論者指出這些標籤化的流程控制打破了結構化程式設計的單退出點的。點.[3]
  • C++ 提供了一些 Java 缺乏的低級特性。在 C++ 裏，指標可以用來操作特定的記憶體位置，這是在寫低級作業系統模組的時候必須用到的。類似的，許多 C++ 編譯期支援內聯彙編，在 Java 裏，這樣的代碼只能放在外來的庫中，而且在調用的時候只能通過JNI來訪問這些外來庫提供的介面.

語意

編輯
  • C++ 允許給函數/方法的參數設置預設值，Java 不提供這個特性。但是方法多載可以達到同樣的效果。
  • C++ 里最小的編譯單位是一個函數；Java 里最小的編譯單位是一個類. 在 C++ 里，函數可以被單獨編譯。在 Java 里，要編譯和維護單獨的方法需要把它們移到超類或子類或者使用其他的代碼重構的技巧。
  • C++ 允許基本類型之間的一些隱式的轉換，也允許程式設計師對於用戶自訂類型相關的隱式轉換規則。在 Java 里，只有基本類型之間變寬類型的轉換可以是隱式的；其餘的轉換需要顯式的類型轉換語法。
    • 這造成的一個後果是，雖然在 Java 和 C++ 里循環的條件（if、while 和 for 里的退出條件）預期的都是一個布爾表達式，但 if(a = 5) 這樣的代碼在 Java 里會導致編譯錯誤，因為沒有從整型到布爾的隱式變窄轉換。如果代碼是 if(a == 5) 的輸錯的情況那麼是很方便發現這個錯誤的。而目前的 C++ 編譯器一般來說只會針對這種情況產生一個警告。
  • 對於傳參數給函數的情況，C++ 支援參照傳遞和值傳遞。在 Java 里，參數總是值傳遞的。[4] 但在 Java 里，所有的非基本類型的值都只是對於對象的參照（用 C++ 的術語來說，它們是智能指針）。對象在 Java 里不是作為值直接被使用的，只有對象的參照可以被直接操作；習慣於將對象當做值直接使用的 C++ 開發者經常會把這個跟參照傳遞搞混。
  • Java 內建的類型在位元組寬度和取值範圍上是被虛擬機定義好的；在 C++ 里，內建的類型有定義一個最小取值範圍，但是其他的部分（位元組寬度）可以被對映成具體平台上支援的原生類型。
    • 舉個例子，Java 字元是16位元的Unicode字元，字串是由這樣的字元組成的序列。 C++ 提供窄和寬兩種字元，但實際的字元寬度是和平台相關的，視所用的字元集而定。字串可以由這兩種字元中的一種組成。
  • 浮點數及其操作的精度和捨入方式在 C++ 里是平台相關的. Java 提供了一個可選的嚴格的浮點數模型（英語：strictfp），保證跨平台的一致性，不過可能會導致運行時效率比較差.
  • 在 C++ 里，指針可以作為主記憶體地址直接操作. Java 沒有指針 — 它只有對象參照和數組參照，這兩者都不允許直接用來訪問主記憶體地址。在 C++ 里可以構造一個指向指針的指針，而 Java 的參照只能指向對象。。
  • 在 C++ 里，指針可以指向函數或者方法（函數指針）。在 Java 里的等價物是對象或者介面的參照。
  • 雖然有使用棧主記憶體分配的對象，C++ 還是支援區域資源管理，一個用來自動管理主記憶體和其他系統資源的技術，此技術支援確定性對象銷毀（deterministic object destruction）。不過，區域資源管理在 C++ 里是不被保證的；它只是一個設計模式，所以需要依賴程式設計師遵守相關的規則. Java 通過使用垃圾搜集來支援自動主記憶體管理，但對於其他的系統資源（窗口，通訊埠，線程），如果垃圾搜集器無法決定它們是否不再被用到，那通常還是需要顯式的釋放的。
  • C++ 的用戶可自訂運算子多載的特性在 Java 里是不支援的。唯一在 Java 里可以重載的運算子是 "+" 和 "+=" 運算子，在字串里多載為連接字串。
  • Java 的標準應用程式介面支援反射和動態載入任意代碼。
  • C++ 支援靜態和動態的庫連接。
  • Java 支援泛型，其主要目的是提供類型安全的容器. C++ 支援模板，在泛型程式設計方面提供了更強的支援。
  • Java 和 C++ 都對基本類型（也叫"內建"類型）和用戶自訂類型（也叫"複合"類型）。在 Java 里，基本類型只有值的語義，複合類型只有參照的語義. 在 C++ 里所有的值都有值語義，可以創建對於任何類型的參照，這樣就允許通過參照語義來操作對象。
  • C++ 支援任意類型的多重繼承. 在 Java 里一個類只能從單個的類繼承而來，但一個類可以實現多個的介面（換句話說，它支援類型的多重繼承，但對於實現只能單繼承）。
  • Java 對於類和介面是顯式區分的。在 C++ 里多重繼承和純虛函數使得定義出類似於 Java 的介面的類是可能的，不過會有少許區別。
  • Java 在語言和標準庫都對多線程有良好的支援。synchronized 這個 Java 的關鍵字為了支援多線程應用提供了簡單而安全的的互斥鎖，但同步（synchronized）區只能用 LIFO 的順序離開。Java 也為更高階的多線程同步提供了健壯而複雜的庫。在 C++ 里沒有專門為多線程定義的主記憶體模型；但第三方庫提供了和 Java 差不多的功能；不過這些 C++ 庫之間差異較大，一致性不好。
  • C++ 方法可以聲明為虛函數，虛函數是在運行期根據對象的類型才確定的。 C++ 方法預設情況下不是虛的. 在 Java 里，方法預設情況下是虛的，但可以使用final關鍵字使之聲明為非虛的。
  • C++ 枚舉屬於基本類型，支援和其他整數類型之間的轉換和比較。Java 枚舉實際上是類的實例（它們從 java.lang.Enum<E> 擴展而來），象其他的類一樣可以定義構造函數，數據成員及方法。

資源管理

編輯
  • Java 提供了自動化的垃圾搜集。在 C++ 里主記憶體管理通常通過構造函數，析構函數以及智能指針。C++ 標準允許垃圾搜集，但並不強制要求；實際使用上垃圾搜集極少被用到。強制使用自動垃圾搜集導致了在 Java 里編寫實時軟件是困難的。[3]
  • C++ 可以申請任意的主記憶體塊。Java 只能通過對象實例化來申請主記憶體。（注意：在 Java 里，程式設計師可以通過創建一個位元組數組模擬申請任意的主記憶體塊，不過 Java 數組仍然是對象。）
  • Java 和 C++ 在資源管理上使用不同的習語。Java 主要依賴只能回收主記憶體的垃圾搜集機制，因為該機制如果用於回收使用中的非主記憶體的系統資源可能是非常危險的。而 C++ 主要依賴 RAII (資源的取得就是初始化)。這反映了這兩種語言的幾方面的不同：
    • 在 C++ 里在棧里申請複合類型的對象是很平常的，一旦退出棧的範圍就會被銷毀。在 Java 里複合類型的對象總是在堆里申請的主記憶體，而後被垃圾搜集器搜集（除非在虛擬機裏使用了逃逸分析技術來將堆的主記憶體申請轉成棧的。）
    • C++ 有析構函數，而 Java 有finalizer(finalizer). 兩者都會在對象釋放之前被調用，但是它們有顯著的不同. 一個 C++ 對象的析構函數必須被隱式（棧變數對象的情況）或者顯式地調用來釋放對象. 析構函數在對象釋放之前同步地執行. 同步，協調的反初始化以及釋放在 C++ 里滿足 RAII 的要求. 在 Java 里，對象的釋放是被垃圾搜集器隱式處理的. 一個 Java 對象的 finalizer 在它被最後一次訪問之後和在實際釋放之前的某個時間點被非同步（非同步）地調用，這個調用有可能一直不產生. 非常少的對象需要 finalizer；只有那些在釋放前必須保證一些清理工作一定要做的對象來說才是需要的 — 典型的情況是：釋放對 JVM 來說是外部的資源. 在 Java 里，企圖安全同步的釋放某些系統資源，只能用顯式的 try/finally 結構來進行.
    • 在 C++ 里是有可能有一個迷途指針的 – 過時的對一個已釋放的對象的參照（參照）；試圖使用一個迷途指針的結果是導致程式錯誤. 在 Java 里，垃圾搜集器不會銷毀一個正在被參照的對象.
    • 在 C++ 里未初始化過的基本類型對象是有可能存在的，Java 強制要做預設初始化.
    • 在 C++ 里有可能申請了一個對象，但對它沒有任何參照. 這樣的不可達對象（不可訪問主記憶體）是無法被銷毀的，導致了主記憶體泄漏. 作為對比，在 Java 里一個對象不會被回收直到它變得不可達（對於用戶程式來說）. （注意: 弱參照(弱參照）是被支援的，這個特性讓 Java 的垃圾搜集器能夠識別不同 程度的可達性.）在 Java 里垃圾搜集阻止了很多主記憶體泄漏的情況，但某些情況下泄漏仍然是可能的.[5]
    • Java 更容易泄漏非主記憶體資源，而 C++ 的慣用做法更不會導致這種泄漏.

庫

編輯
  • C++ 對於許多平台相關的特性提供了跨平台的訪問方式. 從 Java 到原生的作業系統和硬件相關的函數的直接訪問需要用到JNI（Java本地介面）。

運行時

編輯
  • C++ 通常來說會直接被編譯成機械碼，被作業系統直接執行。Java 通常會被編譯成位元組碼，被Java虛擬機器和直譯器或者即時編譯器編譯成機械碼然後執行。
  • 因為表達方式不受限制，低階的 C++ 語言特性（例如：不被檢查的陣列訪問，原始指標，類型雙關語(type punning（英語：type punning）)不能在編譯期間或者執行期間可靠地被檢查. 相關的程式設計錯誤會導致低階的緩衝區溢位和段錯誤（記憶體區段錯誤）. 標準模板庫 提供了進階的抽象（例如 vector,list 和 map）來幫助避免這樣的錯誤.在 Java 里，低階錯誤不會發生或者會被JVM檢測到並以異常的形式報告給應用.
  • Java 語言在越界訪問陣列的時候一般來說會對陣列進行邊界檢查(bounds checking). 這消除了導致程式不穩定的一個可能因素，但這是以執行速度更慢一些作為代價的. 在一些情況下，編譯器分析（compiler analysis（英語：compiler analysis））可以檢測到不必要的邊界檢查並去掉。C++ 對於原生陣列的越界訪問沒有要求特定的處理，所以需要對於原生陣列確認不越界. 但C++ 標準庫里的一部分庫象 std::vector 也提供了可選的邊界檢查. 總的來說，Java 陣列是"總是安全；嚴格限制；開銷較多" ，而 C++ 原生陣列是"可選的開銷； 完全不限制；有潛在的不安全."

模板 vs. 泛型

編輯

C++ 和 Java 都提供泛型程式設計的能力，分別是模板 和 泛型(Generics in Java（英語：Generics in Java）). 雖然它們被創造用來解決類似的問題，有類似的語法，但實際上很不一樣.

C++ 模板 Java 泛型
類和函數都可以使用模板. 類和方法都可以使用泛型.
參數可以是任意類型或者整型. 參數只能是能被參照的類型（非基本類型）.
在編譯的時候對於每種類型生成類或者函數的拷貝. 對於所有類型的參數，只有一個版本的類或者函數生成.
同一個類用不同類型生成的對象在執行期也是不同類型的 編譯完成以後類型參數的類型是被消除的；同一個類用不同類型參數生成的對象在執行期是相同類型的.
想要用到模板類或者函數的實現代碼的話必須 include 它（只是聲明是不夠的）. 有一個編譯好的類檔案里的類或者函數的簽章就足以使用泛型了
模板可以被具體化 -- 可以為某個特定的模板參數提供單獨的實現. 泛型不能被具體化.
模板參數可以有預設參數(default argument)（只針對對於模板類，模板函數是沒有此特性的）. 泛型類參數無法擁有預設參數.
不支援萬用字元. 返回的類型經常是巢狀的 typedef 形式的. 如果只用一次,那麼支援萬用字元作為類型參數.
不直接支援設置類型參數的邊界（即，不允許說明類型參數必須為某個類型的子類/父類別），但超程式設計提供了這個特性[6] 支援類型參數邊界，分別以 "extends" 和 "super" 來定義上界和下界；同時允許定義類型參數之間的繼承關係
允許生成有參模板的類別的實例（如 foo = new Foo<T>, T 為參數） 不允許生成有參模板類別的實例（除非使用反射）
泛型類的類型參數無法用在 static 方法和變數上.
static 變數不在在不同的類型參數生成的類之間共用. static 變數在不同類型參數生成的類的對象之間是共用的.
泛型類和函數在聲明時不強制類參數的類限制. 使用錯誤的類參數會導致模板代碼"不工作". 值得注意的是，如果使用了錯誤的參數，則錯誤資訊將出現在定義模板的代碼處（而非呼叫模板的代碼處）， 說明 "不支援以該類型作為參數來實例化模板". 這種錯誤資訊往往難以幫助人們找出真正的問題所在（程式設計時究竟使用了何種 "錯誤的" 參數）. 因此，模板類或者函數的正確使用更依賴於正確的文件. 超程式設計以額外的代價提供了這些特性. 泛型類和函數在聲明的時候強制了類參數的類限制(Generic classes and functions can enforce type relationships for type parameters in their declaration). 使用一個錯誤的參數會在使用它的時候導致一個類錯誤. 在泛型代碼里操作和參數化類型只能按聲明的時候保證安全的方式來使用. 這用失去彈性的代價來換取好得多的類型方面的安全性.
模板是圖靈完全的（參見 模板超程式設計）. 泛型不是圖靈完全的.

雜項

編輯
  • Java 和 C++ 在使代碼在不同的檔案分開方面使用了不同的技術. Java 使用了一個包系統，這個系統對所有的程式都要指定了檔名和路徑. 在 Java 里，編譯器負責匯入可執行的類檔案. C++ 使用了標頭檔原始碼的包含系統來在不同的檔案共用聲明.
  • 編譯好的 Java 代碼一般來說比 C++ 檔案小，因為Java位元組碼(Java bytecode)一般來說比機械碼要更緊湊[來源請求]，Java 程式都不是靜態連結的.
  • C++ 編譯多了一個文字預處理過程，Java 是沒有的. 因此一些用戶在他們的編譯過程之前增加了一個預處理的過程，這樣能更好的支援需要條件編譯的情況.
  • 兩個語言裏陣列都是定長的. 在 Java 里，陣列是頭等對象，而在 C++ 里它們只是它們的基本類型元素的連續的序列，經常用一個指向第一個元素的指標和一個可選的長度來參照. 在 Java 里，陣列是被邊界檢查的，而且知道它們的長度，而在 C++ 里你可以將任意的序列當成一個陣列. C++ 和 Java 都提供了相關的容器類（分別為std::vector 和 java.util.ArrayList），可以改變大小.
  • Java 的除法和模除運算子是定義成零截斷的. C++ 沒有定義這兩個運算子是零截斷的還是"負無窮截斷"的. 在 Java 里-3/2 總是得到 -1，但一個 C++ 編譯器可能會返回 -1 或 -2，視平台而定. C99 定義了和 Java 一樣的除法方式. 兩種語言都保證對於所有的 a 和 b(b!=0)（當 a 和 b都是整型的時候）(a/b)*b + (a%b) == a. C++ 版本有時候會更快，因為它允許直接使用處理器的截斷方式.
  • 整型的長度在 Java 里是已定義好的(int 為 32-bit, long 為 64-bit)，而在 C++ 里整型和指標的長度是和編譯器以及應用二進制介面相關的. 因此仔細編寫的 C++ 代碼可以利用64位元處理器的能力而又可以在32位元處理器上工作. 但是需要很仔細的用可移植的方式編寫. 作為對比，Java 的固定整型大小使得程式設計師無法做到這樣，沒辦法利用處理器的字長會導致 Java 在64位元處理器上表現較差.

效能

編輯

想執行一個編譯好的 Java 程式，電腦上要執行JVM；而編譯好的 C++ 程式不需要額外的應用。比較早期的 Java 版本在效能上比靜態編譯的語言如 C++ 差得很多，這是因為用 C++ 是直接編譯成一些機器指令，而當 Java 編譯成位元組碼以後用 JVM 解釋執行的時候又牽涉了不少額外的機器指令。 例如：

Java/C++ 陳述式 C++ 生成的代碼 (x86) Java 生成的位元組碼
vector[i]++; mov edx,[ebp+4h]

mov eax,[ebp+1Ch]
inc dword ptr [edx+eax*4]

aload_1

iload_2
dup2
iaload
iconst_1
iadd
iastore

C++ 在大部分的情況下都比 Java 要快，[7] 有幾個數值方面的基準測試的研究爭辯說 Java 在某些情況下可能會比 C++ 的效能好得多。[8][9][10] 但有人說數值方面的基準測試對於語言的評估是不合適的，因為編譯器都可以做相關的最佳化，甚至可能將被測試的代碼徹底刪除。[11][12][13] 如果涉及到一個真正現實應用的程式，Java 會因為很多原因導致效能變差：[14][15][16]

  • 所有的對象都在堆里被申請。對於使用小對象的函數來說會導致很大的效能損失，因為在棧里申請主記憶體幾乎沒有效能損失。
  • 方法預設是虛的。這對於小對象來說會因為虛表增加好幾倍的主記憶體使用。它也會引起效能損失，因為 JIT 編譯器不得不對查虛表的過程做額外的最佳化。
  • 即使使用標準的容器依然會有很多的類型轉換，這會引起效能損失，因為需要遍歷整個繼承樹。
  • 虛擬機器更進一步增加了主記憶體的使用，因此降低了主記憶體的局部性，增加了快取命中失敗率，從而導致整個程式變慢。
  • 缺乏低階細節的操作方式使得開發者無法將程式進一步最佳化，因為編譯器不支援。[17]

有人爭論說，和 Java 相比 C++也有很多劣勢：

  • 指標使得最佳化變得困難，因為它們可能指向任意的數據。當然現在這一點也並非完全正確，因為一些現代的編譯器引入了 "嚴格別名" 的規則 [18] 並且支援 C99 的關鍵字 restrict，從而嚴格限制了指標的使用，使其只能用於指向已知的變數 [19]
  • Java 的垃圾搜集和使用malloc/new來申請主記憶體相比能擁有更好的快取連貫性，因為它的申請一般來說是順序的。然而，始終有爭論認為二者同樣會導致主記憶體的「零碎化」（即多次分配和回收之後主記憶體空間會變得不連續），且並沒有哪一個比對方有更明顯的快取優勢。
  • 執行時編譯可能可以更好的最佳化代碼，因為可以利用執行時的額外的資訊，例如知道代碼是在什麼樣的處理器上執行。然而當今的情況也並非完全如此，因為目前最先進的 C++ 編譯器也會針對不同系統生成不同的目標碼，以期充分利用該系統的計算能力 [20]

此外，有爭議的是，花在更複雜的 C++ 代碼上的 debug 時間太多，用 Java 開發完全可以把這些時間用來最佳化 Java 代碼。當然對於一個給定的程式來說兩種語言能最佳化到什麼程度也是一方面。最後，對於處理器負擔很重的情況，例如影片渲染，C++ 能直接訪問硬件，在同樣一個硬件規格下 C++ 總是會比 Java 的表現好很多。

所有權控制

編輯

C++不是任何一個公司或者組織的商標，不被任何個人擁有。[21]Java原是Sun的商標，現在由甲骨文公司擁有。[22]

C++語言由 ISO/IEC 14882 定義，是一個ISO標準，由 ISO/IEC JTC1/SC22/WG21 委員會發佈。Java語言由 Java Language Specification 定義，這是一本Sun公司（已被甲骨文收購）出版的書。[23]

其他

編輯

兩者的對象訪問格式也不一樣。

參考文獻

編輯
  1. ^ Java is Pass-By-Value. [2010-10-21]. （原始內容存檔於2008-05-15）. 
  2. ^ Java and C++ Library. [2010-10-21]. （原始內容存檔於2020-09-30）. 
  3. ^ 3.0 3.1 Robert C. Martin. Java vs. C++: A Critical Comparison (PDF). January 1997 [2010-10-21]. （原始內容 (PDF)存檔於2008-05-11）. 
  4. ^ James Gosling, Bill Joy, Guy Steele, and Gilad Bracha, The Java language specification, third edition. Addison-Wesley, 2005. ISBN 0-321-24678-0 (see also online edition of the specification （頁面存檔備份，存於互聯網檔案館）).
  5. ^ "Java memory leaks -- Catch me if you can" （頁面存檔備份，存於互聯網檔案館） by Satish Chandra Gupta, Rajeev Palanki, IBM DeveloperWorks, 16 Aug 2005
  6. ^ Boost type traits library. [2010-10-21]. （原始內容存檔於2008-12-02）. 
  7. ^ Cherrystone Software Labs. Algorithmic Performance Comparison Between C, C++, Java and C# Programming Languages (PDF). 2010-03-29 [2010-08-24]. （原始內容 (PDF)存檔於2010-03-31）. 
  8. ^ Bruckschlegel, Thomas. Microbenchmarking C++, C# and Java. Dr. Dobbs. 2005-06-17 [2010-10-24]. （原始內容存檔於2007-04-29）. 
  9. ^ "Performance of Java versus C++" （頁面存檔備份，存於互聯網檔案館） by J.P. Lewis and Ulrich Neuman, USC, Jan. 2003 (updated 2004)
  10. ^ "Java will be faster than C++" （頁面存檔備份，存於互聯網檔案館） by Kirk Reinholtz, JPL, Apr 2001
  11. ^ 存档副本. [2010-10-21]. （原始內容存檔於2014-04-27）. 
  12. ^ 存档副本. [2010-10-21]. （原始內容存檔於2020-04-20）. 
  13. ^ "Java (not really faster) than C++ benchmark （頁面存檔備份，存於互聯網檔案館） illustrates
  14. ^ 存档副本. [2008-02-15]. （原始內容存檔於2008-02-11）. 
  15. ^ 存档副本. [2010-10-21]. （原始內容存檔於2020-11-08）. 
  16. ^ An empirical comparison of C, C++, Java, Perl, Python, Rexx, and Tcl for a search/string-processing program (PDF): 18. [2012-12-13]. （原始內容存檔 (PDF)於2020-10-26）. 
  17. ^ Clark, Nathan; Amir Hormati, Sami Yehia, Scott Mahlke. Liquid SIMD: Abstracting SIMD hardware using lightweight dynamic mapping. HPCA』07. 2007: 216–227. 
  18. ^ 存档副本. [2010-10-21]. （原始內容存檔於2013-05-08）. 
  19. ^ Demystifying the Restrict Keyword. [2010-10-21]. （原始內容存檔於2008-06-19）. 
  20. ^ Targeting IA-32 Architecture Processors for Run-time Performance Checking. [2010-10-21]. （原始內容存檔於2020-09-29）. 
  21. ^ Bjarne Stroustrup's FAQ: Do you own C++?. [2010-10-21]. （原始內容存檔於2008-06-17）. 
  22. ^ ZDNet: Oracle buys Sun; Now owns Java （頁面存檔備份，存於互聯網檔案館）.
  23. ^ Java SE Specifications. [2014-09-04]. （原始內容存檔於2021-02-01）. 

外部連結

編輯
 
維基教科書中的相關電子教學：Programming Languages/Comparisons/Java
取自 "https://zh.wikipedia.org/w/index.php?title=Java和C%2B%2B的對照&oldid=83688184"