Reducing virtually duplicate template instantiations

I have a (generated) set of classes that look roughly like this when simplified:

class A {
public:
    static const int id = 0;
    typedef int value_type;
    void* data; // actually pointer to int
};
class B {
public:
    static const int id = 1;
    typedef float value_type;
    void* data; // actually pointer to float
};

There are altogether tens of these, with much fewer types. I need to create classes that calculate some derived values for all of these. Now the obvious solution would be using a template like this:

template<class T>
class Derived {
public:
    typename T::value_type value;
    void update(const void* data) {
        value = *static_cast<typename T::value_type*>(data);
        // do some calculations
    }
};

But this is going to instantiate a separate class for every single parameter class A, B, and so on; most of which will be identical. The other solution would be an obvious template class like this:

template<typename T>
class Derived2 {
public:
    T value;
    void update(const void* data) {
        value = *static_cast<T*>(data);
    }
};

This would be updating the code using this class manually if the schema that classes A, B, etc., are generated from changes. Is there a way to use the value_type typedefs to generate instantiations of Derived2<int>, Derived2<float> etc., or at least match the types of manually parametrized instantiations to types A, B, etc.?

This is an embedded system, so the target is reducing the amount of identical code, even if it leads to more convoluted C++ code. Replacing the void*s with actual types would lead to code explosion in other parts of the program, so it is not done.

via Chebli Mohamed