4. IMPLEMENT_SERIAL und Kein Standardkonstruktor verfügbar

IMPLEMENT_SERIAL und Kein Standardkonstruktor verfügbar

  • ?

    Hallo.

    Danke für deine Hilfe. Bin noch nicht ganz durchgestiegen wie du das meinst, bzw. wie ich das realisieren soll. Vieleicht nochmal 10mal lesen 🙂

    Habe es jetzt erstmal so gemacht wie in deinem ersten Vorschlag. Mit IMPLEMENT_SERIAL und Dummy Daten.

    Wenn ich nun aber ein Objekt erzeugen will erhalte ich immer NULL. Wenn ich die Funktion CRuntimeClass::CreateObject debugge erscheint meine Klasse nicht in der Klassenliste.

    Was habe ich gemacht:

    1. Habe meine Klasse von CObject abgeleitet. CMyClass1 : public CObject
    2. Makro DECLARE_SERIAL(CMyClass1) in die Header
    3. Makro IMPLEMENT_SERIAL(CMyClass1,CObject,1) in die cpp
    4. in meiner Factoryklasse Aufruf:
    class = (CMyClass*)CRuntimeClass::CreateObject("CMyClass1");

    0
  • ?

    Kann das vieleicht daran liegen, dass meine Klasse in einem Namespace liegt

    0
  • Mod

    Möglich und wahrscheinlich.
    Debugge doch den MFC Code. Das ist doch nicht schwer.

    Das MFC CObject Modell unterstützt keine Namespaces! Die Namen der Klassen werden ohne Namespaces gespeichert.

    0
  • ?

    Debugge doch den MFC Code. Das ist doch nicht schwer.

    Habe ich doch gemacht, habe ich doch auch geschrieben.

    Also bei CreateObject wird ja die Methode FromName aufgerufen. In dieser Methode wird die Liste pModuleState->m_classList mit einer For-Schleife durchgegangen. Und in dieser Liste befindet sich meine Klasse nicht.

    Also wird es besser sein deinen anderen Vorschlag in die Tat umzusetzen?

    0
  • Mod

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

    0
  • ?

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

    Ja kann ich. Aber meiner ist halt nicht dabei.

    0
  • Mod

    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!

    0
  • ?

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

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

    0
  • ?

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

    0
  • ?

    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?

    0
  • ?

    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?

    0
  • ?

    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?

    0
  • Mod

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

    0
  • ?

    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.

    0
  • ?

    Noch ein Tipp?

    0
  • Mod

    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...

    0
  • ?

    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.

    0
  • ?
     

    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?

    0
  • Mod

    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;
}
    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?

    0
Anmelden zum Antworten