www.enchantedage.com

I recommend upgrading to visual studio 2008 or later. (2010 is out now!)

One option would be to make the struct contain only the data, and then declare a subtype that adds the polymorphic member. The RTTI could work on the base (POD) struct.

If you really want to do it with arbitrary class types, then you have to be more dynamic about what you're doing, which may impact performance and network behavior, but can also give you benefits in other areas. In this case, you simply turn RTTI(typename, members) into something like:

#define RTTI(typename, members) \
  template<typename Visitor> bool visit(Visitor &v) { \
    return members true; \
  } \
  DEFINE_RTTI(typename, #typename)
#define MEMBER(name) \
  v(this, name, #name) &&

At this point, each class implementing RTTI gets a "visit()" function which will call a visitor object with each member, passing a reference to the member as well as the name of it. This can be used to marshal in and out, to build hash tables to get members by name, etc. You can actually still do this with a NULL value if you want:

#define DEFINE_RTTI(type, name) \
  static inline IRTTIType &rtti_type() { \
    static RttiType inst(name); \
    static bool inited = ((type *)0)->visit(inst) && inst.commit(); \
  }

This will define the static registration for each type (assuming you can arrange for the static function to force linkage), in turn assuming RttiType is a class that can register data for a class instance based on the members passed to its operator(), and put it into a registry of some sort (depending on what you need to do with the type). And, yes, this "visits" a NULL object, but that will end working with all current compilers, as long as you don't actually read the value of the member; only store the offset and the name.

There's obviously all kinds of directions you can take this; the reason I posted this particular direction was that I wanted to show that a lightweight, intrusive marshaling solution is often actually better for some particular problems than a generic, non-intrusive system like that used by boost. Pick the right tool for the job!

The problem is that the value of each member may be of a different type. Thus, you must vector through the type-specific handler for each member. This is unavoidable because of the static typing of C++.

An alternative approach to serialization and meta-data is to create a template visitor worker function that visits each member in some order; you could then re-write your for loop as a simple visitor functor, and it would be invoked with the right type for each member. However, the up-front macro declarations to set that up are less elegant than the macros in this code; requiring separating declaration from definition.

struct MyPDU1 {
  int someValue;
  double anotherValue;
  std::string thirdValue;
};
 
#define V(x) v(#x, pdu.x, (size_t)((char *)&(pdu.x) - (char *)&pdu)) &&
template<typename Visitor> inline bool Visit(MyPDU1 &pdu, Visitor &v)
{
  return V(someValue)
    V(anotherValue)
    V(thirdValue)
    true;
}
#undef V

Your code can then call Visit(somePdu, MyVisitor) and MyVisitor will be invoked with the correct name, argument value/type, and offset within the PDU. However, you'd have to solve the registry of types separately, and the flavor of working with this kind of serialization is very different from the flavor I present in the article. There's also, as pointed out, the option of going with code parsing, or code generation from IDL. There are times when each kind will work just fine; you have to figure out the specific requirements of your project, and pick the alternative that matches your requirements the best.

If you want pre-processing, then there are many, many options open to you. You can even integrate it with Visual Studio, so it's not all that cumbersome to change your structures. However, you do end up with a more "static" solution, that in some sense separates declaration and behavior more than I intended with this illustrated solution.

For one of many ways to do marshaling and reflection using pre-processing, you might also want to compare my IDL-like solution that generates reflection visitors from source files as a pre-process step.