1. 定義 .proto 文件：
首先我們需要編寫一個 proto 文件，定義我們程序中需要處理的結構化數據，在 protobuf 的術語中，結構化數據被稱為 Message。proto 文件非常類似 java 或者 C 語言的 數據定義，可以使用 C或 C++風格的注釋,下面是proto文件的例子
package tutorial; option java_package = "com.example.tutorial"; option java_outer_classname = "AddressBookProtos"; message Person { required string name = 1; required int32 id = 2; // Unique ID number for this person. optional string email = 3; enum PhoneType { MOBILE = 0; HOME = 1; WORK = 2; } message PhoneNumber { required string number = 1; optional PhoneType type = 2 [default = HOME]; } repeated PhoneNumber phone = 4; } // Our address book file is just one of these. message AddressBook { repeated Person person = 1; }
一個 proto 文件主要包含 package定義、 message定義和屬性定義三個部分，還有一些 可選項。
1.1 定義 package
Package在 c++中對應 namespace。 對於 Java，包聲明符會變為 java 的一個包，除非在 .proto 文件中提供了一個明確有 java_package。
1.2 定義 message
Message在 C++中對應 class。Message中定義的全部屬性在 class中全部為 private 的。
Message的嵌套使用可以嵌套定義，也可以采用先定義再使用的方式。
Message的定義末尾可以采用 java方式在末尾不加“ ;”，也可以采用 C++定義方式在末尾加 上“;”，這兩種方式都兼容，建議采用 java定義方式。
向.proto 文件添加注釋，可以使用 C/C++/java風格的雙斜杠（ // ） 語法格式。
1.3 定義屬性
屬性定義分為四部分：標注 +類型+屬性名 +屬性順序號 +[默認值 ]，其示意如下所示
其中屬性名與 C++和 java語言類似，不再解釋；下面分別對標注、類型和屬性順序號加 以詳細介紹。 其中包名和消息名以及其中變量名均采用 java 的命名規則——駝峰式命名法。
1.3.1 標注
標注包括“ required”、“optional”、“repeated”三種，其中
required 表示該屬性為必選屬性，否則對應的 message“未初始化”，debug 模式下導致 斷言， release模式下解析失敗；
optional 表示該屬性為可選屬性，不指定，使用默認值（ int 或者 char 數據類型默認為 0,string 默認為空， bool 默認為 false，嵌套 message默認為構造，枚舉則為第一個）
repeated 表示該屬性為重復字段，可看作是動態數組，類似於 C++中的 vector。
如果為 optional 屬性，發送端沒有包含該屬性，則接收端在解析式采用默認值。對於默認值，如果已設置默認值，則采用默認值，如果未設置，則類型特定的默認值為使用，例如 string 的默認值為 ” ”。
1.3.2 類型
Protobuf 的屬性基本包含了 c++需要的所有基本屬性類型。
1.3.2.1 Union 類型定義
Protobuf 沒有提供 union 類型，如果希望使用 union 類型，可以采用 enum 和 optional 屬性定義的方式。 例如，如果已經定義了 Foo、Bar、Baz等 message，則可以采用如下定義。
message OneMessage { enum Type { FOO = 1; BAR = 2; BAZ = 3; } // Identifies which field is filled in. required Type type = 1; // One of the following will be filled in. optional Foo foo = 2; optional Bar bar = 3; optional Baz baz = 4; }
1.3.3 屬性順序號
屬性順序號是 protobuf 為了提高數據的壓縮和可選性等功能定義的， 需要按照順序進行 定義，且不允許有重復。
1.4. 其他
1.4.1 import 可選項
Import 可選項用於包含其它 proto 文件中定義的 message或 enum等。標准格式如 下
import “phonetype.proto ”;
使用時，import 的文件必須與當前文件處於同一個文件夾下， protoc 無法完成不處於同 一個文件夾下的 import 選項。
1.4.2 packed
packed (field option): 如果該選項在一個整型基本類型上被設置為真， 則采用更緊湊的編 碼方式。當然使用該值並不會對數值造成任何損失。在 2.3.0 版本之前，解析器將會忽略那些非期望的包裝值。因此，它不可能在不破壞現有框架的兼容性上而改變壓縮格式。 在 2.3.0 之后，這種改變將是安全的，解析器能夠接受上述兩種格式，但是在 處理 protobuf 老版本 程序時，還是要多留意一下。
repeated int32 samples = 4 [packed=true];
1.4.3 default
[default = default_value]: optional 類型的字段，如果在序列化時沒有被設置，或者是老版 本的消息中根本不存在該字段，那么在反序列化該類型的消息是， optional 的字段將被賦予類型相關的缺省值，如 bool 被設置為 false，int32 被設置為 0。Protocol Buffer 也支持自定義 的缺省值，如：
optional int32 result_per_page = 3 [default = 10];
1.5 大數據量使用建議
在使用過程中發現，對於大數據量的協議報文（循環超過10000 條），如果 repeated 修飾的屬性為對象類型 （諸如 message 、Bytes、string 等稱為“對象類型”，其余的諸如 int32、 int64、float 等等稱為“原始類型” ）時，效率非常低，而且占用的進程內存也非常大，建議 采用如下方式優化。
1.5.1 repeated message類型
在 message 中對 repeated 標識的 message類型的字段需要做大量 ADD操作時，可以考 慮盡量避免嵌套 message或者減少嵌套的 message個數。 實例如下所示：
1.5.2 repeated raw 類型
在 message中對 repeated 標識的原始數據類型的字段需要做大量 ADD操作（例如超過3千）時，可以考慮預分配數據空間，避免重復大量地分配空間。 實例如下所示：
1.5.3 repeated Bytes類型
在 protobuf 中，Bytes基於 C++ STL中的 string 實現，因為 string 內存管理的原因，程序 空間往往較大。所以應用如果有很多 repeated Bytes類型的字段的話，進程顯示耗用大量內存，這與 vector的情況基本一致。
1.6 Protocol Buffer 消息升級原則
在實際的開發中會存在這樣一種應用場景， 即消息格式因為某些需求的變化而不得不進行必要的升級， 但是有些使用原有消息格式的應用程序暫時又不能被立刻升級， 這便要求我們在升級消息格式時要遵守一定的規則， 從而可以保證基於新老消息格式的新老程序同時運行。規則如下：
1. 不要修改已經存在字段的標簽號。
2. 任何新添加的字段必須是 optional 和 repeated 限定符，否則無法保證新老程序在 互相傳遞消息時的消息兼容性。
3. 在原有的消息中， 不能移除已經存在的 required 字段，optional 和 repeated 類型的 字段可以被移除，但是他們之前使用的標簽號必須被保留，不能被新的字段重用。
4. int32、uint32、int64、uint64 和 bool 等類型之間是兼容的， sint32 和 sint64 是兼容 的，string 和 bytes 是兼容的， fixed32 和 sfixed32，以及 fixed64 和 sfixed64之間是兼容的， 這意味着如果想修改原有字段的類型時， 為了保證兼容性， 只能將其修改為與其原有類型兼 容的類型，否則就將打破新老消息格式的兼容性。
5. optional 和 repeated 限定符也是相互兼容的。
第2章 編譯 .proto文件
可以通過定義好的 .proto 文件來生成 Java、Python、C++代碼，需要基於 .proto 文件運行 protocol buffer 編譯器 protoc。運行的命令如下所示：
protoc --proto_path=IMPORT_PATH --cpp_out=DST_DIR --java_out=DST_DIR --python_out=DST_DIR path/to/file.proto
MPORT_PATH聲明了一個 .proto 文件所在的具體目錄。 如果忽略該值， 則使用當前目錄。
如果有多個目錄則可以 對 --proto_path 寫多次，它們將會順序的被訪問並執行導入。 -I=IMPORT_PATH是它的簡化形式。
當然也可以提供一個或多個輸出路徑： --cpp_out 在目標目錄 DST_DIR 中 產 生 C++ 代 碼 ，
你必須提供一個或多個 .proto 文件作為輸入。多個 .proto 文件能夠一次全部聲明。雖然 這些文件是相對於當前目錄來命名的，每個文件必須在一個 IMPORT_PATH中，只有如此編 譯器才可以決定它的標准名稱。
第3章 使用 message
3.1 類成員變量的訪問
在生成的 .h 文件中定義了類成員的訪問方法。例如，對於 Person類，定義了 name、id、 email、phone 等成員的訪問方法。 獲取成員變量值直接采用使用成員變量名（全部為小寫） ，設置成員變量值，使用在成 員變量名前加 set_的方法。
對於普通成員變量（ required 和 optional）提供 has_方法判斷變量值是否被設置；提供 clear_方法清除設置的變量值。
對於 string 類型，提供多種 set_方法，其參數不同。同時，提供了一個 mutable_方法， 返回變量值的可修改指針。
對於 repeated 變量，提供了其它一些特殊的方法：
_size方法：返回 repeated field’s size
通過下腳標訪問其中的數組成員組
通過 mutable_的方法返回指針
_add 方法：增加一個成員。
// name inline bool has_name() const; inline void clear_name(); inline const ::std::string& name() const; inline void set_name(const ::std::string& value); inline void set_name(const char* value); inline ::std::string* mutable_name(); // id inline bool has_id() const; inline void clear_id(); inline int32_t id() const; inline void set_id(int32_t value); // email inline bool has_email() const; inline void clear_email(); inline const ::std::string& email() const; inline void set_email(const ::std::string& value); inline void set_email(const char* value); inline ::std::string* mutable_email(); // phone inline int phone_size() const; inline void clear_phone(); inline const ::google::protobuf::RepeatedPtrField< ::tutorial::Person_PhoneNumber >& phone() const; inline ::google::protobuf::RepeatedPtrField< ::tutorial::Person_PhoneNumber >* mutable_phone(); inline const ::tutorial::Person_PhoneNumber& phone(int index) const; inline ::tutorial::Person_PhoneNumber* mutable_phone(int index); inline ::tutorial::Person_PhoneNumber* add_phone();
3.2 標准 message 方法
生成的 .h 文件中的 class都繼承自 ::google::protobuf::Message 類，Message類提供了一些 方法可以檢查或者操作整個 message，包括
bool IsInitialized() const; 檢查是否所有 required 變量都已經初始化；
string DebugString() const; 返回 message的可閱讀的表示，主要用於調試程序；
void CopyFrom(const Person& from); 使用一個 message的值覆蓋本message；
void Clear(); 清空 message的所有成員變量值。
3.3 編碼和解碼函數
每個 message類都提供了寫入和讀取 message數據的方法，包括
bool SerializeToString(string* output) const; 把 message編碼進 output 。
bool ParseFromString(const string& data); 從 string 解碼到 message
bool SerializeToArray(char* buf,int size) const; 把 message編碼進數組 buf.
bool ParseFromArray(const char* buf,int size); 把 buf 解碼到 message。此解 碼方法效率較 ParseFromString高很多，所以一般用這種方法解碼。
bool SerializeToOstream(ostream* output) const; 把 message編碼進 ostream
bool ParseFromIstream(istream* input); 從 istream 解碼到 message
備注：發送接收端所使用的加碼解碼方法不一定非得配對，即發送端用 SerializeToString 接收端不一定非得用 ParseFromString ，可以使用其他解碼方法。
例子：
簡單 message 生成的 C++代碼
這里先定義一個最簡單的 message，其中只是包含原始類型的字段。
option optimize_for = LITE_RUNTIME; message LogonReqMessage { required int64 acctID = 1; required string passwd = 2; }
由於我們在 MyMessage 文件中定義選項 optimize_for 的值為 LITE_RUNTIME，因此由 該 .proto 文 件 生 成 的 所 有 C++類 的 父 類 均 為 ::google::protobuf::MessageLite ， 而 非::google::protobuf::Message。MessageLite類是 Message的父類，在 MessageLite中將缺少 Protocol Buffer 對反射的支持，而此類功能均在 Message類中提供了具體的實現。使用 LITE 版本的 Protocol Buffer。這樣不僅可以得到更高編碼效率，而且生成代碼編譯后所占用的資 源也會更少，至於反射所能帶來的靈活性和極易擴展性。下面我們來看一下由 message LogonReqMessage生成的 C++類的部分聲明，以及常用方法的說明性注釋。
class LogonReqMessage : public ::google::protobuf::MessageLite { public: LogonReqMessage(); virtual ~LogonReqMessage(); // implements Message ---------------------------------------------- // 下面的成員函數均實現自 MessageLite 中的虛函數。 // 創建一個新的 LogonReqMessage對象，等同於 clone。 LogonReqMessage* New() const; // 用另外一個 LogonReqMessage對象初始化當前對象，等同於賦值操作符重載（ operator=） void CopyFrom(const LogonReqMessage& from); // 清空當前對象中的所有數據，既將所有成員變量置為未初始化狀態。 void Clear(); // 判斷當前狀態是否已經初始化。 bool IsInitialized() const; // 在給當前對象的所有變量賦值之后，獲取該對象序列化后所需要的字節數。 int ByteSize() const; // 獲取當前對象的類型名稱。 ::std::string GetTypeName() const; // required int64 acctID = 1; // 下面的成員函數都是因 message中定義的 acctID 字段而生成。 // 這個靜態成員表示 AcctID 的標簽值。命名規則是 k + FieldName(駝峰規則) + FieldNumber。 static const int kAcctIDFieldNumber = 1; // 如果 acctID字段已經被設置返回 true ，否則 false。 inline bool has_acctid() const; // 執行該函數后 has_acctid 函數將返回 false，而下面的 acctid 函數則返回 acctID 的缺省值。 inline void clear_acctid(); // 返回 acctid 字段的當前值，如果沒有設置則返回 int64 類型的缺省值。 inline ::google::protobuf::int64 acctid() const; // 為 acctid 字段設置新值，調用該函數后 has_acctid 函數將返回 true。 inline void set_acctid(::google::protobuf::int64 value); // required string passwd = 2; // 下面的成員函數都是因 message中定義的 passwd 字段而生成。這里生成的函數和上面 acctid // 生成的那組函數基本相似。因此這里只是列出差異部分。 static const int kPasswdFieldNumber = 2; inline bool has_passwd() const; inline void clear_passwd(); inline const ::std::string& passwd() const; inline void set_passwd(const ::std::string& value); // 對於字符串類型字段設置 const char* 類型的變量值。 inline void set_passwd(const char* value); inline void set_passwd(const char* value, size_t size); // 可以通過返回值直接給 passwd 對象賦值。在調用該函數之后 has_passwd 將返回 true。 inline ::std::string* mutable_passwd(); // 釋放當前對象對 passwd 字段的所有權，同時返回 passwd 字段對象指針。調用此函數之后， passwd 字段對象 // 的所有權將移交給調用者。此后再調用 has_passwd 函數時將返回 false。 inline ::std::string* release_passwd(); private: ... ... };
下面是讀寫 LogonReqMessage對象的 C++測試代碼和說明性注釋
void testSimpleMessage() { printf("==================This is simple message.================\n"); // 序列化 LogonReqMessage對象到指定的內存區域。 LogonReqMessage logonReq; logonReq.set_acctid(20); logonReq.set_passwd("Hello World"); // 提前獲取對象序列化所占用的空間並進行一次性分配，從而避免多次分配 // 而造成的性能開銷。通過該種方式，還可以將序列化后的數據進行加密。 // 之后再進行持久化，或是發送到遠端。 int length = logonReq.ByteSize(); char* buf = new char[length]; logonReq.SerializeToArray(buf,length); // 從內存中讀取並反序列化 LogonReqMessage對象，同時將結果打印出來。 LogonReqMessage logonReq2; logonReq2.ParseFromArray(buf,length); printf("acctID = %I64d, password = %s\n",logonReq2.acctid(),logonReq2.passwd().c_str()); delete [] buf; }
3.5 嵌套 message 生成的 C++代碼
enum UserStatus { OFFLINE = 0; ONLINE = 1; } enum LoginResult { LOGON_RESULT_SUCCESS = 0; LOGON_RESULT_NOTEXIST = 1; LOGON_RESULT_ERROR_PASSWD = 2; LOGON_RESULT_ALREADY_LOGON = 3; LOGON_RESULT_SERVER_ERROR = 4; } message UserInfo { required int64 acctID = 1; required string name = 2; required UserStatus status = 3; } message LogonRespMessage { required LoginResult logonResult = 1; required UserInfo userInfo = 2; // 這里嵌套了 UserInfo 消息。 }
對於上述消息生成的 C++代碼，UserInfo 因為只是包含了原始類型字段，因此和上例中 的 LogonReqMessage沒有太多的差別，這里也就不在重復列出了。由於 LogonRespMessage 消息中嵌套了 UserInfo類型的字段，在這里我們將僅僅給出該消息生成的 C++代碼和關鍵性 注釋。
class LogonRespMessage : public ::google::protobuf::MessageLite { public: LogonRespMessage(); virtual ~LogonRespMessage(); // implements Message ---------------------------------------------- ... ... // 這部分函數和之前的例子一樣。 // required .LoginResult logonResult = 1; // 下面的成員函數都是因 message中定義的 logonResult 字段而生成。 // 這一點和前面的例子基本相同，只是類型換做了枚舉類型 LoginResult。 static const int kLogonResultFieldNumber = 1; inline bool has_logonresult() const; inline void clear_logonresult(); inline LoginResult logonresult() const; inline void set_logonresult(LoginResult value); // required .UserInfo userInfo = 2; // 下面的成員函數都是因 message中定義的 UserInfo 字段而生成。 // 這里只是列出和非消息類型字段差異的部分。 static const int kUserInfoFieldNumber = 2; inline bool has_userinfo() const; inline void clear_userinfo(); inline const ::UserInfo& userinfo() const; // 可以看到該類並沒有生成用於設置和修改 userInfo 字段 set_userinfo 函數，而是將該工作 // 交給了下面的 mutable_userinfo 函數。因此每當調用函數之后， Protocol Buffer 都會認為 // 該字段的值已經被設置了，同時 has_userinfo 函數亦將返回 true。在實際編碼中，我們可以 // 通過該函數返回 userInfo 字段的內部指針，並基於該指針完成 userInfo 成員變量的初始化工作。 inline ::UserInfo* mutable_userinfo(); inline ::UserInfo* release_userinfo(); private: ... ... };
下面是讀寫 LogonRespMessage對象的 C++測試代碼和說明性注釋
void testNestedMessage() { printf("==================This is nested message.================\n"); LogonRespMessage logonResp; logonResp.set_logonresult(LOGON_RESULT_SUCCESS); // 如上所述，通過 mutable_userinfo 函數返回 userInfo 字段的指針，之后再初始化該對象指針。 UserInfo* userInfo = logonResp.mutable_userinfo(); userInfo->set_acctid(200); userInfo->set_name("Tester"); userInfo->set_status(OFFLINE); int length = logonResp.ByteSize(); char* buf = new char[length]; logonResp.SerializeToArray(buf,length); LogonRespMessage logonResp2; logonResp2.ParseFromArray(buf,length); printf("LogonResult = %d, UserInfo->acctID = %I64d, UserInfo->name = %s, UserInfo->status = %d\n" ,logonResp2.logonresult(),logonResp2.userinfo().acctid(),logonResp2.userinfo().name().c_str(),logonResp2.userinfo() .status()); delete [] buf; }
3.6 repeated 嵌套 message 生成的 C++代碼
message BuddyInfo { required UserInfo userInfo = 1; required int32 groupID = 2; } message RetrieveBuddiesResp { required int32 buddiesCnt = 1; repeated BuddyInfo buddiesInfo = 2; }
對於上述消息生成的代碼， 我們將只是針對 RetrieveBuddiesResp消息所對應的 C++代碼 進 行 詳 細 說 明 ， 其 余 部 分 和 前 面 小 節 的 例 子 基 本 相 同 ， 可 直 接 參 照 。 而 對 於 RetrieveBuddiesResp類中的代碼，我們也僅僅是對 buddiesInfo 字段生成的代碼進行更為詳細 的解釋。
class RetrieveBuddiesResp : public ::google::protobuf::MessageLite { public: RetrieveBuddiesResp(); virtual ~RetrieveBuddiesResp(); ... ... // 其余代碼的功能性注釋均可參照前面的例子。 // repeated .BuddyInfo buddiesInfo = 2; static const int kBuddiesInfoFieldNumber = 2; // 返回數組中成員的數量。 inline int buddiesinfo_size() const; // 清空數組中的所有已初始化成員，調用該函數后， buddiesinfo_size 函數將返回 0。 inline void clear_buddiesinfo(); // 返回數組中指定下標所包含元素的引用。 inline const ::BuddyInfo& buddiesinfo(int index) const; // 返回數組中指定下標所包含元素的指針，通過該方式可直接修改元素的值信息。 inline ::BuddyInfo* mutable_buddiesinfo(int index); // 像數組中添加一個新元素。返回值即為新增的元素，可直接對其進行初始化。 inline ::BuddyInfo* add_buddiesinfo(); // 獲取 buddiesInfo 字段所表示的容器，該函數返回的容器僅用於遍歷並讀取，不能直接修改。 inline const ::google::protobuf::RepeatedPtrField< ::BuddyInfo >& buddiesinfo() const; // 獲取 buddiesInfo 字段所表示的容器指針，該函數返回的容器指針可用於遍歷和直接修改。 inline ::google::protobuf::RepeatedPtrField< ::BuddyInfo >* mutable_buddiesinfo(); private: ... ... };
下面是讀寫 RetrieveBuddiesResp對象的 C++測試代碼和說明性注釋
void testRepeatedMessage() { printf("==================This is repeated message.================\n"); RetrieveBuddiesResp retrieveResp; retrieveResp.set_buddiescnt(2); BuddyInfo* buddyInfo = retrieveResp.add_buddiesinfo(); buddyInfo->set_groupid(20); UserInfo* userInfo = buddyInfo->mutable_userinfo(); userInfo->set_acctid(200); userInfo->set_name("user1"); userInfo->set_status(OFFLINE); buddyInfo = retrieveResp.add_buddiesinfo(); buddyInfo->set_groupid(21); userInfo = buddyInfo->mutable_userinfo(); userInfo->set_acctid(201); userInfo->set_name("user2"); userInfo->set_status(ONLINE); int length = retrieveResp.ByteSize(); char* buf = new char[length]; retrieveResp.SerializeToArray(buf,length); RetrieveBuddiesResp retrieveResp2; retrieveResp2.ParseFromArray(buf,length); printf("BuddiesCount = %d\n",retrieveResp2.buddiescnt()); printf("Repeated Size = %d\n",retrieveResp2.buddiesinfo_size()); // 這里僅提供了通過容器迭代器的方式遍歷數組元素的測試代碼。 // 事實上，通過 buddiesinfo_size 和 buddiesinfo 函數亦可循環遍歷。 RepeatedPtrField<BuddyInfo>* buddiesInfo = retrieveResp2.mutable_buddiesinfo(); RepeatedPtrField<BuddyInfo>::iterator it = buddiesInfo->begin(); for (; it != buddiesInfo->end(); ++it) { printf("BuddyInfo->groupID = %d\n", it->groupid()); printf("UserInfo->acctID = %I64d, UserInfo->name = %s, UserInfo->status = %d\n" , it->userinfo().acctid(), it->userinfo().name().c_str(),it->userinfo().status()); } delete [] buf; }
3.7 寫入 message
#include"addressbook.pb.h" #include<iostream> #include<unistd.h> #include<sys/types.h> #include<sys/stat.h> #include<fcntl.h> #include<stdio.h> #include<string.h> #include<sys/socket.h> #include<netinet/in.h> #include<arpa/inet.h> #include<stdlib.h> #include<string> using namespace std; { // 填充消息 void PromptInput(tutorial::Person* person){ person->set_id(2008); person->set_name("Joe"); person->set_email("joepayne@163.com"); int i=0; while(i<3){ tutorial::Person::PhoneNumber* phone_number=person->add_phone(); phone_number->set_number("13051889399"); phone_number->set_type(tutorial::Person::MOBILE); i++; } } } int main(){ { // 建立 SOCKET連接 } int n=0; tutorial::AddressBook msg1; PromptInput(msg1.add_person()); string s; int uSize; { // 發送 1 個消息包 while(n<1){ // 兩次發送過程 { msg1.SerializeToString(&s); // 把消息包的長度發送出去 usize=s.size(); write(sockfd,&uSize,sizeof(uSize)); // 把消息包發送出去 // 注意如果消息數據比較大的話，一次 IO寫操作不能寫完，那就需要自己另作處理了 write(sockfd,s.data(),s.size()); } // 輸出包的大小 cout<<"Message size:"<<uSize<<endl; n++; } return 0; }
3.8 讀出 message
#include"addressbook.pb.h" #include<iostream> #include<unistd.h> #include<sys/types.h> #include<sys/stat.h> #include<fcntl.h> #include<stdio.h> #include<string.h> #include<stdlib.h> #include<sys/socket.h> #include<netinet/in.h> #include<arpa/inet.h> #include<stdlib.h> using namespace std; // 列出消息中的所有數據 void List(const tutorial::AddressBook& address_book){ for(int i=0;i<address_book.person_size();i++){ const tutorial::Person& person=address_book.person(i); cout<<"Person ID:"<<person.id()<<endl; cout<<"Name:"<<person.name()<<endl; if(person.has_email()){ cout<<"E-mail address:"<<person.email()<<endl; } for(int j=0;j<person.phone_size();j++){ const tutorial::Person::PhoneNumber& phone_number=person.phone(j); switch(phone_number.type()){ case tutorial::Person::MOBILE: cout<<"Mobile phone:"; break; case tutorial::Person::HOME: cout<<"Home phone:"; break; case tutorial::Person::WORK: cout<<"WOrk Phone:"; break; } cout<<phone_number.number()<<endl; } } } int main(){ { // 建立連接 } tutorial::AddressBook msg2; int uLen; char* uData; int nRead; { // 讀取數據 // 先讀取消息包的長度信息 while((nRead=read(connfd,&uLen,sizeof(uLen)))>0){ cout<<"The length of the message is:"<<uLen<<endl; // 根據消息包的長度信息，分配適當大小的緩沖區來接收消息包數據 uData=(char*)malloc(uLen); // 注意此次 read 可能一次性讀不完一個包，如果包比較大的話，這樣的話就得自己再做進一步處 理 read(connfd,uData,uLen); // 解碼操 作，從 緩沖 區中解 到 msg2 消息空間中去， 此 處用 ParseFromArray 而沒有使用ParseFromString 因為前者的效率相對於后者效率要高很多。 if(!msg2.ParseFromArray(uData,uLen)){ cout<<”Parse failed!”<<endl; return -1; } free(uData); uData=NULL; // 輸出消息的數據信息 List(msg2); } } return 0; }
附錄：駝峰命名法
駝峰命名法就是當變量名或函式名是由一個或多個單字連結在一起， 而構成的唯一識別 字時，第一個單字以小寫字母開始； 第二個單字的首字母大寫或每一個單字的首字母都采用大寫字母， 例如：myFirstName、 myLastName，這樣的變量名看上去就像駱駝峰一樣此起彼伏，故得名。