werden aufrufe bei der optimierung restlos entfernt?

Sovok

long Funktion ( char* )
{
  #ifdef _DEBUG
  //mach was
  //mach was
  //mach was
  #endif

  //es wir eine konstante zurückgegeben
  return 0;
}

int main()
{
  //der rückgabewert wird nicht zugewiesen/ausgewertet
  Funktion ( "test" );
  return 0;
}

die frage ist ob der c++ standard besagt, dass funktionsaufrufen zu leeren funktionen vom compiler entfernt werden dürfen

oder falls der c++ standard nichts dazu sagt, ob vc++/gcc den aufruf in der release fassung rauswerden würden

(bitte keine vermutungen... vermuten kann ich selber ;))

ziel ist es solchen code zu vermeiden:

int main()
{
  #ifdef _DEBUG
    Funktion ( "test" );
  #endif

  return 0;
}

Bashar

Sovok schrieb:

die frage ist ob der c++ standard besagt, dass funktionsaufrufen zu leeren funktionen vom compiler entfernt werden dürfen

Der Standard sagt nichts über die Codegenerierung, nur etwas über die Ausführungssemantik. Solange diese gleich bleibt, hat ein Compiler jegliche Freiheit bei der Umsetzung, inklusive Optimierung. Du kannst nicht herausfinden, ob der Funktionsaufruf wegoptimiert wurde oder nicht, also geht diese Frage den Standard nichts an.

Ich würde sagen, du hast gute Chancen, wenn die Funktion in der Übersetzungseinheit, in der sie aufgerufen wird, auch mitsamt Definition sichtbar ist. Das zieht höchstwahrscheinlich nach sich, dass sie inline deklariert werden muss, um die One-Definition-Rule nicht zu verletzen. Ein sehr schlauer Compiler könnte die notwendigen Informationen dazu auch aus anderen Übersetzungseinheiten herausziehen, aber sowas ist eher die Ausnahme.

C++hristopher

Ich vermute mal, dass trotz aller Optimierungen der Aufruf nicht so einfach entfernt wird, selbst dann nicht, wenn die Funktion außer der berechnung absolut gar nichts macht, und das Ergebnis verworfen wird.

bitte keine vermutungen... vermuten kann ich selber

:p

SirLant

Bei folgendem Beispiel dürfte der Compiler höchstwarscheinlich die Funktion ignorieren

int foo ()
{
 return 0;
}

int main ()
{
 foo ();
 cout << "Hello World\n";
}

Aber müssen tut er es nicht

Sovok

ok andersrum gefragt

wie umgehe ich hässlichen code wie

#ifdef _DEBUG
  Funktion ( "test" );
#endif

oder

#ifdef _DEBUG
  #define FUNC(a) Funktion ( a )
#else
  #define FUNC(a)
#endif

int main()
{
  FUNC ( "test" );
  return 0;
}

und erreiche dass eine funktion nur in der debugfassung existiert

es geht um viele aufrufe in extrem zeitkritischen code
d.h. wenn ich durch alle aufrufe an leere funktionen zusammen
eine millisekunde verlier is mir das schon zuviel

otze

um eine millisekunde zu verlieren, müssten das verdammt viele aufrufe sein.

Bashar

Inline-Funktionen statt Makros verwenden.

void real_foo();

inline void foo() {
  #ifdef DEBUG
  real_foo();
  #endif
}
...
void blah() {
  foo();
}

Sovok

otze schrieb:

um eine millisekunde zu verlieren, müssten das verdammt viele aufrufe sein.

kommt wohl auch auf die grösse des systems an -> embedded
abgesehn davon summieren sich die aufrufe der oberen schichten an die unteren sehr schnell