C ++和压缩结构

Question

I have database project that I want to move from C to C++. In this C project I have lots of small packed structs, that I write directly to file or read from mmaped file - eg directly from memory address.

I need the class in-memory representation, to be exactlybthe same as if I use plain old C struct. I believe this is called POD or C++ standard layout.

I can proceed in several ways:

I can do class, bu I worry that if I add methods to this struct, probably the internal structure will be changed.

If I wrap the a structure into class, I will need to create / destroy classes all the time, along with the structs.

If I do it C - OO style, I will need to supply pointer to every function, eg

static const char *Pair::getKey(const void *mem);

I can also make the struct a field and do something similar

void Pair::setMem(const void *mem);
const char *Pair::getKey();

but the more I see this, the less I like it, because there is no real advantage.

Anything I am missing?

Answer 1

If I add methods to this struct, probably the internal structure will be changed.

That's wrong; to satisfy your needs what you want is to keep your structure a POD, for which essentially you don't want:

• non-trivial constructors/destructors/assignment operators;
• virtual functions or virtual base classes;
• different access specifiers for data members .

(there are some additional restrictions (see C++11 §9 ¶6-10), but they are not particularly relevant in your case)

The "POD" thing implies two things:

• that your class is "standard layout", which roughly means "laid out in a well-defined manner, the same way as C would do" (which assesses your primary concern);

  adding methods shouldn't break stuff, since, as they aren't be virtual, they are translated as free functions which take a pointer to the object as hidden parameter, and that requires no modification to the original C layout. static methods are just free functions with different scoping, so in general they are a non-issue.

• that your class can be freely copyable with a memcpy without stuff breaking, which is probably what you want if you read it straight from file (either with mmap or with fread );

  this is accounted for by the "triviality" of the constructors (ie if they are skipped nothing bad happens to your objects) and by the absence of virtual members, which means that you don't risk overwriting the vptr with a stale one read from the file.

Answer 2

C++11 has a specific concept called standard layout, it basically means that for classes meeting the standard layout requirements, it guarantees that the class will be laid out in memory identically to C. The requirements are:

• All non-static data members have the same access control
• Has no virtual functions or virtual base classes
• All non-static data members and base classes are themselves standard layout types
• Has no two base class subobjects of the same type

So you can add methods to your classes, as long as you're careful. See http://en.cppreference.com/w/cpp/concept/StandardLayoutType .

Answer 3

If I add methods to this struct, probably the internal structure will be changed.

This is unlikely, at least no more so than changing compiler (from C to C++). You can add methods, as long as they aren't constructors, destructors, assignment operators, or virtual functions, and the memory layout is guaranteed to not change.

For more information, see Structure of a C++ Object in Memory Vs a Struct

If I wrap the structure into class, I will need to create / destroy classes all the time.

Which is exactly the same as creating and destroying structs all the time. Class instantiation in C++ consists of a memory allocation and a call to a constructor. You have the same control over the allocation as you do with a struct, and you control all of the code in the constructor (including the option to have no code at all).

It is perfectly legal to write C code and build it using a C++ compiler. It is also possible to write C++ code (under a few restrictions) that compiles to exactly the same binary as that C code. What using class/struct members gets you is a (arguably) cleaner syntax and implied currying of the this pointer. For example:

// C
ret = CallMyStructMethodX(pMyStruct, param1, param2);

// C++
ret = pMyStruct->CallMethodX(param1, param2);

These two lines of code will are identical. The only difference is that in the latter case, your struct pointer is passed by the implied this parameter, rather than as an explicit parameter to the function.