C++防御性编程：从类型安全的缓冲区中读取

Question

假设我有一个我不拥有的类：DataBuffer。它提供了各种 get 成员函数：

get(uint8_t *value);
get(uint16_t *value); 
...

当读取此缓冲区中包含的结构时，我知道字段的顺序和大小，并且我想减少将来代码更改导致错误的机会：

struct Record 
{
    uint16_t Header;
    uint16_t Content;
}

void ReadIntoRecord(Record* r)
{
    DataBuffer buf( initialized from the network with bytes )
    buf.get(&r->Header); // Good!
    buf.get(&r->Content);
}

然后有人签入更改以执行某些操作在编写标题之前先添加标题：

    uint8_t customHeader;
    buf.get(&customHeader);  // Wrong, stopped reading after only 1 byte
    r->Header = customHeader + 1;
    buf.get(&r->Content);  // now we're reading from the wrong part of the buffer.

以下是强化代码以防止更改的可接受方法吗？请记住，我无法将函数名称更改为 getByte、getUShort 等。我可以从 DataBuffer 继承，但这似乎有点矫枉过正。

    buf.get(static_cast<uint16_t*>(&r->Header));  // compiler will catch incorrect variable type
    buf.get(static_cast<uint16_t*>(&r->Content))

使用不安全的遗留代码示例进行更新：

       float dummy_float;
        uint32_t dummy32;
        uint16_t dummy16;
        uint8_t dummy8;

        uint16_t headTypeTemp;
        buf.get(static_cast<uint16_t*>(&headTypeTemp));
        m_headType = HeadType(headTypeTemp);
        buf.get(static_cast<uint8_t*>(&hid));
        buf.get(m_Name);
        buf.get(m_SerialNumber);


        float start;
        buf.get(static_cast<float*>(&start));
        float stop;
        buf.get(static_cast<float*>(&stop));


        buf.get(static_cast<float*>(&dummy_float));
        setStuffA(dummy_float);

        buf.get(static_cast<uint16_t*>(&dummy16));
        setStuffB(float(dummy16)/1000);

        buf.get(static_cast<uint8_t*>(&dummy8));    //reserved





        buf.get(static_cast<uint32_t*>(&dummy32));
        Entries().setStart( dummy32 );
        buf.get(static_cast<uint32_t*>(&dummy32));
        Entries().setStop( dummy32 );
        buf.get(static_cast<float*>(&dummy_float));
        Entries().setMoreStuff( dummy_float );

        uint32_t datalength;
        buf.get(static_cast<uint32_t*>(&datalength));

        Entries().data().setLength(datalength);

        RetVal ret = ReturnCode::SUCCESS;
        Entry* data_ptr = Entries().data().data();
        for (unsigned int i = 0; i < datalength && ret == ReturnCode::SUCCESS; i++)
        {
            ret = buf.get(static_cast<float*>(&dummy_float));
            data_ptr[i].FieldA = dummy_float;
        }

        for (unsigned int i = 0; i < datalength && ret == ReturnCode::SUCCESS; i++)
        {
            ret = buf.get(static_cast<float*>(&dummy_float));
            data_ptr[i].FieldB = dummy_float;
        }

        // Read in the normalization vector
        Util::SimpleVector<float> norm;
        buf.get(static_cast<uint32_t*>(&datalength));
        norm.setLength(datalength);
        for (unsigned int i=0; i<datalength; i++)
        {
            norm[i] = buf.getFloat();
        }

        setNormalization(norm);

        return ReturnCode::SUCCESS;
}

Answer 1

从网络读取整个结构不是更好吗？让用户执行所有套接字操作对我来说似乎是一个坏主意（未封装）。封装要在网络上发送的内容以对文件描述符进行操作，而不是让用户将原始缓冲区数据放入文件描述符。

我可以想象类似的事情

void readHeader(int filedes, struct Record * Header);

，所以你可以做这样的事情

struct Record 
{
  uint16_t Header;
  uint16_t Content;
  uint16_t getHeader() const { return Header; }
  uint16_t getContent() const  { return Content; }  
};

/* socket stuff to get filedes */
struct Record x;
readHeader(fd, &x);
x.getContent();

Answer 2

除非缓冲区包含有关内容的信息，否则无法从类型安全的缓冲区中读取数据。一种简单的方法是为每个结构添加长度，并检查至少正在读取的数据是否仍然是正常的长度。您还可以使用 XML 或 ASN.1 或提供类型信息的类似内容。当然，我假设您也写入该缓冲区。

Answer 3

不要使用超载。为什么不进行 get_word 和 get_dword 调用？界面不会变得更难看，但至少更难犯错误。