C、C++、Java、go的語法區別

詳細C++、Java比較：http://www.cnblogs.com/stephen-liu74/archive/2011/07/27/2118660.html

一、C、C++的區別 

  在很大程度上,標准C++是標准C的超集.實際上,所有C程序也是C++程序,然而,兩者之間有少量區別.下面簡要介紹一下最重要的區別.
1、在C++中,局部變量可以在一個程序塊內在任何地方聲明,在C中,局部變量必須在程序塊的開始部分,即在所有"操作"語句之前聲明,請注意,C99標准中取消了這種限制.
2、在C中,按如下方式聲明的函數沒有對函數參數進行任何說明;

int func();

   也就是說,如果沒有在函數后面的括孤內指定任何參數,這在C中就意味着對函數參數未做任何聲明,該函數可能有參數,也可能沒有參數,然而,在C++中,這樣的函數聲明意味着該函數沒有參數,也就是說,在C++中,下面這兩個函數聲明具有同樣的作用:

     int func(); int func(void);

  在C++中,參數列表中的void是任選的.許多C++程序員使用它們是為了表明函數沒有任何參數的,以便於他人理解程序.但是,從技術上說,void不是必須的.
4、在C++中,所有函數均必須被設計成原型,但這在C中只是一種選擇.編程經驗表明,在程序中也應該給函數采用原型設計方法 .
5、在C與C++之間還存在一個重要而又細微的差別,即字符常數在C中被自動作為整形來處理,但在C++中則不然.
6、在C中,多次聲明一個全局變量雖然不可取,但不算錯.在C++中,多次聲明同一個全局變量會引發錯誤.
7、在C中,一個標識符可以至少31個有效的組成字符.在C++中,一個標識符的所有組成字符均是有效的.可是,從實用角度看,過長的標識符沒有太大的用處,不僅不便於記憶,而且還會增加出現打字錯誤的可能性.
8、在C中,在程序內部調用main()函數的情形不常見,但這種做法是容許的,在C++中,這種做法是不容許的.  
9、在C中,無法獲得register型的地址,在C++中則可以獲得這種地址.
10、在C中,如果類型聲明語句中沒有指定類型名,該類型被假定成int,這種隱式轉型在C99與C++中是不允許的. 

11、頭文件命名形式不同

#include <iostream>
using namespace std;

  為什么沒有.h后綴名?

  名稱iostream沒有擴展名.h,原因是<iostream>是標准C++所定義的新式頭部文件之一,新式C++頭部文件不再使用.h擴展名.
  第二行告訴編譯程序使用std名稱空間,名稱空間是C++的,一個名稱空間建立一個聲明范圍,在該范圍內可以放置各種程序元素.名稱空間用來幫助組織大型程序的結構.這條using語句通知編譯程序,程序員需要使用std名稱空間,這是整個標准C++庫聲明所使用的名稱空間.通過使用sdt名稱空間,程序可以簡化對標准庫的訪問.普通C程序僅使用C子集,不需要名稱空間語句,因為C的庫函數在默認的全局名稱空間中是可使用的.

12、類與結構體的區別:類與結構體是相互關聯的

  結構是C的一部分,C++從C中繼承了結構,在語法上,類與結構十分相似,在關系上,這兩者也很接近,在C++中,結構的作用被拓寬了,進而使結構成為了類的一種替代方法.實際上,類與結構的惟一區別在於:在默認狀態下,結構的所有成員均是公有的,而類的所有成員是私有的.除此之外,類與結構是等價的,也就是說,一個結構定義了一個類的類型.
  C++同時包含這兩個等價的關鍵字struct與class，基於3個方面的原因：

  第一,加強結構的能力.在C中,結構提供了一種數據分組方法,因而讓結構包含成員函數是一個小小的改進；

  第二,由於類與結構是相互關聯的,所有現有C代碼到C++的移植變得更容易；

  第三,由於類與結構的等價性,提供兩個不同的關鍵字可以使類定義自由發展,為了保持C++與C的兼容性,結構定義必須始終受它的C定義的結束。
  即使在有些地方可以使用結構來代替類,但盡量不要這么做,為了清楚起見,該用類的地方就用class關鍵字,該用C結構的地方就用struct關鍵字.

13、類與聯合是相互關聯的

  聯合也可以用來定義類.在C++中,聯合包含成員函數,變量以及構造與析構函數.C++聯合保留了C聯合的全部特征,其中最重要的特征是所有數據元素共享內存的相同地址.與結構類似,聯合的成員在默認狀態下也是公有的,並且完全兼容於C.與結構一樣,C++中的聯合聲明定義了一種特殊的類,進而意味着保持了類的封裝原則.
  C++的聯合有幾個必須遵守的使用限制.第一,聯合不能繼承其他任何類型的類.第二,聯合不能是基類,不能包含有虛函數成員.靜態變量不能是聯合的成員.聯合不能使用引用成員,而且不能有任何作為成員的重載賦值運算符的對象.第三,如果一個對象包含明確的構造或析構函數,該對象不能成為聯合的成員.
  C++有一個叫做匿名聯合的特殊聯合.匿名聯合沒有類型名,也不聲明任何變量,只是告訴編譯程序它的成員變量共享一個內存地址.但是,變量本身無需要使用常規的點運算符語法即可直接引用。
  上述聯合的使用限制也適用於匿名聯合,但下面這兩個限制除外,第一,匿名聯合所包含的元素只能是數據,不能包含成員函數,也不能包含私有或受保護元素;第二,全局匿名聯合必須聲明成靜態的.

 

二、java與C++的區別

1、和C++一樣，Java也提供了兩種類型的注釋。

2、所有東西都必須置入一個類。不存在全局函數或者全局數據。如果想獲得與全局函數等價的功能，可考慮將static方法和static數據置入一個類里。注意沒有象結構、枚舉或者聯合這一類的東西，一切只有“類”（Class）！
3、所有方法都是在類的主體定義的。所以用C++的眼光看，似乎所有函數都已嵌入，但實情並非如何（嵌入的問題在后面講述）。
4、在Java中，類定義采取幾乎和C++一樣的形式。但沒有標志結束的分號。沒有class foo這種形式的類聲明，只有類定義。

　　class aType(){ 　　void aMethod() {/* 方法主體*/} 　　}

5、Java中沒有作用域范圍運算符“::”。Java利用點號做所有的事情，但可以不用考慮它，因為只能在一個類里定義元素。即使那些方法定義，也必須在一個類的內部，所以根本沒有必要指定作用域的范圍。我們注意到的一項差異是對static方法的調用：使用ClassName.methodName()。除此以外，package（包）的名字是用點號建立的，並能用import關鍵字實C++的“#include”的一部分功能。例如下面這個語句：

import java.awt.*;

　（#include並不直接映射成import，但在使用時有類似的感覺。）
6、與C++類似，Java含有一系列“主類型”（Primitive type），以實現更有效率的訪問。在Java中，這些類型包括boolean，char，byte，short，int，long，float以及double。所有主類型的大小都是固有的，且與具體的機器無關（考慮到移植的問題）。這肯定會對性能造成一定的影響，具體取決於不同的機器。對類型的檢查和要求在Java里變得更苛刻。例如：
　　■條件表達式只能是boolean（布爾）類型，不可使用整數。
　　■必須使用象X+Y這樣的一個表達式的結果；不能僅僅用“X+Y”來實現“副作用”。
7、char（字符）類型使用國際通用的16位Unicode字符集，所以能自動表達大多數國家的字符。
8、靜態引用的字串會自動轉換成String對象。和C及C++不同，沒有獨立的靜態字符數組字串可供使用。
9、Java增添了三個右移位運算符“>>>”，具有與“邏輯”右移位運算符類似的功用，可在最末尾插入零值。“>>”則會在移位的同時插入符號位（即“算術”移位）。
10、盡管表面上類似，但與C++相比，Java數組采用的是一個頗為不同的結構，並具有獨特的行為。有一個只讀的length成員，通過它可知道數組有多大。而且一旦超過數組邊界，運行期檢查會自動丟棄一個異常。所有數組都是在內存“堆”里創建的，我們可將一個數組分配給另一個（只是簡單地復制數組句柄）。數組標識符屬於第一級對象，它的所有方法通常都適用於其他所有對象。
11、對於所有不屬於主類型的對象，都只能通過new命令創建。和C++不同，Java沒有相應的命令可以“在堆棧上”創建不屬於主類型的對象。所有主類型都只能在堆棧上創建，同時不使用new命令。所有主要的類都有自己的“封裝（器）”類，所以能夠通過new創建等價的、以內存“堆”為基礎的對象（主類型數組是一個例外：它們可象C++那樣通過集合初始化進行分配，或者使用new）。
12、Java中不必進行提前聲明。若想在定義前使用一個類或方法，只需直接使用它即可——編譯器會保證使用恰當的定義。所以和在C++中不同，我們不會碰到任何涉及提前引用的問題。
13、Java沒有預處理機。若想使用另一個庫里的類，只需使用import命令，並指定庫名即可。不存在類似於預處理機的宏。
14、Java用包代替了命名空間。由於將所有東西都置入一個類，而且由於采用了一種名為“封裝”的機制，它能針對類名進行類似於命名空間分解的操作，所以命名的問題不再進入我們的考慮之列。數據包也會在單獨一個庫名下收集庫的組件。我們只需簡單地“import”（導入）一個包，剩下的工作會由編譯器自動完成。
15、被定義成類成員的對象句柄會自動初始化成null。對基本類數據成員的初始化在Java里得到了可靠的保障。若不明確地進行初始化，它們就會得到一個默認值（零或等價的值）。可對它們進行明確的初始化（顯式初始化）：要么在類內定義它們，要么在構建器中定義。采用的語法比C++的語法更容易理解，而且對於static和非static成員來說都是固定不變的。我們不必從外部定義static成員的存儲方式，這和C++是不同的。
16、在Java里，沒有象C和C++那樣的指針。用new創建一個對象的時候，會獲得一個引用。例如：

String s = new String("howdy");

　　然而，C++引用在創建時必須進行初始化，而且不可重定義到一個不同的位置。但Java引用並不一定局限於創建時的位置。它們可根據情況任意定義，這便消除了對指針的部分需求。在C和C++里大量采用指針的另一個原因是為了能指向任意一個內存位置（這同時會使它們變得不安全，也是Java不提供這一支持的原因）。指針通常被看作在基本變量數組中四處移動的一種有效手段。Java允許我們以更安全的形式達到相同的目標。解決指針問題的終極方法是“固有方法”（已在附錄A討論）。將指針傳遞給方法時，通常不會帶來太大的問題，因為此時沒有全局函數，只有類。而且我們可傳遞對對象的引用。Java語言最開始聲稱自己“完全不采用指針！”但隨着許多程序員都質問沒有指針如何工作？於是后來又聲明“采用受到限制的指針”。大家可自行判斷它是否“真”的是一個指針。但不管在何種情況下，都不存在指針“算術”。
17、Java提供了與C++類似的“構建器”（Constructor）。如果不自己定義一個，就會獲得一個默認構建器。而如果定義了一個非默認的構建器，就不會為我們自動定義默認構建器。這和C++是一樣的。注意沒有復制構建器，因為所有自變量都是按引用傳遞的。
18、Java中沒有“破壞器”（Destructor）。變量不存在“作用域”的問題。一個對象的“存在時間”是由對象的存在時間決定的，並非由垃圾收集器決定。有個finalize()方法是每一個類的成員，它在某種程度上類似於C++的“破壞器”。但finalize()是由垃圾收集器調用的，而且只負責釋放“資源”（如打開的文件、套接字、端口、URL等等）。如需在一個特定的地點做某樣事情，必須創建一個特殊的方法，並調用它，不能依賴finalize()。而在另一方面，C++中的所有對象都會（或者說“應該”）破壞，但並非Java中的所有對象都會被當作“垃圾”收集掉。由於Java不支持破壞器的概念，所以在必要的時候，必須謹慎地創建一個清除方法。而且針對類內的基礎類以及成員對象，需要明確調用所有清除方法。
19、Java具有方法“過載”機制，它的工作原理與C++函數的過載幾乎是完全相同的。
20、Java不支持默認自變量。
21、Java中沒有goto。它采取的無條件跳轉機制是“break 標簽”或者“continue 標准”，用於跳出當前的多重嵌套循環。
22、Java采用了一種單根式的分級結構，因此所有對象都是從根類Object統一繼承的。而在C++中，我們可在任何地方啟動一個新的繼承樹，所以最后往往看到包含了大量樹的“一片森林”。在Java中，我們無論如何都只有一個分級結構。盡管這表面上看似乎造成了限制，但由於我們知道每個對象肯定至少有一個Object接口，所以往往能獲得更強大的能力。C++目前似乎是唯一沒有強制單根結構的唯一一種OO語言。
23、Java沒有模板或者參數化類型的其他形式。它提供了一系列集合：Vector（向量），Stack（堆棧）以及Hashtable（散列表），用於容納Object引用。利用這些集合，我們的一系列要求可得到滿足。但這些集合並非是為實現象C++“標准模板庫”（STL）那樣的快速調用而設計的。Java 1.2中的新集合顯得更加完整，但仍不具備正宗模板那樣的高效率使用手段。
24、“垃圾收集”意味着在Java中出現內存漏洞的情況會少得多，但也並非完全不可能（若調用一個用於分配存儲空間的固有方法，垃圾收集器就不能對其進行跟蹤監視）。然而，內存漏洞和資源漏洞多是由於編寫不當的finalize()造成的，或是由於在已分配的一個塊尾釋放一種資源造成的（“破壞器”在此時顯得特別方便）。垃圾收集器是在C++基礎上的一種極大進步，使許多編程問題消彌於無形之中。但對少數幾個垃圾收集器力有不逮的問題，它卻是不大適合的。但垃圾收集器的大量優點也使這一處缺點顯得微不足道。
25、Java內建了對多線程的支持。利用一個特殊的Thread類，我們可通過繼承創建一個新線程（放棄了run()方法）。若將synchronized（同步）關鍵字作為方法的一個類型限制符使用，相互排斥現象會在對象這一級發生。在任何給定的時間，只有一個線程能使用一個對象的synchronized方法。在另一方面，一個synchronized方法進入以后，它首先會“鎖定”對象，防止其他任何synchronized方法再使用那個對象。只有退出了這個方法，才會將對象“解鎖”。在線程之間，我們仍然要負責實現更復雜的同步機制，方法是創建自己的“監視器”類。遞歸的synchronized方法可以正常運作。若線程的優先等級相同，則時間的“分片”不能得到保證。
26、我們不是象C++那樣控制聲明代碼塊，而是將訪問限定符（public，private和protected）置入每個類成員的定義里。若未規定一個“顯式”（明確的）限定符，就會默認為“友好的”（friendly）。這意味着同一個包里的其他元素也可以訪問它（相當於它們都成為C++的“friends”——朋友），但不可由包外的任何元素訪問。類——以及類內的每個方法——都有一個訪問限定符，決定它是否能在文件的外部“可見”。private關鍵字通常很少在Java中使用，因為與排斥同一個包內其他類的訪問相比，“友好的”訪問通常更加有用。然而，在多線程的環境中，對private的恰當運用是非常重要的。Java的protected關鍵字意味着“可由繼承者訪問，亦可由包內其他元素訪問”。注意Java沒有與C++的protected關鍵字等價的元素，后者意味着“只能由繼承者訪問”（以前可用“private protected”實現這個目的，但這一對關鍵字的組合已被取消了）。
27、嵌套的類。在C++中，對類進行嵌套有助於隱藏名稱，並便於代碼的組織（但C++的“命名空間”已使名稱的隱藏顯得多余）。Java的“封裝”或“打包”概念等價於C++的命名空間，所以不再是一個問題。Java 1.1引入了“內部類”的概念，它秘密保持指向外部類的一個句柄——創建內部類對象的時候需要用到。這意味着內部類對象也許能訪問外部類對象的成員，毋需任何條件——就好象那些成員直接隸屬於內部類對象一樣。這樣便為回調問題提供了一個更優秀的方案——C++是用指向成員的指針解決的。
28、由於存在前面介紹的那種內部類，所以Java里沒有指向成員的指針。
29、Java不存在“嵌入”（inline）方法。Java編譯器也許會自行決定嵌入一個方法，但我們對此沒有更多的控制權力。在Java中，可為一個方法使用final關鍵字，從而“建議”進行嵌入操作。然而，嵌入函數對於C++的編譯器來說也只是一種建議。
30、Java中的繼承具有與C++相同的效果，但采用的語法不同。Java用extends關鍵字標志從一個基礎類的繼承，並用super關鍵字指出准備在基礎類中調用的方法，它與我們當前所在的方法具有相同的名字（然而，Java中的super關鍵字只允許我們訪問父類的方法——亦即分級結構的上一級）。通過在C++中設定基礎類的作用域，我們可訪問位於分級結構較深處的方法。亦可用super關鍵字調用基礎類構建器。正如早先指出的那樣，所有類最終都會從Object里自動繼承。和C++不同，不存在明確的構建器初始化列表。但編譯器會強迫我們在構建器主體的開頭進行全部的基礎類初始化，而且不允許我們在主體的后面部分進行這一工作。通過組合運用自動初始化以及來自未初始化對象句柄的異常，成員的初始化可得到有效的保證。

　　public class Foo extends Bar { 　　 public Foo(String msg) { 　　 super(msg); // Calls base constructor
　　 } 　　 public baz(int i) { // Override
　　 super.baz(i); // Calls base method
　　 } 　　}

31、Java中的繼承不會改變基礎類成員的保護級別。我們不能在Java中指定public，private或者protected繼承，這一點與C++是相同的。此外，在衍生類中的優先方法不能減少對基礎類方法的訪問。例如，假設一個成員在基礎類中屬於public，而我們用另一個方法代替了它，那么用於替換的方法也必須屬於public（編譯器會自動檢查）。
32、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"); 　　 } }

33、Java中沒有virtual關鍵字，因為所有非static方法都肯定會用到動態綁定。在Java中，程序員不必自行決定是否使用

34、指針
JAVA語言讓編程者無法找到指針來直接訪問內存無指針，並且增添了自動的內存管理功能，從而有效地防止了c／c++語言中指針操作失誤，如野指針所造成的系統崩潰。但也不是說JAVA沒有指針，虛擬機內部還是使用了指針，只是外人不得使用而已。這有利於Java程序的安全。 
35、多重繼承 
C++支持多重繼承，這是C++的一個特征，它允許多父類派生一個類。盡管多重繼承功能很強，但使用復雜，而且會引起許多麻煩，編譯程序實現它也很不容易。Java不支持多重繼承，但允許一個類繼承多個接口(extends+implement)，實現了C++多重繼承的功能，又避免了C++中的多重繼承實現方式帶來的諸多不便。 
36、數據類型及類 
Java是完全面向對象的語言，所有函數和變量部必須是類的一部分。除了基本數據類型之外，其余的都作為類對象，包括數組。對象將數據和方法結合起來，把它們封裝在類中，這樣每個對象都可實現自己的特點和行為。而c++允許將函數和變量定義為全局的。此外，Java中取消了c/c++中的結構和聯合，消除了不必要的麻煩。 
37、自動內存管理 
Java程序中所有的對象都是用new操作符建立在內存堆棧上，這個操作符類似於C++的new操作符。下面的語句由一個建立了一個類Read的對象，然后調用該對象的work方法：

Read r＝new Read()；

r.work()；

語句

Read r＝new Read()；

在堆棧結構上建立了一個Read的實例。Java自動進行無用內存回收操作，不需要程序員進行刪除。而c++中必須由程序員釋放內存資源，增加了程序設計者的負擔。Java中當一個對象不被再用到時，無用內存回收器將給它加上標簽以示刪除。Java里無用內存回收程序是以線程方式在后台運行的，利用空閑時間工作。 
38、操作符重載 
Java不支持操作符重載。操作符重載被認為是C++的突出特征，在Java中雖然類大體上可以實現這樣的功能，但操作符重載的方便性仍然丟失了不少。Java語言不支持操作符重載是為了保持Java語言盡可能簡單。 
39、預處理功能 
Java不支持預處理功能。C/C++在編譯過程中都有一個預編譯階段，即眾所周知的預處理器。預處理器為開發人員提供了方便，但增加丁編譯的復雜性。JAVA虛擬機沒有預處理器，但它提供的引入語句(import)與C++預處理器的功能類似。 
40、 Java不支持缺省函數參數，C++支持 
在C中，代碼組織在函數中，函數可以訪問程序的全局變量。C++增加了類，提供了類算法，該算法是與類相連的函數，C++類方法與Java類方法十分相似，然而，由C++仍然支持C，所以不能阻止C++開發人員使用函數，結果函數和方法混合使用使得程序比較混亂。 Java沒有函數，作為一個比c++更純的面向對象的語言，Java強迫開發人員把所有例行程序包括在類中，事實上，用方法實現例行程序可激勵開發人員更好地組織編碼。 
41、字符串 
C和C++不支持字符串變量，在C和C++程序中使用null終止符代表字符串的結束，在Java中字符串是用類對象(String和StringBuffer)來實現的，這些類對象是Java語言的核心，用類對象實現字符串有以下幾個優點： 
■在整個系統中建立字符串和訪問字符串元素的方法是一致的； 
■字符串類是作為Java語言的一部分定義的，而不是作為外加的延伸部分； 
■Java字符串執行運行時檢空，可幫助排除一些運行時發生的錯誤； 
■可對字符串用“十”進行連接操作。
42、數組
java引入了真正的數組。不同於C++中利用指針實現的“偽數組”，Java引入了真正的數組，同時將容易造成麻煩的指針從語言中去掉，這將有利於防止在C++程序中常見的因為數組操作越界等指針操作而對系統數據進行非法讀寫帶來的不安全問題。
43、“goto“語句 
“可怕”的goto語句是C和C++的“遺物”，它是該語言技術上的合法部分，引用goto語句引起了程序結構的混亂，不易理解，goto語句子要用於無條件轉移子程序和多結構分支技術。鑒於以廣理由，Java不提供goto語句，它雖然指定goto作為關鍵字，但不支持它的使用，使程序簡潔易讀。 
44、類型轉換 
在C和C++中有時出現數據類型的隱含轉換，這就涉及了自動強制類轉換問題。例如，在c++中可將一浮點值賦予整型變量，並去掉其尾數。Java不支持C++中的自動強制類型轉換，如果需要，必須由程序顯式進行強制類型轉換。 
45、異常 
JAVA中的異常機制用於捕獲例外事件，增強系統容錯能力

try{

//可能產生例外的代碼

}catch(exceptionType name){

//處理

}

其中exceptionType表示異常類型。而C++則沒有如此方便的機...

 

 

三、Go和C++的區別 

1、變量初始化

現在開發語言的初始化都差不多，都能很方便的定義時初始化，循環也是如下面中的C++ for循環和Go語言中的"for : rang"形式基本一樣。 另外C++的auto，Go語言中的":="，都能省代碼的好東西。不過要多提一句，Go語言支持多重賦值,並且變量都是默認就已初始化好。同時，Go語言也支持指針，但它的指針要安全得多。

Golang 

var k int
fmt.Println(k)
 
mArr := []int{ 1, 2, 3}
var mMap = map[string]int {"a":1,"b":2}
fmt.Printf("array:%v\nmap:%v \n",mArr,mMap)
 
i := 10  
pi := &i  //*i
ppi := π  //**int
fmt.Println(i,*pi,**ppi)

結果:

0
array:[1 2 3]
map:map[a:1 b:2]
10 10 10

 C++

int mArr[] = { 1, 2, 3 };
  auto mList = vector < int > {1, 2, 3, 4};
  auto mMap = map < int, string > {{1, "aa"}, { 2, "bb" }};
 
  cout << "vector: ";
  for (const int& x : mList)
    cout << x << " ";
  cout << endl;
 
  cout << "map: ";
  for (const auto& mp : mMap)
    cout << mp.first << " " << (mp.second).c_str();
  cout << endl;

 

2、lambda表達式

lambda這東西在C++11中可是重點推薦的特性，非常的強大。Go語言自然也有，但對於閉包函數中函數外部變量的處理並沒有C++那么多種。 像C++分了四類:

[a,&b] a變量以值的方式唄捕獲，b以引用的方式被捕獲。 
[this] 以值的方式捕獲 this 指針。 
[&] 以引用的方式捕獲所有的外部自動變量。 
[=] 以值的方式捕獲所有的外部自動變量。 
[] 不捕獲外部的任何變量。

而Go語言默認就相當於"[=]",即，捕獲可見范圍內所有的外部變量。

Golang

mArr := []int{ 1, 2, 3}
  fun := func(i,v int){
    fmt.Printf("idx:%d value:%d \n",i,v)
  }
  for idx,val := range mArr{
    fun(idx,val)
  }

 C++    

int arr[] = { 1, 2, 3 };
  for_each(begin(arr), end(arr), [](int n){cout << n << endl; });
 
  cout << "---lambda_demo---" << endl;
 
  auto func = [](int n){cout << n << endl; };
  for_each(begin(arr), end(arr), func);

3、值順序遞增（iota)

iota這個小東西很有特點，兩種語言都支持且都是讓數據順序遞增，從功能上看C++的iota似乎更強大靈活些。 但有意思的是，似乎在Go語言中，iota的使用頻率要高得多，被大量的用於像const定義之類的地方，有意思。

Golang

const (
    Red = iota
    Green
    Blue
  )
  fmt.Println("Red:",Red," Gree:",Green," Blue:",Blue);

C++

int d[5] = { 0 };
std::iota(d, d + 5, 10);
 
cout << "iota_demo(): old : d[5] = { 0 } "<< endl;
cout << "iota_demo(): iota: d[5] = { ";
for each (int var in d)
{
  cout <<  var <<" ";
}
cout <<"} "<< endl;
 
char e[5] = { 'a' };
char f[5] = { 0 };
copy_n(e, 5, f);
 
cout << "iota_demo(): old : e[5] = { 'a' } " << endl;
cout << "iota_demo(): iota: e[5]  " << endl;
std::iota(e, e + 5, 'e');
for (size_t i = 0; i < 5; i++)
{
  cout << "                      old = " << f[i] << " iota = " << e[i] << endl;
}

結果:

iota_demo(): old : d[5] = { 0 }
iota_demo(): iota: d[5] = { 10 11 12 13 14 }
iota_demo(): old : e[5] = { 'a' }
iota_demo(): iota: e[5]
 iota = e
 iota = f
 iota = g
 iota = h
 iota = i

4、多值賦值及函數返回多值

這個功能在Go語言中相當方便，C++中則需要使用tuple和 tie等才能實現，有點麻煩，但效果是一樣的。

Golang

func tuple_demo()(int,string){
 
  a,b := 1,2
  fmt.Println("a:",a," b:",b);
 
  c,d := b,a
  fmt.Println("c:",c," d:",d);
 
  return 168, "函數返回的字符串"
}

 C++

tuple<int, string> tuple_demo(){
  tuple<int, string> ret;
  ret = make_tuple(168, "函數返回的字符串");
  cout << "tuple_demo(): " << get<0>(ret) << " " << (get<1>(ret)).c_str() << endl;
 
  auto triple = make_tuple(5, 6, 7);
  cout << "tuple_demo(): " << get<0>(triple) << " " << get<1>(triple) << " " << get<2>(triple) << endl;
 
  int ti;
  string ts;
  tie(ti, ts) = make_tuple(10, "xcl--將數字和字符賦值給兩個變量");
  cout << "tuple_demo(): " << ti << " " << ts.c_str() << endl;
 
  return ret;
}
 
//調用:
int ti;
string ts;
tie(ti, ts) = tuple_demo();
cout << "main() <- tuple_demo(): " << ti << " " << ts.c_str() << endl;

結果:

tuple_demo(): 168 函數返回的字符串
tuple_demo(): 5 6 7
tuple_demo(): 10 xcl--將數字和字符賦值給兩個變量
main() <- tuple_demo(): 168 函數返回的字符串

5、map查找

Go語言中map的查找特別方便. 要找個值，直接map[key]就出來了。C++也可以直接用find(key)的方式，但Go語言直接有個found的匿名變量，能告知是否有找到，這個要比C++去比end()，要直觀些，也可以少打些字。

Golang

var mMap = map[string]int {"a":1,"b":2,"c":3}
  val,found := mMap["b"]
  if found {
    fmt.Println("found :",val);
  }else{
    fmt.Println("not found");
  }

C++    

typedef map <string, int > map_str_int;
tuple<string, int, bool> mapfind_demo(map_str_int myMap, string key){
  
  map_str_int::iterator pos;   
  pos = myMap.find(key);
  if (pos == myMap.end()){
    return make_tuple("", 0, false);
  }
  else{
    return make_tuple(pos->first, pos->second, true);
  }
}

調用:

auto myMap = map_str_int{ { "aa", 1 }, { "bb", 2 }, { "cc", 3 } };
 
string mpKey;
int mpValue;
bool  mpFound = false;
tie(mpKey, mpValue, mpFound) = mapfind_demo(myMap, "bb");
 
if (mpFound){
  cout << "mapfind_demo: found" << endl;
}
else{
  cout << "mapfind_demo: not found" << endl;
}

6、可變參數

可變參數是指函數的最后一個參數可以接受任意個參數，我在用Go語言實現的args_demo()例子中，用了效果一樣的兩種不同

調用方法來展示Go語言對這個下的功夫。然后可以再看看通過C++模板實現的，一個比較有代表性的Print函數來感受感受C++

對這個可變參數的處理方式。

Golang  

auto myMap = map_str_int{ { "aa", 1 }, { "bb", 2 }, { "cc", 3 } };
 
string mpKey;
int mpValue;
bool  mpFound = false;
tie(mpKey, mpValue, mpFound) = mapfind_demo(myMap, "bb");
 
if (mpFound){
  cout << "mapfind_demo: found" << endl;
}
else{
  cout << "mapfind_demo: not found" << endl;
}

調用

args_demo(5,6,7,8);
mArr := []int{ 5, 6, 7,8}
args_demo(mArr[0],mArr[1:]...);
fmt.Println("fmtPrintln(): ", 1, 2.0, "C++11", "Golang");

執行結果

ars_demo first: 5
args: 6
args: 7
args: 8
ars_demo first: 5
args: 6
args: 7
args: 8
fmtPrintln():  1 2 C++11 Golang

C++

template<typename T> void fmtPrintln(T value){
  cout << value << endl;
}
 
template<typename T, typename... Args>
void fmtPrintln(T head, Args... args)
{
  cout << head << " ";
  fmtPrintln(args...);
}

調用

fmtPrintln("fmtPrintln(): ", 1, 2.0, "C++11", "Golang");

執行結果:

fmtPrintln():  1 2 C++11 Golang

7、回調函數

對比看看兩種語言函數的回調處理。實現方法沒啥差異。

Golang

type funcType func(string)
func printFunc(str string){
  fmt.Println( "callFunc() -> printFunc():",str)
}
func callFunc(arg string,f funcType){
  f(arg)
}
callFunc("回調就是你調我，我調它，大家一起玩。",printFunc)

C++

void printFunc(string arg){
  cout << "callFunc() -> printFunc():" << arg.c_str() << endl;
}
typedef void(*callf)(string);
void callFunc(callf pFunc, string arg){ //void(*pFunc)(string)
  pFunc(arg);
}
callFunc(printFunc, "回調就是你調我，我調它，大家一起玩。");

8、泛型

C++泛型就不用多說了，都知道有多強大。Go語言要加入這個不知道是啥時候的事，不過通過簡單的反射，還是可以實現類似的功能,但代碼有點長。

Golang

func compare(v1, v2 interface{}) (int, error) {
 
  switch v1.(type) {
  case int:
    if v1.(int) < v2.(int) {
      return -1, nil
    } else if v1.(int) == v2.(int) {
      return 0, nil
    }
  case int8:
    if v1.(int8) < v2.(int8) {
      return -1, nil
    } else if v1.(int8) == v2.(int8) {
      return 0, nil
    }
  case int32:
    if v1.(int32) < v2.(int32) {
      return -1, nil
    } else if v1.(int32) == v2.(int32) {
      return 0, nil
    }
 
  //省略......
 
  default:
    return -2, errors.New("未能處理的數據類型.")
  }
  return 1, nil
}

　調用:

v1 := 13
v2 := 53
ret, err := compare(v1, v2)
if err != nil {
  fmt.Println(err)
  return
}
switch ret {
case -1:
  fmt.Println("v1 < v2")
case 0:
  fmt.Println("v1 == v2")
case 1:
  fmt.Println("v1 > v2")
default:
  fmt.Println("defualt")
}

C++

template <typename T> int compare(const T v1, const T v2){
  if (v1 < v2){
    cout << "compare(): v1 < v2" << endl;
    return -1;
  }
  else if (v1 == v2){
    cout << "compare(): v1 == v2" << endl;
    return 0;
  }
  else{
    cout << "compare(): v1 > v2" << endl;
    return 1;
  }
}

調用:

int i1 = 5, i2 = 7;
double d1 = 52.5, d2 = 10.7;
compare(i1, i2);
compare(d1, d2);

9、數組和切片(sclie)

數組/切片Go語言做得非常靈活，不一一舉例，這里主要可以看看C++的。我用copy_n,copy_if 模擬二下簡單的切片功能。

Golang 

a := [5]int{ 1, 2, 3, 4, 5 }
    b := a[:3]
    c := a[1:2]
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)   

運行結果:

[1 2 3 4 5]
[1 2 3]
[2]

C++    

int a[5] = { 1, 2, 3, 4, 5 };
  int b[3] = { 0 };
  int c[2] = { 0 };
 
 
  cout << "a[5] = { 1, 2, 3, 4, 5 }" << endl;
  cout << "array[:end_pos]: b = array[:3]" << endl;
  // array[:end_pos]
  copy_n(a, 3, b);
  for each (int var in b)
  {
    cout << " " << var;
  }
  cout << endl;
 
 
  cout << "a[5] = { 1, 2, 3, 4, 5 }" << endl;
  cout << "array[begin_pos:end_pos]: c = array[1,2] " << endl;
  // array[begin_pos:end_pos]
  int begin_pos = 1;
  int subLen = sizeof(c) / sizeof(c[0]);
  int end_pos = begin_pos + subLen;
  copy_if(a + begin_pos, a + end_pos, c, [](int v){return true; });
  
  for each (int var in c)
  {
    cout << " " << var ;
  }
  cout << endl;

運行結果:    

a[5] = { 1, 2, 3, 4, 5 }
array[:end_pos]: b = array[:3]
 1 2 3
a[5] = { 1, 2, 3, 4, 5 }
array[begin_pos:end_pos]: c = array[1,2]
 2 3

很粗淺的分別實現下這幾個點，體會是C++很強大，Golang更純粹，少即是多。

10. 多參數返回

還記得在C里面為了回饋多個參數，不得不開辟幾段指針傳到目標函數中讓其操作么？在Go里面這是完全不必要的。而且多參數的支持讓Go無需使用繁瑣的exceptions體系，一個函數可以返回期待的返回值加上error，調用函數后立刻處理錯誤信息，清晰明了。

11. Array，slice，map等內置基本數據結構

如果你習慣了Python中簡潔的list和dict操作，在Golang中，你不會感到孤單。一切都是那么熟悉，而且更加高效。如果你是C++程序員，你會發現你又找到了STL的vector 和 map這對朋友。

12. Interface

Golang最讓人贊嘆不易的特性，就是interface的設計。任何數據結構，只要實現了interface所定義的函數，自動就implement了這個interface，沒有像Java那樣冗長的class申明，提供了靈活太多的設計度和OO抽象度，讓你的代碼也非常干凈。千萬不要以為你習慣了Java那種一條一條加implements的方式，感覺還行，等接口的設計越來越復雜的時候，無數Bug正在后面等着你。

同時，正因為如此，Golang的interface可以用來表示任何generic的東西，比如一個空的interface，可以是string可以是int，可以是任何數據類型，因為這些數據類型都不需要實現任何函數，自然就滿足空interface的定義了。加上Golang的type assertion，可以提供一般動態語言才有的duck typing特性， 而仍然能在compile中捕捉明顯的錯誤。

13. OO

Golang本質上不是面向對象語言，它還是過程化的。但是，在Golang中， 你可以很輕易的做大部分你在別的OO語言中能做的事，用更簡單清晰的邏輯。是的，在這里，不需要class，仍然可以繼承，仍然可以多態，但是速度卻快得多。因為本質上，OO在Golang中，就是普通的struct操作。

14. Goroutine

這個幾乎算是Golang的招牌特性之一了，我也不想多提。如果你完全不了解Goroutine，那么你只需要知道，這玩意是超級輕量級的類似線程的東西，但通過它，你不需要復雜的線程操作鎖操作，不需要care調度，就能玩轉基本的並行程序。在Golang里，觸發一個routine和erlang spawn一樣簡單。基本上要掌握Golang，以Goroutine和channel為核心的內存模型是必須要懂的。不過請放心，真的非常簡單。

15. 更多現代的特性

和C比較，Golang完全就是一門現代化語言，原生支持的Unicode, garbage collection, Closures(是的，和functional programming language類似), function是first class object，等等等等。