Zentrale Frage: Wie sage ich delete , dass es ab der Stelle X, also ab da, wo der Typ mit new erstellt wurde, die Anzahl an Bytes löscht, die mir übergeben wurden?

Gruß

Guck dir mal boost::any an.

Zweiteres würde ich dir nicht empfehlen, daher:

// Header:
void my_ugly_pointer_func_do(void *ptr);

// Nur dieser Teil ist templated, da sonst jedesmal die obere Funktion neu geschrieben werden muss
template<typename T>
void my_ugly_pointer_func(T *ptr)
{
  my_ugly_pointer_func_do(ptr);
  delete ptr; // Destruktor wird aufgerufen, Compiler weiss von welchem Typ (wenn kein Array).
}

// Code:
void my_ugly_pointer_func_do(void *ptr)
{
   // hier dein alter Code
}

So sollte das gehen, mir will der Sinn aber nicht ganz erschliessen.

// externe plugin.dll
class Bla // Bla ist nur in plugin.dll bekannt, somit auch dessen Größe
{
public:
    // ...
};

// ...

void myCallback(void **)
{
}

// ...

bool *test = new bool;
*bool = false;
int *x = new int;
*x = 2;
Bla *bla = new Bla;

pMyIface->CreateTimer(2.0/*delay*/, myCallback, Type_Bool, test, Type_Int, x, Type_AutoDeletePointer, bla);

// ...

typedef void (*Callback_t)(void **);

void MyIface::CreateTimer(double delay, Callback_t Callback, ...)
{
    // daten speichern
}

void MyIface::OnTick()
{
    for (/* daten durchlaufen*/)
    {
        if (bla.delay + currenttime <= currenttime)
        {
            bla.callback(bla.params);

            // an dieser stelle müsste ich dann alle parameter durchgehen, um diese mit delete wieder zu löschen
            // bei bool, int, float, double, long, und so, weiß ich ja, wie groß sie sind, d.H. ich kann folgendes machen:
            delete (long*)blub;
            // bei eigenen Typen weiß der Compiler ja nicht, wie groß diese sind
            // also bräuchte ich etwas, was dem delete folgendes sagt:
            // ab hier z.B. 250 bytes löschen
            delete (void*)blub;
        }
    }
}

Gruß

ich will eine Art mehr oder weniger dynamische Möglichkeit bieten, Parameter verschiedenster Typen an eine Funktion zu übergeben. Dann soll nach Ablauf einer bestimmten Zeit eine Funktion aufgerufen werden, d.h. die Parameter müssen zwischengespeichert werden.

Das klingt nach dem, was boost::thread auch schon macht. Der Konstruktor nimmt ein beliebiges Funktionsobjekt optional mit zusätzlichen Parametern entgegen und speichert diese zwischen, so dass der neu gestartete Thread darauf später arbeiten kann. boost::function und boost::any arbeiten ähnlich. Der Trick heißt "type erasure" in C++. In Java gibt es diesen Begriff auch, hat dort aber eine leicht andere Bedeutung. Ich bin mir auch sicher, dass das in diesem Forum mindestens 2mal schon erklärt wurde. Such mal danach.

class TimerCallback
{
public:
    virtual ~TimerCallback() {}
    virtual void OnTick() = 0; // braucht keine parameter!
};

void Foo::CreateTimer(double delay, TimerCallback* callback)
{
    // ...
}

void Foo::OnTick()
{
    // ...
    callback->OnTick();
    delete callback; // löscht callback inklusive aller parameter
    // ...
}

// Benutzung:

class MyTimerCallback : public TimerCallback
{
public:
    MyTimerCallback(int a, int b, int c)
        : m_a(a), m_b(b), m_c(c)
    {
    }

    virtual void OnTick()
    {
        printf("%d, %d, %d\n", m_a, m_b, m_c);
    }
private:
    int m_a;
    int m_b;
    int m_c;
};

void Test()
{
    MyTimerCallback* callback = new MyTimerCallback(1, 2, 3);
    foo->CreateTimer(42, callback);
}

Oder verwende gleich boost::function statt TimerCallback .

Gruß