Zuerst mal etwas kurzen Code:
Base.hpp

typedef unsigned int t_Type;

class CBase
{
    // Static attributes //
public:
    static t_Type register_type();

    // Methods //
public:
    virtual t_Type get_type() const = 0;
};

Base.cpp

#include "Base.hpp"

t_Type CBase::register_type()
{
    static t_Type TypeCounter = 0;
    return TypeCounter++;
}

ExampleType.hpp

#include "Base.hpp"

class CExampleType : public CBase
{
    // Static attributes //
public:
    static t_Type const TYPE;

    // Methods //
public:
    virtual t_Type get_type() const { return TYPE; };
};

ExampleType.cpp

#include "ExampleType.hpp"

t_Type const CExampleType::TYPE = CBase::register_type();

main.cpp oder sonst wo halt

CBase* pBase; // Gültiger zeiger auf ein Object, wessen Klasse von CBase abgeleitet wurde.

switch(pBase->get_type())
{
case CFooType::TYPE :
    { write_object(*dynamic_cast<CFooType*>(pBase)); }
    break;
case CExampleType::TYPE :
    { write_object(*dynamic_cast<CExampleType*>(pBase)); }
    break;
// ...
}

Dabei kommt der Fehler:
case expression not constant

Wenn ich das richtig begreife, dann kommt dies deswegen, weil die TYPE Variablen erst zur Laufzeit mit Werten befüllt werden, oder?

Was habe ich für alternativen?

• If Else will ich nicht, das sind zu viele Typen.
• Für eine Map bräuchte ich zuerst einen Funktor, welcher das dynamic_cast und die Dereferenzierung durchführt. Welcher aber noch ziemlich komplex werden könnte, für sowas einfaches, da der dynamic_cast immer mit einer anderen Klasse ausgeführt wird.
• Ich könnte auch eine Map machen, welche immer auf eine andere Funktion zeigt, aber viel zu viel Aufwand.
• Sonstiges?

Danke für weitere Ideen!

Grüssli

Wie wäre es mit einem template Funktor?

Überleg mal, das geht nicht so einfach. Du kannst einer Map nur ein Typ als zweiter Typ übergeben. Als müsste man wohl Polymorphie für den Funktor anwenden, was die Sache ein wenig zu komplex, für einen normalen Funktor macht.

Chewie83 schrieb:

Warum versuchst Du, das nachzubauen, was bereits in der Sprache drin ist? Implementier den write_object-Aufruf in virtuellen Methoden der jeweiligen Klasse und lass den Compiler diese Entscheidungstabelle generieren - genau dafür sind doch virtuelle Methoden da.

Wenn es so einfach wäre. CBase kommt aus einer Baum-Klassenstruktur. Die ExampleTypes sind Blätter und Knoten, welche das Interface dieser Klassenstruktur benutzen. Diese Baum-Klassenstruktur wird allerdings auch in anderen Hierarchien verwendet, wo es kein write_object benötigt. Das write_object ist halt Teil eines Writers, welcher die Daten auf seine Weise in eine Datei schreibt.

Aber trotz dem, dass deine Idee zwar nicht funktioniert, so hast du mich grad auf eine andere gebracht, welche ich mal überprüfen werde. Danke!

Falls noch jemand Ideen hat, immer her damit

Grüssli

Falls noch jemand Ideen hat, immer her damit

Wenn Du die write-Object-Methode lieber extern implementieren möchtest kannst Du das ja immer noch tun, indem Du es sozusagen als Visitor implementierst.

Wenn Du die write-Object-Methode lieber extern implementieren möchtest kannst Du das ja immer noch tun, indem Du es sozusagen als Visitor implementierst.

Etwas in der Richtung verfolge ich gerade. Bin mir aber immer noch nicht zu 100% sicher, ob es funktioniert und schön aussieht.

Es ist manchmal echt schlimm. Man löst verschiedene Probleme und mit der Zeit verbohrt man sich auf gewisse Konzepte und übersieht völlig, dass auch anderes noch gehen würde. Das alte Konzept zwar beibehalten, aber neues dazu setzen. Aber dafür hat man ja zumindest dieses schöne Forum

Grüssli