what is the proper way to fill members from raw data

Question

I have a pointer to raw data using const u_char*, and a generic class like this

class Rectangle 
{
   u_int8_t length;
   u_int8_t height;
   ...
}

Assuming the raw data is a binary "stream" of bytes, what is the best way to get the raw data into the fields of the class.

-memcpy ?
-cast   ?

i could do this :

Rectangle *rect = (Rectangle*)rawdata;

but i know that is a "old style" cast.

What is the proper way ?

Answer 1

I'd say having a constructor:

Rectangle(const u_char*)

having casts all over the code could work fine for now, but it's a terrible idea in case you want to change your class later on. Having a constructor can mean some overhead, but you'd have a single point where the logic happens.

If later you decide you want to add a virtual method to Rectangle, all casts in the code will become useless.

This is of course if you want to construct a new object from data. If you frequently serialize/deserialize objects, I'd go with serializations methods:

const u_char* toUChar() const;
void fromUChar(const u_char*) const;

Answer 2

Rectangle& rect = *reinterpret_cast<Rectangle*>(rawdata);

I'll do it this way if rawdata is void or cast directly to a reference if rawdata is any other type (one that I can deference directly).

I prefer the reference because I find it less error prone than using raw pointers. However, if you need to do pointer arithmetic there's no problem making it a raw pointer. Depending on usage you might want to cast to a const Rectangle& instead of non-const.

However, usually with raw byte streams you need to invent a protocol and you shouldn't cast directly into a struct or class. Structs and classes may have padding which messes up your direct cast. The cast will silently succeed no matter what, but your values will be unexpected. A protocol would be something like...

0 offset: (4 bytes - float) size

4 offset: (2 bytes - uint16_t) height

etc. Doing the protocol approach would mean you'll have to assign the members one by one.

Answer 3

The easiest and most reliable method is to simply use a convert constructor:

class Rectangle
{
public:
  Rectangle(uint8_t l, uint8_t h) : length(l), height(h) {};
  // ...
};

This should be your go-to method until for whatever reason this is impossible.

Barring this, the next best thing to do is simply do a memberwise initialization:

Rectangle rect;
rect.width = 20;
rect.height = 40;

If it becomes impossible to do the above, and iff the object in question is what the Standard refers to as an "aggregate" (basically a POD), you can use an initializer like this:

Recatagle rect = {10,20};

When doing this, you must bear in mind that the members will be initialized in the order in which they are declared in the class. If you change the order of declaration, you will break every initialization like the above. This is very brittle. For this reason, I limit my use of a construct like this to cases where the class in question is highly localized (like a helper class in a single translation unit), and I document the need to keep the order of declaration intact.

EDIT PER COMMENTS:

In the instance you are trying to copy strings in to your class, or pointers to any sort of data, you will need to do a deep copy:

class Gizmo
{
public:
  Gizmo(const char* str) : str_(0)
  {
    str_ = new char[strlen(str)+1];
    strcpy(str_,str);
  }
};

Note the clumsiness and how brittle the above code is. There are plenty of things that could go wrong here. Not the least of which are forgetting to delete str_ when Gizmo is destroyed, the ugliness and seeming lack of necessity for newing a char string in the first place, one-past-the-end errors ... the list goes on. For these reasons, it's best to avoid using raw pointers at all and using either smart pointers (ie unique_ptr, shared_ptr, etc) or collection classes. In this case, I'd use a std::string, which can be thought of as a collection class:

class Gizmo
{
public:
  Gizmo(const char* str) : str_(str) {};
private:
  std::string str_;
};

Feel free to convert this for use with a u_char*, and to add robustness by means of verifying the source pointer is valid.

Answer 4

The "new style" cast is

Rectangle *rect = reinterpret_cast< Rectangle* >( rawdata );

But you should be careful with the alignment, the padding in your class.

This will use the same memory, it will just interpret it like a Rectanle object.

memcpy will copy it. Depends on your needs. Most probably, you don't need it.

Answer 5

While directly casting is a little faster, doing it that way locks your class into a specific design. If you later make changes to the data within the class, all casts will break.

A better way to handle raw data would be to either make a constructor and/or overload the input stream operator. I personally prefer overloading the operator to a constructor because I hate having more than one simple constructor to a class. The overload might look something like this:

istream& operator >> (istream& input, char* rawData)
{
    //fill your object's variables directly from the raw data
}

This way you take control of filling your object from the data, and if the data or your object ever changes, you only have to change code in one location to fix it everywhere.

I also like using the operator overload over creating a function for it because I think it makes the code look nicer and faster to see what you're doing.