array von void pointern

AlexanderKiebler

Hallo,

ich würde gerne mehrere verschiedene template instanzen einer Klasse
in einem array speichern. Hierfür hatte ich ein Pointerarray vorgesehen.
Etwa in der Art:

unsafe class Record
    {
        void*[] ptr_arr = new void*[10];
        public Record()
        {
            Parameter<int> p=new Parameter<int>(5, -1, "U", "Volt");
            ptr_arr[0] = (void*)&p;

        }
    }

Wiso geht das nicht ?? Im Arry ptr_arr kann der Kompiler rumspringen wie er mag, da void pointer immer die selbe Größe/Betriebssystem haben.

Was ich mit dem Poiter mache, und wie ich den Typ zurück bekomme, ist doch dann mein Problem ....

Der Compiler meint er könnte die größe des Pointers =)... also er meint eigentlich die Größe des Typs hinter dem Pointer ... nicht bestimmen, wo er ja recht hat, aber hier garnichts zur Sache tut.

Habe ich nen Denkfehler drin ??
Oder
Wie kann ich denn sowas in C# lösen ??

Grüße

AlexanderKiebler

Verdammt *lach*... das problem hatte ich schon... is gelöst. sorry

freaky

Gibt es einen bestimmten Grund warum du mit void-Pointers rumexperimentierst?

AlexanderKiebler

Generell ist das Problem sehr gut oben beschrieben.
Die lösung ist:

class InterfaceBase{
   public:
      virtual ~Interface()=0;
      virtual void shoot()=0;
};
template <typename TX,typename RX>
class Interface:public InterfaceBase{
    TX foo;
    RX bar;
    void shoot(){
       foo.grapelize(&bar.moo);
    }
};
vector<InterfaceBase*> vec;
for each i as Interface*
   i->shoot();

Allerdings in C++. Das müßte in C# auch gehen.
Habe letzte woche schonmal was ähnliches gehabt.

freaky

Ohne void-Pointer gefrickel (Nachbau deines C++ Code)

interface InterfaceBase
{
    void Shoot();
}
class Interface<T, U> : InterfaceBase
{
    public void Shoot()
    {
        // SHOOT !
    }
}
class Program
{
    static void Main(string[] args)
    {
        List<InterfaceBase> list = new List<InterfaceBase>();
        list.Add(new Interface<int, int>());
        list.Add(new Interface<string, int>());
        foreach (InterfaceBase i in list)
        {
            i.Shoot();
        }
    }
}

Nebenbei... Alle Klassen, auch eigene, leiten von Object ab. Also ist das Equivalient zu einer void* Liste von C++ eine List<Object> in C#. Mit dem Unterschied das vei void* sämtliche Typinformationen verloren gehen, bei Object nicht.