Re: Template technicality - What does the standard say?

Stephen Horne <sh006d3592@blueyonder.co.uk> kirjutas:


As Stephen is not so prone to provide compilable code samples, I will
provide one of my own distilled from working production code. I have no
idea if it bears any resemblance to Stephen's issues, but I think this is
something which could make use of a generalized offsetof() macro. What
the code does is to register the offset of a variable ("parameter") in a
derived class in another dynamic library, and assigning it a value later.

Restrictions:

Derived class must be as simple as possible (there are hundreds of such
classes). When started, Derived::Run() should just find the class member
parameters initialized to needed values.

In this example only one parameter of type 'int' is used. In reality
there are arbitrarily many parameters of multiple (restricted set of)
possible types. The parameter registration involves communicating both
the parameter type and offset, the type (an enum value) omitted here for
brevity. So the parameters cannot be just passed as parameters for the
Run() function.

The Base class and main() do not know anything about the Derived class.

Task:

The ob1 object in line A is actually not used except for finding out the
offsets of parameter data members. Please rewrite the code so that
creation of this dummy object ob1 would not be needed.

The code follows:
 
// MAIN EXECUTABLE
#include <iostream>

class Base {
public:
    Base(): base_data_(111) {}
    virtual int Declare()=0;
    virtual void Run()=0;
     virtual ~Base(){}
protected:
    int RegisterInput(void* memberaddr) {
        return static_cast<char*>(memberaddr)
        - static_cast<char*>(static_cast<void*>(this));
    }
private:
    int base_data_;
};

typedef Base* (*creator_functype)();
creator_functype RegisterDerived();

int main() {
    creator_functype creator = RegisterDerived();

     // Find out the offset of param1_ in the Derived class.
    Base* ob1 = (*creator)(); //LINE A
    int offset = ob1->Declare();
     delete ob1;

     // Much later, and many times: assign value to param1_ and call Run.
    Base* ob2 = (*creator)();
    *static_cast<int*>(static_cast<void*>
        (static_cast<char*>(static_cast<void*>(ob2))+offset)) = 42;
    ob2->Run();
     delete ob2;
}

// MIGHT BE IN A SEPARATE LIBRARY
class Derived: public Base {
public:
    virtual int Declare() {
        return RegisterInput(&param1_);
    }
    virtual void Run() {
        std::cout << "param1=" << param1_ << "\n";
    }
    static Base* Create() {return new Derived();}
private:
    int param1_;
};
creator_functype RegisterDerived() {return &Derived::Create;}