您现在的位置： 主页 > 上位机技术 > 比特币源码学习笔记（二）章
本文所属标签:
为本文创立个标签吧:

比特币源码学习笔记（二）章

来源： 网络用户发布，如有版权联系网管删除　2018-04-10　
进入嵌入式论坛与网友讨论>>

比特币源码学习笔记（二）章

本章继上一章交易创建之后介绍比特币客户端序列化数据的过程。

比特币客户端所有的序列化函数均在seriliaze.h中实现。其中，CDataStream类是数据序列化的核心结构。

CDataStream

CDataStream拥有一个字符类容器用来存放序列化之后的数据。它结合一个容器类型和一个流（stream）界面以处理数据。它使用6个成员函数实现这一功能：

 

[cpp] view plain copy
 
  1. class CDataStream  
  2. {  
  3. protected:  
  4.     typedef vector<char, secure_allocator<char> > vector_type;  
  5.     vector_type vch;  
  6.     unsigned int nReadPos;  
  7.     short state;  
  8.     short exceptmask;  
  9. public:  
  10.     int nType;  
  11.     int nVersion;  
  12.     //......  
  13. }  

 

  • vch存有序列化后的数据。它是一个拥有自定义内存分配器的字符容器类型。该内存分配器将由该容器的实现在需要分配/释放内存时调用。该内存分配器会在向操作系统释放内存前清空内存中的数据以防止本机的其他进程访问此数据，从而保证数据存储的安全性。该内存分配器的实现在此不进行讨论，读者可于serialize.h自行查找。
  • nReadPos是vch读取数据的起始位置。
  • state是错误标识。该变量用于指示在序列化/反序列化当中可能出现的错误。
  • exceptmask是错误掩码。它初始化为ios::badbit | ios::failbit。与state类似，它被用于指示错误种类。
  • nType的取值为SER_NETWORK，SER_DISK，SER_GETHASH，SER_SKIPSIG，SER_BLOCKHEADERONLY之一，其作用为通知CDataStream进行具体某种序列化操作。这5个符号被定义在一个枚举类型enum里。每个符号均为一个int类型（4字节），并且其值为2的次方。
[cpp] view plain copy
 
  1. enum  
  2. {  
  3.     // primary actions  
  4.     SER_NETWORK         = (1 << 0),  
  5.     SER_DISK            = (1 << 1),  
  6.     SER_GETHASH         = (1 << 2),  
  7.   
  8.     // modifiers  
  9.     SER_SKIPSIG         = (1 << 16),  
  10.     SER_BLOCKHEADERONLY = (1 << 17),  
  11. };  
  • nVersion是版本号。

CDataStream::read()与CDataStream::write()

成员函数CDataStream::read()和CDataStream::write()是用于执行序列化/反序列化CDataStream对象的低级函数。
[cpp] view plain copy
 
  1. CDataStream& read(char* pch, int nSize)  
  2.    {  
  3.        // Read from the beginning of the buffer  
  4.        assert(nSize >= 0);  
  5.        unsigned int nReadPosNext = nReadPos + nSize;  
  6.        if (nReadPosNext >= vch.size())  
  7.        {  
  8.            if (nReadPosNext > vch.size())  
  9.            {  
  10.                setstate(ios::failbit, "CDataStream::read() : end of data");  
  11.                memset(pch, 0, nSize);  
  12.                nSize = vch.size() - nReadPos;  
  13.            }  
  14.            memcpy(pch, &vch[nReadPos], nSize);  
  15.            nReadPos = 0;  
  16.            vch.clear();  
  17.            return (*this);  
  18.        }  
  19.        memcpy(pch, &vch[nReadPos], nSize);  
  20.        nReadPos = nReadPosNext;  
  21.        return (*this);  
  22.    }  
  23.   
  24. CDataStream& write(const char* pch, int nSize)  
  25.    {  
  26.        // Write to the end of the buffer  
  27.        assert(nSize >= 0);  
  28.        vch.insert(vch.end(), pch, pch + nSize);  
  29.        return (*this);  
  30.    }  
CDataStream::read()从CDataStream复制nSize个字符到一个由char* pch所指向的内存空间。以下是它的实现过程：
  • 计算将要从vch读取的数据的结束位置，unsigned int nReadPosNext  = nReadPos + nSize。
  • 如果结束位置比vch的大小更大，则当前没有足够的数据供读取。在这种情况下，通过调用函数setState()将state设为ios::failbit，并将所有的零复制到pch。
  • 否则，调用memcpy(pch, &vch[nReadPos], nSize)复制nSize个字符，从vch的nReadPos位置开始，到由pch指向的一段预先分配的内存。接着从nReadPos向前移至下一个起始位置nReadPosNext（第22行）。
该实现表明1）当一段数据被从流中读取之后，该段数据无法被再次读取；2）nReadPos是第一个有效数据的读取位置。
CDataStream::write()非常简单。它将由pch指向的nSize个字符附加到vch的结尾。

宏READDATA()和WRITEDATA()

函数CDataStream::read()与CDataStream::write()的作用是序列化/反序列化原始类型（int，bool，unsigned long等）。为了序列化这些数据类型，这些类型的指针将被转换为char*。由于这些类型的大小目前已知，它们可以从CDataStream中读取或者写入至字符缓冲。两个用于引用这些函数的宏被定义为助手。
[cpp] view plain copy
 
  1. #define WRITEDATA(s, obj)   s.write((char*)&(obj), sizeof(obj))  
  2. #define READDATA(s, obj)    s.read((char*)&(obj), sizeof(obj))  
 
这里是如何使用这些宏的例子。下面的函数将序列化一个unsigned long类型。
[cpp] view plain copy
 
  1.   
[cpp] view plain copy
 
  1. template<typename Stream> inline void Serialize(Stream& s, unsigned long a,  int, int=0) { WRITEDATA(s, a); }  
 
把WRITEDATA(s, a)用自身的定义取代，以下是展开以后的函数：
[cpp] view plain copy
 
  1. <span style="font-family:monospace;white-space:pre;background-color:rgb(240,240,240);">template<typename Stream> inline void Serialize(Stream& s, unsigned long a,  int, int=0) { s.write((char*)&(a), sizeof(a)); }</span>  
 
该函数接受一个unsigned long参数a，获取它的内存地址，转换指针为char*并调用函数s.write()。
 

CDataStream中的操作符 << 和 >>

CDataStream重载了操作符<< 和 >>用于序列化和反序列化。
[cpp] view plain copy
 
  1. template<typename T>  
  2. CDataStream& operator<<(const T& obj)  
  3. {  
  4.     // Serialize to this stream  
  5.     ::Serialize(*this, obj, nType, nVersion);  
  6.     return (*this);  
  7. }  
  8.   
  9. template<typename T>  
  10. CDataStream& operator>>(T& obj)  
  11. {  
  12.     // Unserialize from this stream  
  13.     ::Unserialize(*this, obj, nType, nVersion);  
  14.     return (*this);  
  15. }  
 
头文件serialize.h包含了14个重载后的这两个全局函数给14个原始类型（signed和unsigned版本char，short，int，long和long long，以及char，float，double和bool）以及6个重载版本的6个复合类型（string，vector，pair，map，set和Cｓｃｒｉｐｔ）。因此，对于这些类型，你可以简单地使用以下代码来序列化/反序列化数据：
[cpp] view plain copy
 
  1. CDataStream ss(SER_GETHASH);  
  2. ss<<obj1<<obj2; //序列化  
  3. ss>>obj3>>obj4; //反序列化  

如果没有任何实现的类型符合第二个参数obj，则以下泛型T全局函数将会被调用。
[cpp] view plain copy
 
  1. template<typename Stream, typename T>  
  2. inline void Serialize(Stream& os, const T& a, long nType, int nVersion=VERSION)  
  3. {  
  4.     a.Serialize(os, (int)nType, nVersion);  
  5. }  

对于该泛型版本，类型T应该用于实现一个成员函数和签名T::Serialize(Stream, int, int)。它将通过a.Serialize()被调用。

怎样实现一个类型的序列化

在之前的介绍当中，泛型T需要实现以下三个成员函数进行序列化。
[cpp] view plain copy
 
  1. unsigned int GetSerializeSize(int nType=0, int nVersion=VERSION) const;  
  2. void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const;  
  3. void Unserialize(Stream& s, int nType=0, int nVersion=VERSION);  

这三个函数将由它们相对应的带泛型T的全局函数调用。这些全局函数则由CDataStream中重载的操作符<<和>>调用。
 
一个宏IMPLEMENT_SERIALIZE(statements)用于定义任意类型的这三个函数的实现。
[cpp] view plain copy
 
  1. #define IMPLEMENT_SERIALIZE(statements)      
  2.     unsigned int GetSerializeSize(int nType=0, int nVersion=VERSION) const    
  3.     {                                             
  4.         CSerActionGetSerializeSize ser_action;    
  5.         const bool fGetSize = true;               
  6.         const bool fWrite = false;                
  7.         const bool fRead = false;                 
  8.         unsigned int nSerSize = 0;                
  9.         ser_streamplaceholder s;                  
  10.         s.nType = nType;                          
  11.         s.nVersion = nVersion;                    
  12.         {statements}                              
  13.         return nSerSize;                          
  14.     }                                             
  15.     template<typename Stream>                     
  16.     void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const    
  17.     {                                             
  18.         CSerActionSerialize ser_action;           
  19.         const bool fGetSize = false;              
  20.         const bool fWrite = true;                 
  21.         const bool fRead = false;                 
  22.         unsigned int nSerSize = 0;                
  23.         {statements}                              
  24.     }                                             
  25.     template<typename Stream>                     
  26.     void Unserialize(Stream& s, int nType=0, int nVersion=VERSION)    
  27.     {                                             
  28.         CSerActionUnserialize ser_action;         
  29.         const bool fGetSize = false;              
  30.         const bool fWrite = false;                
  31.         const bool fRead = true;                  
  32.         unsigned int nSerSize = 0;                
  33.         {statements}                              
  34.     }  
 
以下例子示范怎样使用该宏。
[cpp] view plain copy
 
  1. #include <iostream>  
  2. #include "serialize.h"  
  3. using namespace std;  
  4. class AClass {  
  5. public:  
  6.     AClass(int xin) : x(xin){};  
  7.     int x;  
  8.     IMPLEMENT_SERIALIZE(READWRITE(this->x);)  
  9. }  
  10. int main() {  
  11.     CDataStream astream2;  
  12.     AClass aObj(200); //一个x为200的AClass类型对象  
  13.     cout<<"aObj="<<aObj.x>>endl;  
  14.     asream2<<aObj;  
  15.     AClass a2(1); //另一个x为1的对象  
  16.     astream2>>a2  
  17.     cout<<"a2="<<a2.x<<endl;  
  18.     return 0;  
  19. }  

这段程序序列化/反序列化AClass对象。它将在屏幕上输出下面的结果。
[cpp] view plain copy
 
  1. aObj=200  
  2. a2=200  

AClass的这三个序列化/反序列化成员函数可以在一行代码中实现：
IMPLEMENT_SERIALIZE(READWRITE(this->x);)
 
宏READWRITE()的定义如下
[cpp] view plain copy
 
  1. #define READWRITE(obj)      (nSerSize += ::SerReadWrite(s, (obj), nType, nVersion, ser_action))  

该宏的展开被放在宏IMPLEMENT_SERIALIZE(statements)的全部三个函数里。因此，它一次需要完成三件事情：1）返回序列化后数据的大小，2）序列化（写入）数据至流；3）从流中反序列化（读取）数据。参考宏IMPLEMENT_SERIALIZE(statements)中对这三个函数的定义。
 
想要了解宏READWRITE(obj)怎样工作，你首先需要明白它的完整形式当中的nSerSize，s，nType，nVersion和ser_action是怎么来的。它们全部来自宏IMPLEMENT_SERIALIZE(statements)的三个函数主体部分：
  • nSerSize是一个unsigned int，在三个函数当中初始化为0；
  • ser_action是一个对象在三个函数当中均有声明，但为三种不同类型。它在三个函数当中分别为CSerActionGetSerializeSize、CSerActionSerialize和CSerActionUnserialize；
  • s在第一个函数中定义为ser_streamplaceholder类型。它是第一个传入至另外两个函数的参数，拥有参数类型Stream；
  • nType和nVersion在三个函数中均为传入参数。
因此，一旦宏READWRITE()扩展至宏IMPLEMENT_SERIALIZE()，所有它的符号都将被计算，因为它们已经存在于宏IMPLEMENT_SERIALIZE()的主体中。READWRITE(obj)的扩展调用一个全局函数::SerReadWrite(s, (obj), nType, nVersion, ser_action)。这里是这个函数的全部三种版本。
[cpp] view plain copy
 
  1. template<typename Stream, typename T>  
  2. inline unsigned int SerReadWrite(Stream& s, const T& obj, int nType, int nVersion, CSerActionGetSerializeSize ser_action)  
  3. {  
  4.     return ::GetSerializeSize(obj, nType, nVersion);  
  5. }  
  6.   
  7. template<typename Stream, typename T>  
  8. inline unsigned int SerReadWrite(Stream& s, const T& obj, int nType, int nVersion, CSerActionSerialize ser_action)  
  9. {  
  10.     ::Serialize(s, obj, nType, nVersion);  
  11.     return 0;  
  12. }  
  13.   
  14. template<typename Stream, typename T>  
  15. inline unsigned int SerReadWrite(Stream& s, T& obj, int nType, int nVersion, CSerActionUnserialize ser_action)  
  16. {  
  17.     ::Unserialize(s, obj, nType, nVersion);  
  18.     return 0;  
  19. }  

如你所见，函数::SerReadWrite()被重载为三种版本。取决于最后一个参数，它将会调分别用全局函数::GetSerialize()，::Serialize()和::Unserialize()；这三个函数在前面章节已经介绍。
 
如果你检查三种不同版本的::SerReadWrite()的最后一个参数，你会发现它们全部为空类型。这三种类型的唯一用途是区别::SerReadWrite()的三个版本，继而被宏IMPLEMENT_SERIALIZE()定义的所有函数使用。
 



　　　　　　　　　　　　　 查看评论 回复



嵌入式交流网主页 > 上位机技术 > 比特币源码学习笔记（二）章
 

"比特币源码学习笔记（二）章"的相关文章

热门文章
♦
真方便巧用Windows7画图调整图片大小
♦
Windows7系统管理和禁用IE8加载项的方
♦
Windows 10升级全面“防范”
♦
Protocols 1
♦
centos6系统snmp监控安装配置与使用示
♦
上网本Windows7视窗切换设置技巧
相关文章

热门文章

论坛热帖

相关图文

网站地图

围观()