Question: I'm writing a program in C++ to listen to a stream of tcp messages from another program to give tracking data from a webcam. I have the socket connected and I'm getting all the information in but having difficulty splitting it up into the data I want.

Here's the format of the data coming in:

8 byte header:
4 character string,
integer

32 byte message:
integer,
float,
float,
float,
float,
float

This is all being stuck into a char array called buffer. I need to be able to parse out the different bytes into the primitives I need. I have tried making smaller sub arrays such as headerString that was filled by looping through and copying the first 4 elements of the buffer array and I do get the the correct hear ('CCV ') printed out. But when I try the same thing with the next for elements (to get the integer) and try to print it out I get weird ascii characters being printed out. I've tried converting the headerInt array to an integer with the atoi method from stdlib.h but it always prints out zero.

I've already done this in python using the excellent unpack method, is their any alternative in C++?

Any help greatly appreciated,

Jordan

Links

[CCV packet structure](http://nuigroup.com/forums/viewthread/8708/)

[Python unpack method](http://docs.python.org/library/struct.html#functions-and-exceptions)

Answer: 
The buffer only contains the raw image of what you read over the 
network. You'll have to convert the bytes in the buffer to whatever
format you want. The string is easy:

```
std::string s(buffer + sOffset, 4);

```

(Assuming, of course, that the internal character encoding is the same
as in the file—probably an extension of ASCII.)

The others are more complicated, and depend on the format of the
external data. From the description of the header, I gather than the
integers are four bytes, but that still doesn't tell me anything about
their representation. Depending on the case, either:

```
int getInt(unsigned char* buffer, int offset)
{
    return (buffer[offset    ] << 24)
        |  (buffer[offset + 1] << 16)
        |  (buffer[offset + 2] <<  8)
        |  (buffer[offset + 3]      );
}

```

or

```
int getInt(unsigned char* buffer, int offset)
{
    return (buffer[offset + 3] << 24)
        |  (buffer[offset + 2] << 16)
        |  (buffer[offset + 1] <<  8)
        |  (buffer[offset    ]      );
}

```

will probably do the trick. (Other four byte representations of
integers are possible, but they are exceedingly rare. Similarly, the
conversion of the unsigned results of the shifts and or's into a `int`
is implementation defined, but in practice, the above will work almost
everywhere.)

The only hint you give concerning the representation of the floats is in
the message format: 32 bytes, minus a 4 byte integer, leave 28 bytes for
5 floats; but 28 doesn't go into five, so I cannot even guess as to the
length of the floats (except that there must be some padding in there
somewhere). But converting floating point can be more or less
complicated if the external format isn't exactly like the internal
format.
Something like this may work:

```
struct {
    char string[4];
    int integers[2];
    float floats[5];
} Header;

Header* header = (Header*)buffer;

```

You should check that `sizeof(Header) == 32`.