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’ssize

通過下腳標訪問其中的數組成員組

通過 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.================
");
// 序列化 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
",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.================
");
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
"
,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.================
");
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
",retrieveResp2.buddiescnt());
printf("Repeated Size = %d
",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
", it->groupid());
printf("UserInfo->acctID = %I64d, UserInfo->name = %s, UserInfo->status = %d
"
, 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，這樣的變量名看上去就像駱駝峰一樣此起彼伏，故得名。

總結

以上是生活随笔為你收集整理的protobuf 使用的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。