Populate Struct of Char Pointers - c++

Question

Let's say you have this structure:
struct MMFS_IDENTIFICATION
{
char *szVendor;
char *szControllerModel;
char *szRevision;
char *szId;
char *szExecutive;
char *szKarelRevision;
char *szProcessName;
char *szCommRevision;
char *szRobotModel;
};
Is there any easy way to do something like this?
MMFS_IDENTIFICATION mmfsId;
for( int i = 0; i < 9; i++ )
{
int len = buf[pos++];
mmfsId[i] = malloc(len);
memcpy( mmfsId[i], buf[pos], len );
pos += len;
}
The only thing I know to do is copy and paste the code nine times. But I really don't want to do that because in the real program I'm using this concept for, calculating len is not as simple as I made it in this example.

Answer 1

Since your structure contains 9 different pointers with different names, the only standard way to access them is with 9 different pieces of code. You might try to cheat and rely on the internal representation of the structure, and you might even get away with it, but it isn't advised.
Use a function to turn each piece into a single one-liner.
void CopyString(char * & string_ptr, char * buf, int & pos)
{
int len = buf[pos++];
string_ptr = new char[len];
memcpy( string_ptr, buf[pos], len );
pos += len;
}
CopyString(mmfsId.szVendor, buf, pos);
CopyString(mmfsId.szControllerModel, buf, pos);
CopyString(mmfsId.szRevision, buf, pos);
CopyString(mmfsId.szId, buf, pos);
CopyString(mmfsId.szExecutive, buf, pos);
CopyString(mmfsId.szKarelRevision, buf, pos);
CopyString(mmfsId.szProcessName, buf, pos);
CopyString(mmfsId.szCommRevision, buf, pos);
CopyString(mmfsId.szRobotModel, buf, pos);

Answer 2

Since all of the structure members are char* pointers, you could do something like this:
#include <pshpack1.h>
struct MMFS_IDENTIFICATION
{
char *szVendor;
char *szControllerModel;
char *szRevision;
char *szId;
char *szExecutive;
char *szKarelRevision;
char *szProcessName;
char *szCommRevision;
char *szRobotModel;
};
#include <poppack.h>
MMFS_IDENTIFICATION mmfsId;
char** pmmfsId = (char**) &mmfsId;
for( int i = 0; i < 9; ++i )
{
int len = buf[pos++];
pmmfsId[i] = malloc(len+1);
memcpy( pmmfsId[i], buf[pos], len );
}

Answer 3

For the moment, I've made the members std::string instead of char *, for the sake of slightly simpler demo code, but the general idea should work the same with with char * instead1.
#include <stddef.h>
#include <iostream>
#include <string.h>
#include <sstream>
struct MMFS_IDENTIFICATION
{
std::string Vendor;
std::string ControllerModel;
std::string Revision;
std::string Id;
std::string Executive;
std::string KarelRevision;
std::string ProcessName;
std::string CommRevision;
std::string RobotModel;
};
int main() {
MMFS_IDENTIFICATION s;
// We need a char *, because we need to add byte-wise offsets:
char *base = (char *)&s;
typedef std::string *ptr;
ptr fields[9];
// Set up our `fields` array with the addresses of the fields.
// Note the parens to force pointer arithmetic on `char *`, *then* conversion
// to `std::string *`.
fields[0] = (std::string *)(base + offsetof(MMFS_IDENTIFICATION, Vendor));
fields[1] = (std::string *)(base + offsetof(MMFS_IDENTIFICATION, ControllerModel));
fields[2] = (std::string *)(base + offsetof(MMFS_IDENTIFICATION, Revision));
fields[3] = (std::string *)(base + offsetof(MMFS_IDENTIFICATION, Id));
fields[4] = (std::string *)(base + offsetof(MMFS_IDENTIFICATION, Executive));
fields[5] = (std::string *)(base + offsetof(MMFS_IDENTIFICATION, KarelRevision));
fields[6] = (std::string *)(base + offsetof(MMFS_IDENTIFICATION, ProcessName));
fields[7] = (std::string *)(base + offsetof(MMFS_IDENTIFICATION, CommRevision));
fields[8] = (std::string *)(base + offsetof(MMFS_IDENTIFICATION, RobotModel));
// Initialize the field contents to some recognizable values:
for (int i=0; i<9; i++) {
std::ostringstream buffer;
buffer << "Field " << i;
*fields[i] = buffer.str();
}
// print out some spot results to show we've written to the fields in the struct:
std::cout << "printing by field names:\n";
std::cout << "Vendor = " << s.Vendor << "\n";
std::cout << "Id = " << s.Id << "\n";
std::cout << "CommRevision = " << s.CommRevision << "\n";
return 0;
}
Another possibility would be to use std/tr1/boost tuples. These won't let you use run-time iteration like I have above, but they will give you access to fields by number at compile time. With some case, you can probably use this to eliminate duplication at the source code level, even though it may remain in the object code.
Technically, you can only use offsetof in a POD struct (at least under C++98/03), so it's not required to work at all with them being std::string. At least with most typical compilers (e.g., VC++, g++) I've yet to see it fail for non-POD types, at least as long as the parent struct has no virtual functions, etc., of its own.