Methoden werden nicht ausgeführt

Pria

Hallo,

habe jetzt neuerdings seid einiger Zeit ein paar Probleme mit dem Prinzip von statischen konstruktoren http://www.c-plusplus.net/forum/311196-10

Wenn ich im Debugbuild auf eine statische methode verweise, wird diese einfach übersprungen. Selbst mit haltepunkten und prozedurschritt führt der die funktion einfach nicht aus, der haltepunkt wird auch eigenmächtig einfach nach unten verschoben.

static void staticFunc();
static void _init()
{
  staticFunc(); //<- ignoriert
}

Woran kann das liegen?

Im Releasebuild werden neuerdings die konstruktoren nicht mehr aufgerufen, sodass das objekt erzeugt aber nicht die _init funktion der basisklasse ausgeführt wird.

Der basiskonstruktor muss doch aufgerufen werden, warum wird dann die methode nicht aufgerufen?

Skym0sh0

Kannst du mal Beispielcode posten, der den Fehler auch reproduziert?
Mit main-Funktion und der einen Klasse, wo das passiert.

class Foo
{
	static void static_bar(){}

public:
	Foo()
	{
		static_bar();
	}

	Foo(int)
	{ }
}

int main()
{
	Foo f(1);
}

Ich hoffe, du meinst nicht das (mit Basiskonstruktor) und wunderst dich, dass die statische Funktion nicht aufgerufen wird?!

Edit: ich hab den anderen Thread nicht gelesen, also kA was da diskutiert wurde.

Pria

//static_ctor.h
template<typename T>
class static_ctor
{
	bool toInit;

	public:
		inline static_ctor() 
		{ 
			if(!toInit)
				return;

			_init();
			toInit = false;
		}

	static inline void _init();
};

//myStaticClass.h
class myStaticClass
{
   public:
      inline static void doSomething() {}
};

//test.h
class test : static_ctor<test>
{	
    public:
	inline test(void* handle) : static_ctor<test>()
	{ }
};

//test.cpp
void static_ctor<test>::_init()
{
   myStaticClass::doSomething(); //<- ignored
}

main()
{
   test t = test(); //<- call static ctor
}

Sone

static auto b = []() -> bool {T::_init(); return true;}();

oO (nebenbei: unnötiger trailing-return-type und () )

static std::once_flag flag;
std::call_once( flag, T::_init );

Oder noch viel direkter:

static bool called;
if( !called )
{
    T::_init();
    called = true;
}

Pria

kein c++ 11 vorhanden

Sone

Ich rügte ja auch den Code aus dem verlinkten Thread.

Das inline ist bei Konstruktoren übrigens völlig überflüssig.

Und wo wird toInit initialisiert?

Skym0sh0

Pria schrieb:

kein c++ 11 vorhanden

Deswegen schlägt Sone ja die letzte Möglichkeit vor.

Sone

Edit: Nein, meine Version ist auch irre riesig. Im verlinkten Thread gibt es natürlich direktere Varianten.

Bashar

Sone schrieb:

Das inline ist bei Konstruktoren übrigens völlig überflüssig.

Wie meinst du das? Klingt vollkommen falsch.

Pria

Sone schrieb:

Und wo wird toInit initialisiert?

garnicht, ist zumindest im inspektor immer initial false

wie würde das letzte beispiel konkret in ausfürbarem code aussehen? ich brauche tatsächlich etwas, dass initial bei der objekterzeugung die statische initialfunktion auslöst und sich leicht in den klassencode einfügen lässt. Das wir unter anderem benutzt um funktionsbindungen zu erstellen, wenn der anwender das vergessen sollte fliegt ihm ansonsten der code um die ohren, deswegen möchte ich das direkt in die cpp der jeweiligen klasse integrieren.

SeppJ

Pria schrieb:

Das wir unter anderem benutzt um funktionsbindungen zu erstellen, wenn der anwender das vergessen sollte fliegt ihm ansonsten der code um die ohren, deswegen möchte ich das direkt in die cpp der jeweiligen klasse integrieren.

Erzähl mal mehr. Idealziel in C++ ist, dass man alle Programmierfehler zur Compilezeit abfängt und nicht erst zur Laufzeit auftreten lässt. Aufgrund der strengen Regeln in C++ ist dies in sehr vielen Fällen möglich.

Pria

SeppJ schrieb:

Erzähl mal mehr. Idealziel in C++ ist, dass man alle Programmierfehler zur Compilezeit abfängt und nicht erst zur Laufzeit auftreten lässt. Aufgrund der strengen Regeln in C++ ist dies in sehr vielen Fällen möglich.

z.b. OpenGL Shading

class Shader
{
   public:
      static_ctor()
      {
          CreateShader.Bind(GetProcAddress("glCreateShader")); assert(CreateShader); //dynamic linking
          ...
      }

      bool Create(?? type)
      {
          uint handle = CreateShader(type); //crashes if not bound, null-pointer exception
          return (uint != 0);
      }
};

Pria

Wie würde es sich denn bei folgender Änderung verhalten?

template<typename T>
class static_ctor
{
    typedef bool (*ptr) ();
    bool toInit;

    public:
        inline static_ctor(ptr _init)
        {
            if(!toInit)
                toInit = _init();
        }
};

class test : public static_ctor<test>
{
   public:
      static void init();
      test() : static_ctor<test>(&test::init) {}
};

Sone

Bashar schrieb:

Sone schrieb:

Das inline ist bei Konstruktoren übrigens völlig überflüssig.

Wie meinst du das? Klingt vollkommen falsch.

Gut, da war ich zu pauschal. Wenn man eine Memberfunktion in der Klasse definiert wird, dann ist sie automatisch inline , darauf spielte ich an.

Pria

So, habe das Problem nach etwas Grübeln soweit gelöst, indem ich das wie bereits in meinem letzten Post abgeändert und in den Klassen einen Funktionspointer definiert habe, der anstatt dem T::-init ausgeführt werden soll.

Danach hat sich das Problem erledigt, ich vermute war entweder ein Linker oder Optimizer problem.

SeppJ

Pria schrieb:

Danach hat sich das Problem erledigt, ich vermute war entweder ein Linker oder Optimizer problem.

Das war ein simpler Anfängerfehler! Sone hat ihn dir erklärt! Es bedarf wohl einer speziellen Art Mensch, um da trotzdem die Fehler noch woanders zu suchen. Ich sehe da bei so einer Einstellung Schwarz für deine künftigen Programmierunternehmen.

Deine Antwort auf meine Gegenfrage, was das Ganze überhaupt soll, fand ich auch nicht befriedigend, aber das ist dein Problem, wenn du keine bessere Hilfe möchtest, werde ich mich nicht aufdrängen. Aber obiger Absatz musste gesagt sein. Vielgetestete Programme laufen korrekt für alles was du jemals ausprobieren wirst. Die Fehler liegen bei dir, du musst sie auch dort suchen, wenn du jemals besser werden möchtest.