How do I inherit static data members ?

I would probably use the generic overload for primitive types, then provide a Serializable& overload, but no more, causing compile errors instead of silent "failure."
Anyway, I put that out there not just as a "lecture," but also as information to whomever else may be reading and to point out boost, of course.

that wouldn't cause compile errors.

Having a non-appropriate overload would cause a compile error.

you can't overload your way into compile errors, the template always picks up the 'miscellaneous'. you can only overload your way into alternate paths. the only way that could possibly work would be with something like this:

Code:

template<class T,class U>
class Conversion
{
    typedef char Small;
    class Big{char arr[2];};
    static Small Test(U);
    static Big Test(...);
    static T& MakeT();
public:
    enum
    {
        exists = sizeof(Test(MakeT()))==sizeof(Small)
    };
};

template<typename T> void Serializer::pack(T& t)
{
    static_assert(Conversion<T,int>::exists,"packed types must be POD");
}

My point was to remove the generic overload to cause compile errors on purpose.

you said you'd use it for POD.

the generic overload is extremely powerful. it lets you serialize containers recursively, which allows you to handle containers-of-containers, and the like with no additional effort.

providing overloads for the standard containers plus a serializeable interface, along with the POD-check above in the ultimate call that packs the data members into the byte buffer works very well.

Originally Posted by m37h0d

you said you'd use it for POD.

Not POD. Primitive types.
Although, even primitive types are dangerous.
Although then again, think about it, providing overloads for the fixed-size types in C++11 and doing checks for endianess, it wouldn't be so bad.
POD types are still dangerous since we cannot predict padding.

providing overloads for the standard containers plus a serializeable interface, along with the POD-check above in the ultimate call that packs the data members into the byte buffer works very well.

For primitive types, but yes, I am inclined to agree. You may wish to extend it somehow to make it easy to write some code to allow for easily writing code to handle custom containers. Although I suppose one might be able to derive from Serializable or perhaps the class exposes some interface that can easily be overloaded. I digress.

darth vader is riding a unicycle playing a bagpipe.

your argument is invalid.

Darth Vader bagpipe unicycle - YouTube





happy monday