Frage an STL GURUS!!!!!

pumuckl

Badestrand schrieb:

// Für alles, was mit reinterpret_cast nicht möglich ist:
template<typename U,typename T>
U forbidden_cast( T p )
{
	assert( sizeof(T) == sizeof(U) );

	union Shared
	{
		T p1;
		U p2;
	};

	Shared s;
	s.p1 = p;
	return s.p2;
}

Was ist denn z.B. mit reinterpret_cast nicht möglich?
Und wo ist außer dem assert der wesentliche Unterschied?

Badestrand

pumuckl schrieb:

Was ist denn z.B. mit reinterpret_cast nicht möglich?
Und wo ist außer dem assert der wesentliche Unterschied?

Ich hatte es nur kurz ausprobiert, aber die Umwandlung von Member-Function-Pointer nach void* wollte reinterpret_cast nicht machen.

Tobias Harley

hey also das ganze funktioniert echt super mit Visual Studio, leider beendet es der MinGW Compiler mit einer unhandled win32 exception. Aber vielleicht gibt es ja auch noch eine C++ Standart konforme(re) Lösung für dieses Problem, ich würde es gerne kompatibel zu mehreren Compilern halten?

grüsse
Tobber

LordJaxom

Ja, gibt es, über Template-Parameter, ohne üble Hacks. Vielleicht schilderst Du mal, warum Du meinst, diesen Hack zu brauchen. Vielleicht kann man Dich dann davon überzeugen, dass dem nicht so ist.

hustbaer

Zwischen Datenzeigern (auch void*) und Funktionszeigern zu casten ist in C++ nicht erlaubt. Manche Compiler unterstützen es, aber wie gesagt, erlaubt ist es nicht.

Was spricht gegen die Verwendung von boost::function<> oder ähnlichem?

Tobias Harley

Hi,

ja gerne, also ich baue ein kleines Reflection System (oder versuche es), sieht "grob" so aus (ohne syntactic sugar)

class Test : public Object {
public:
    Test();
    ~Test();

private:
    int i;
    list<string> strList;

public:
    void reflect( System* sys ) {
        sys->addClass( "Test" );
        sys->addProperty( "i", TYPE_INTEGER, &i );

        // mein problemkind.
        sys->addSTLProperty( "strList", TYPE_STL_LIST, 
             /* zeiger auf container */ 
             &strList, 
             /* Memberfunctionpointer auf void* casten */
             forbidden_cast <void*>( &list<string>::push_back ) );
    }
};

Nun will ich mit nur einem (void*) Pointer auf eine Instanz (von Test), und der generierten Typinformation, Elemente in meine Lise (strList) einfügen. Was auch mit der von badestrand gezeigten Methode wunderbar funzt, aber leider nur im Visual Studio, der MinGW macht da nich mit.

Ich hoffe das Code-Stück stellt meine Problematik dar.

dank und gruß
Tobber

hustbaer

Mal ganz davon abgesehen dass ich nicht glaube dass das so eine gute Idee ist...:

boost::shared_ptr<void> pushBackFunctor(new boost::function<void (int)>(boost::bind(&list<string>::push_back, &strList, _1)));

sys->addSTLProperty( "strList", TYPE_STL_LIST, 
             &strList, 
             pushBackFunctor);

Jetzt castest du Datenzeiger, und das ist erlaubt.

hustbaer

BTW: bau dir doch gleich kleine Helper-Templates:

class WrappedProperty
{
public:
    WrappedProperty(char const* name):
        m_name(name)
    {
    }

    char const* GetName() const { return m_name; }
    virtual int GetTypeCode() const = 0;
private:
    char const* m_name;
};

template <class T> ScalarTypeCodeMap;

template <> ScalarTypeCodeMap<int> {
    static const int TypeCode = 1;
}

template <> ScalarTypeCodeMap<char> {
    static const int TypeCode = 2;
}

// ...

template <class T> WrappedScalar : public WrappedProperty
{
public:
    virtual int GetTypeCode() const { return ScalarTypeCodeMap<T>::TypeCode; }

    T value;
};

class WrappedCollectionProperty : public WrappedProperty
{
public:
    virtual void PopFront() = 0;
    virtual void PopBack() = 0;
    virtual void Clear() = 0;
    virtual size_t GetSize() = 0;
    virtual size_t GetCapacity() = 0;
};

// ...

hustbaer

BZW. noch eine Frage: was willst du mit diesem Reflection-System eigentlich erreichen?

drakon

hustbaer schrieb:

BZW. noch eine Frage: was willst du mit diesem Reflection-System eigentlich erreichen?

Frage ich mich gerade auch.. Wenn man da sowieso alles von Hand eintragen muss ist der Spass ja weg..

Ich denke mal, das man das mit Typlisten automatisch erledigen kann, allerdings wäre die Klassenerzeugung so etwas von umständlich und unhandlich, dass man es eigl. glatt vergessen kann..