IMPLEMENT_SERIAL und Kein Standardkonstruktor verfügbar

Martin Richter

Aber Du kannst doch sehen, welche Namen in der Liste sind!

Aber Du kannst doch sehen, welche Namen in der Liste sind!

Ja kann ich. Aber meiner ist halt nicht dabei.

Martin Richter

Dann stimmt was mit Deinen Namen nicht.
Das CRuntimeClass Objekt enthält den Namen und wird durch IMPLEMENT_SERIAL mit erzeugt.

Dann besorge Dir doch mal von einem neuen Objekt die CRuntimeClass!

Dann besorge Dir doch mal von einem neuen Objekt die CRuntimeClass!

? Du meinst ich soll das ganze mit einer anderen Klasse testen?

Ok. Das hat funktioniert. Dann muss was mit meinem Namen nicht passen.

Ich versteh es nicht. Habe alles kontrolliert. Der Name den ich bei IMPLEMENT_SERIAL angegeben habe ist genau der meiner Klasse. Er erscheint aber nicht in der Liste.
Das müsste doch sonst eigentlich schon eine Fehler beim Kompilieren geben oder nicht?

Hallo.

Habe nun zwei fast identische Klassen genommen. Unterschied ist das die eine mehr Membervariablen hat und von der anderen noch weitere Klassen abgeleitet sind.

Von der einen Klasse lassen sich dynamisch Objekt erzeugen, ist in der Klassenliste vorhanden. Von der anderen lassen sich keine Objekte erzeugen, ist nicht in der Klassenliste vorhanden.

Woran kann das denn liegen?

Hallo Herr Richter.

Darf ich nochmal was fragen:

Du schreibst:

Du könntest ein eigenes System aufbauen, bei denen jedes Objekt seine eigene Factory hat. Jedes Objekt initialisiert sich in dem es (über statische Member) seine Factory im System anmeldet (z.B. in eine Liste oder Map einträgt).

Hier stellt sich die Frage: wie soll sich das Objekt mit seiner Factory im System anmelden wenn es das Objekt ja noch gar nicht gibt?

Martin Richter

Du erzeugst über ein statisches Factory Objekt eine Liste, die sich selbst durch einen Konstruktor aufbaut. Dasist genau das was auch die MFC macht.

Hallo.

Versteh ich immer noch nicht. Meine Klassen haben nun alle ein statische Methode um sich selber zu kreieren. Diese Funktion soll nun in einer Liste angemeldet werden. Aber wer meldet dies an.

Ich packe doch in eine map den Klassennamen und die zugehörgige Create-Funktion. Nun muss doch aber jemand den Klassennamen und die Funktion kennen. Und das ist doch nur die Klasse selber. Aber wie will die sich anmelden wenn es sie noch gar nicht gibt.

Noch ein Tipp?

Martin Richter

Bau eine verkette Liste.
Erzeuge für jeden Konstruktor ein statisches Objekt, dass dafür sorgt sich mit der initialisierung in die Liste einzutragen mit ID und Konstruktorfunktion.
Das geht automatisch!

Oder Bau Dir simpel selbst einen Array aus "Klassen Token" und statischer Factory Funktion.
Das muss etwas gepflegt werden...

Erzeuge für jeden Konstruktor ein statisches Objekt, dass dafür sorgt sich mit der initialisierung in die Liste einzutragen mit ID und Konstruktorfunktion.

Dass muss dann ja aber auch immer gepfelgt werden. Ich würde gerne aber ein Makro schreiben, ähnlich dem IMPLEMENT_SERIAL von MFC.

Dass mir die Createfunkion in der Klasse erstellt und sich gleichzeitig in eine Liste einträgt.

Das geht automatisch!

Wie soll das gehen.

Also wenn eine meiner Klasse so aussieht.

class CMyClass1 : public CMyClass
{
  CMyClass1(int var);
  ~CMyClass1();

   static CMyClass* CreateObject(int var)
   {
     return new CMyClass(var)
   }

};

std::map<CString,pFnCreate> classmap;

Wie bekomme ich nun die Funktion CreateObject() und den Klassennamen CMyClass1 in die map? Wer ruf hier den insert auf?

Martin Richter

visualer schrieb:

Das geht automatisch!
Wie soll das gehen.

Ich habe alles geschrieben was zu sagen ist. Muss man hier immer alles vorkauen bis ins kleinste?

Das ist jetzt nicht ausgefeiltund einfachmal so gehackt, also bitte nichtall zu viel Kritik.

BTW: Ich habe nur das MFC Verfahren kopiert....

// AutoRegister.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <memory>
#define CONCAT2(x,y) x##y
#define CONCAT1(x,y) CONCAT2(x,y)
#define UNIQUE(x) CONCAT1(x,__COUNTER__)

/////////////////////////////////////////////////////////////////////////////
//    The base class

class CObjBase
{
public:
    CObjBase()
    {
    }
    virtual ~CObjBase()        
    {
    }        
private:
    CObjBase(const CObjBase &);
    CObjBase &operator=(const CObjBase &);
};

/////////////////////////////////////////////////////////////////////////////
//    our factory holder

typedef CObjBase* (*FNOBJECTCREATOR)();

class CFactory
{
public:
    CFactory(int iToken, FNOBJECTCREATOR pFnCreate)
        : m_iFactoryToken(iToken)
        , m_pFnCreate(pFnCreate)
    {
#ifdef _DEBUG
        // Token should not exist twice
        for (const CFactory *pf=m_pFactoryList; pf; pf=pf->m_next)
            _ASSERTE(pf->m_iFactoryToken!=iToken);
#endif
        m_next = m_pFactoryList;
        m_pFactoryList = this;
    }
    static CObjBase *CreateObject(int iToken)
    {
        for (const CFactory *pf=m_pFactoryList; pf; pf=pf->m_next)
        {
            if (pf->m_iFactoryToken==iToken)
                return pf->m_pFnCreate();
        }

        // Not found
        return NULL;
    }

protected:
    int                m_iFactoryToken;
    FNOBJECTCREATOR    m_pFnCreate;
    const CFactory  *m_next;

    static const CFactory *m_pFactoryList;
};

const CFactory *CFactory::m_pFactoryList = NULL;

/////////////////////////////////////////////////////////////////////////////
//    Simple macros to implement and create the factories

#define DEFINE_FACTORY()                            \
        public:                                        \
        static CObjBase* CreateObject();

#define IMPLEMENT_FACTORY(classname,iToken)            \
        CObjBase *classname::CreateObject()            \
        {                                            \
            return new classname;                    \
        }                                            \
        static CFactory UNIQUE(sFactory)(iToken,classname::CreateObject);    \

/////////////////////////////////////////////////////////////////////////////
//    Sample implementation

class CObj1 : public CObjBase
{
    DEFINE_FACTORY()
public:
    CObj1()
    {
        puts(__FUNCTION__);
    }
    ~CObj1()
    {
        puts(__FUNCTION__);
    }
};
IMPLEMENT_FACTORY(CObj1,1)

class CObj2 : public CObjBase
{
    DEFINE_FACTORY()
public:
    CObj2()
    {
        puts(__FUNCTION__);
    }
    ~CObj2()
    {
        puts(__FUNCTION__);
    }
};
IMPLEMENT_FACTORY(CObj2,2)

class CObj3 : public CObjBase
{
    DEFINE_FACTORY()
public:
    CObj3()
    {
        puts(__FUNCTION__);
    }
    ~CObj3()
    {
        puts(__FUNCTION__);
    }
};
IMPLEMENT_FACTORY(CObj3,3)

// Error 
//IMPLEMENT_FACTORY(CObj3,2)

/////////////////////////////////////////////////////////////////////////////
//    Sample code

int _tmain(int argc, _TCHAR* argv[])
{
    std::auto_ptr<CObjBase> p1(CFactory::CreateObject(1));
    std::auto_ptr<CObjBase> p2(CFactory::CreateObject(2));
    std::auto_ptr<CObjBase> p3(CFactory::CreateObject(3));
    return 0;
}

Hallo.

Erstmal vielen vielen Dank fürs vorkauen.
Hatte das mit der verketteten Liste nicht verstanden, bzw. noch nie gesehen.

Funktioniert so weit. Habe nun versucht statt dem int iToken direkt den Klassennamen zu verwenden.

Also so:

#define IMPLEMENT_FACTORY(classname)            \
	CObjBase *classname::CreateObject()            \
	{                                            \
		return new classname();                    \
	}                                            \
	static CFactory UNIQUE(sFactory)(classname,classname::CreateObject);

Und natürlich alles andere dementsprechend auch angepasst.

Nun erhalte ich allerdings nen Fehler beim Aufruf des Makros

Syntaxfehler: Bezeichner 'CreateObject'. Was ist den daran nun falsch?

Ok. Natürlich. Habs raus:

#define IMPLEMENT_FACTORY(classname)            \
    CObjBase *classname::CreateObject()            \
    {                                            \
        return new classname();                    \
    }                                            \
static CFactory UNIQUE(sFactory)(#classname,classname::CreateObject)

Die Raute machts!!

Hallo nochmal.

Jetzt habe ich noch eine Frage: Ich habe das Beispiel nun auf meine Klassen angewendet. Nun musste ich feststellen, dass die Makros nur dann ausgeführt werden, und somit auch die Initialisierung der statischen Liste nur durchgeführt wird, wenn die Klasse schon einmal verwendet wurde.

Deshalb hatte ich auch das Problem, dass beim IMPLEMENT_SERIAL von MFC meine Klasse gar nicht in der Liste erschien. Mein Test ergab auch hier: erst wenn die Klasse einmal verwendet wurde, wird auch das Makro ausgeführt und meine Klasse erscheint in der RuntimeClass Liste.

Woran liegt das?

Martin Richter

Weil der Linker nur die Teile linkt, die auch benötigt werden...
Alles andere wirft er weg. Wäre ja schlimm wenn es nicht so wäre.

Du hast wahrscheinlich die statischen Objekte im selben CPP Modul liegen...
Das geht natürlich nicht, denn ein ganzes Modul wird nicht gelinkt, wnen es nicht benötigt wird. Ist doch auch logisch.

Packe mal alle statischen Objekte in ein andere CPP Modul, dass garantiert benötigt wird.

Du hast wahrscheinlich die statischen Objekte im selben CPP Modul liegen...

Na die statischen Objekte werden ja durch das Makro hinzugefügt.

static CFactory UNIQUE(sFactory)(#classname,classname::CreateObject)

Und wenn ich nun eine Klasse habe CObj1 dann habe ich dafür eine Obj1.cpp. Dort wird dann das Makro IMPLEMENT_FACTORY eingefügt und dort befindet sich ja dann auch das statische Objekt. Was will ich da anders machen?