Klasse + Array + Enum

_frank_

Hallo,

ich möchte in einer Klasse ein array definieren und für die Felder (als Index) ein Enum verwenden.

hier mal der Code:

enum
{
	evClicked=0,//without parameter
	evDoubleClicked,//without parameter
	evMouseDown,//parameters: mouse-button and position
	evMouseUp,//parameters: mouse-button and position
	evSelChanged,//also used for Pagecontrol-switch; without paramaters

	evMax
};

class LuaControl
{
protected:
	lua_State* L;
	int events[evMax]={0};//array for holding lua-function-pointer
public:
	LuaControl(lua_State *l): L(l) {}
};

wie zu erkennen ist, geht es mir um das Feld events...der Compiler zeigt mir folgende Meldungen:

lgui.cxx:61: error: a brace-enclosed initializer is not allowed here before ‘{’ token
lgui.cxx:61: error: ISO C++ forbids initialization of member ‘events’
lgui.cxx:61: error: making ‘events’ static
lgui.cxx:61: error: invalid in-class initialization of static data member of non-integral type ‘int [5]’

leider kann ich mit der Fehlermeldung gar nix anfangen...außer vielleicht geht nicht
Zeile 61 ist die "int events[evMax]={0};"

ich hoffe, jemand kann mir erklären, warum das nicht geht, was ich vorhabe und wie man es evtl umbauen könnte.

Gruß Frank

SeppJ

Das hat nix mit enums zu tun, sondern nur mit Klassen und Arrays. Du kannst allgemein ein Array einer Klasse nicht so initialisieren wir du es dort vor hast. Gerade dafür ist der Konstruktor da.

_frank_

Danke für die schnelle Antwort

wenn ich die Initialisierung in den Constructor verlege:

LuaControl(lua_State *l): L(l) {events={0};}

bekomme ich nachfolgende Warnung (zumindest der error ist weg), welche ich aber auch nicht unbedingt ignorieren will...

extended initializer lists only available with -std=c++0x or -std=gnu++0x

wo und wie muss ich diese Option setzen?

Gruß Frank

SeppJ

Das ist ja auch falsches C++ (zumindest nach aktuellem Standard). Arrays musst du tatsächlich elementweise im Konstruktor initialisieren. Den ganzen Ärger hättest du übrigens nicht mit einem vernünftigen Array-Wrapper wie std::vector oder boost::array.

Willst du die C++0x-Features nutzen die dein Compiler offenbar schon unterstützt, dann musst du ihm eine der angegebenen Optionen einfach über die Kommandozeile mitgeben.

_frank_

std::vector siht mir für meinen Zweck bisschen zu umfangreich aus...
ich möchte einfach nur das array mit 0 initialisieren, da darin später pointer landen sollen.

die sache mit der Kommandozeilenoption ist sicher nicht die sauberste, nehme ich an.

ich vermute mal, die sinnvollste/sauberste Variante dürfte eine schleife im constructor sein, oder?

Gruß Frank

SeppJ

frank schrieb:

std::vector siht mir für meinen Zweck bisschen zu umfangreich aus...

Na, wenn du dir das Leben schwer machen willst, ist das dein Problem .

ich möchte einfach nur das array mit 0 initialisieren, da darin später pointer landen sollen.

Das klingt äußerst abenteuerlich...

die sache mit der Kommandozeilenoption ist sicher nicht die sauberste, nehme ich an.

So lala. es ist halt durch den aktuellen Standard nicht gedeckt. Aber es wird aller Voraussicht nach bald kommen. Und es wird jetzt schon von vielen Compilern unterstützt. Aber du kannst dann dein Programm nicht mit einem Compiler übersetzen, welcher den neuen (noch nicht verabschiedeten) Standard nicht unterstützt.

ich vermute mal, die sinnvollste/sauberste Variante dürfte eine schleife im constructor sein, oder?

Ja, das wäre der Klassiker.

_frank_

SeppJ schrieb:

Na, wenn du dir das Leben schwer machen willst, ist das dein Problem .

hab nurmal grob das hier überflogen...schaut komplizierter aus, als wenn ich das array in ner schleife initialisiere...möchte den code schließlich auch verstehen

SeppJ schrieb:

Das klingt äußerst abenteuerlich...

wüsste nicht wie ich es machen soll, da diese Pointer die callback-Adressen eines LUA-Scripts sind.

Gruß Frank

SeppJ

frank schrieb:

wüsste nicht wie ich es machen soll, da diese Pointer die callback-Adressen eines LUA-Scripts sind.

Es würde schonmal mal helfen, wenn das Array ein Array von Pointern wäre...

_frank_

also "int *events[evMax]", da es ja untypisierte pointer sind, richtig?

Ja, aber was hat das mit untypisierten Zeigern (void*) zu tun?

SeppJ

frank schrieb:

also "int *events[evMax]", da es ja untypisierte pointer sind, richtig?

So sind es doch Pointer auf int. Meinst du vielleicht Pointer auf void? Ansonsten würden sich natürlich auch Funktionspointer anbieten, aber dafür müsste ich genauer wissen, was du vor hast.

Roger Wilco

Wäre es nicht wirklich das sauberste/sicherste mit einem std::vector und shared_ptr zu arbeiten?

#include <vector> //std::vector
#include <memory> //std::tr1::shared_ptr

class MyClass;
typedef std::tr1::shared_ptr<MyClass> MyClassPtr;

class Example{

    public:
        Example(){ };  // Man muss nichts machen!
        ~Example(){ }; // ...auch hier nicht! :-)

    public:
        void AddClass(const MyClass& myClass)
        {
            m_myClassCollection.push_back(myClass);
        }
        MyClassPtr CreateNewMyClass()
        {
            MyClassPtr newMyClass(new MyClass());
            m_myClassCollection.push_back(newMyClass);
            return newMyClass;
        }
        size_t GetMyClassCount()
        {
            return m_myClassCollection.size();
        }
    private:
        std::vector<MyClassPtr> m_myClassCollection;
};

Nirgendwo musst du etwas initialisieren oder Dich um die Gültigkeit der Zeiger kümmern oder delete aufrufen. Es wird dir alles abgenommen! Innerhalb als auch außerhalb der Beispiel-Klasse.

_frank_

ne ganze klasse um einen Pointer zu halten? zumal ich sowas wie myClass nicht habe...
es sind wirklich untypisierte Zeiger (void*), die gehalten werden müssen.
ich kann meines wissens auch keine funktionspointer draus machen (wie es bei WinApi o.ä. gemacht wird).

das ganze funktioniert so:
http://stackoverflow.com/questions/2688040/how-to-callback-a-lua-function-from-a-c-function

lua_rawgeti(L,LUA_REGISTRYINDEX,callback_function);
//push the parameters and call it
lua_pushnumber(L, 5); // push first argument to the function
lua_pcall(L, 1, 0, 0); // call a function with one argument and no return values

in sämtlichen c/c++-codes, die ich finde wird die ADresse auch in einem Int hinterlegt statt einem Pointer.

int function_index = luaL_ref(L, LUA_REGISTRYINDEX);

in meiner Klasse möchte ich verschiedene solche Funktionen speichern können (für die Ereignisse aus dem Enum), somit ein array mit der Anzahl Elemente gleich der möglichen Ereignisse

ich hoffe, ich habe ein bisschen Licht ins Dunkel gebracht

Gruß Frank