Reihenfolge von Funktionen

[Holzi (Gast)]

Ich versuche in Funktion 1 die Funktion 2 aufzurufen. Aber in Funktion 2 
die unter Funktion 1 steht möchte ich gerne auch Funktion 1 aufrufen!

void funktion 1()
{
  ..
  funktion2();
  ..
}

void funktion 2()
{
  ..
  funktion1();
  ..
}

so funktioniert das aber nicht! Gibt es da einen Trick wie man das 
umgehen kann?

[Doofkopp (Gast)]

Prototypen?

[A. H. (Gast)]

void funktion1()
void funktion2()

void funktion1()
{
  ..
  funktion2();
  ..
}

void funktion2()
{
  ..
  funktion1();
  ..
}

Wie Doofkopp schon gesagt hat, über Prototypen geht es. Und vermeide 
Leerzeichen in Funktionsnamen, das kann dann nicht funktionieren.

[Ratlos (Gast)]

Funktionen die sich gegenseitig aufrufen?
Rekursiv, kann zum Stacküberlauf führen,
da hilft dann kein Trick.
Die Reihenfolge der Funktionen im Listing ist eh' egal.

[Jerome (Gast)]

void function1(void);
void function2(void);

void funktion1()
{
  ..
  funktion2();
  ..
}

void funktion2()
{
  ..
  funktion1();
  ..
}

[A. H. (Gast)]

Mist, jetzt habe ich etwas vergessen ... am Ende der ersten beiden 
Zeilen muss jeweils ein Semikolon

[Rufus Τ. F. (rufus)]

Holzi schrieb:
> so funktioniert das aber nicht!

Doch, das tut es. Es muss nur zum Zeitpunkt des Aufrufs einer Funktion 
bekannt sein, daß es sie gibt - C-Programme werden "von oben nach unten" 
übersetzt.

Mit einem Funktionsprototypen kann man genau das erreichen. Der besagt, 
daß es eine Funktion gibt, und welche Datentypen sie nutzt.
Die Implementierung (also der Funktionsrumpf) kann dann irgendwann 
später erfolgen - auch in einem anderen Modul, das erst vom Linker zum 
Programm dazugepackt wird.


In Deinem Beispiel genügt es, die Zeile

void funktion2(void);

vor die Implementierung von funktion1 zu schreiben.

[Mark B. (markbrandis)]

Rufus Τ. Firefly schrieb:
> Doch, das tut es. Es muss nur zum Zeitpunkt des Aufrufs einer Funktion
> bekannt sein, daß es sie gibt - C-Programme werden "von oben nach unten"
> übersetzt.

Mir ist klar, dass dies in C so ist, aber ehrlich gesagt habe ich nie 
verstanden warum.

Was spräche denn dagegen,
1.) einmal main() zu durchlaufen und festzustellen, welche Funktionen 
aufgerufen werden
2.) nachzuprüfen, ob alle nach 1.) erforderlichen Funktionen auch 
tatsächlich vorhanden sind?

Dass das hier funktioniert:

void funktion()
{
  // tu was
}

int main()
{
  funktion();
  return 0;
}

aber das hier nicht:

int main()
{
  funktion();
  return 0;
}

void funktion()
{
  // tu was
}

ist doch eigentlich Käse. ;)

Okay, vielleicht gibt es einen super wichtigen Grund, warum es nur genau 
so und nicht anders sein darf. Dann sagt ihn mir bitte :)

[Karl H. (kbuchegg)]

Mark Brandis schrieb:
> Rufus Τ. Firefly schrieb:
>> Doch, das tut es. Es muss nur zum Zeitpunkt des Aufrufs einer Funktion
>> bekannt sein, daß es sie gibt - C-Programme werden "von oben nach unten"
>> übersetzt.
>
> Mir ist klar, dass dies in C so ist, aber ehrlich gesagt habe ich nie
> verstanden warum.

Weil die Funktionen keineswegs in der gleichen Datei sein müssen. Die 
können irgendwo sein.

> Was spräche denn dagegen,
> 1.) einmal main() zu durchlaufen und festzustellen, welche Funktionen
> aufgerufen werden
> 2.) nachzuprüfen, ob alle nach 1.) erforderlichen Funktionen auch
> tatsächlich vorhanden sind?

Dann hast du 2 Mechanismen
zum einen werden Funktionen in der selben Übersetzungseinheit 
automatisch gefunden
während Funktionen die nicht in dieser Übersetzungseinheit sind, erst 
recht wieder einen Protoypen benötigen.

Was wäre also gewonnen?
Nichts

> Okay, vielleicht gibt es einen super wichtigen Grund, warum es nur genau
> so und nicht anders sein darf. Dann sagt ihn mir bitte :)

Der Compiler wird einfacher, wenn er den Quelltext einfach nur 1 mal 
durchgehen muss.
Vergiss nicht, dass die Ursprünge der meisten Sprachen weit in die 60-er 
Jahre des letzten Jahrhunderts zurückreichen. Damals war Speicherplatz 
noch kostbar und teuer.

[Mark B. (markbrandis)]

Karl heinz Buchegger schrieb:
> Der Compiler wird einfacher, wenn er den Quelltext einfach nur 1 mal
> durchgehen muss.
> Vergiss nicht, dass die Ursprünge der meisten Sprachen weit in die 60-er
> Jahre des letzten Jahrhunderts zurückreichen. Damals war Speicherplatz
> noch kostbar und teuer.

Gewiss. Darf man aber auch im 21. Jahrhundert keinen 
Multiple-Pass-Compiler für die Sprache C haben?

[Karl H. (kbuchegg)]

Mark Brandis schrieb:
> Karl heinz Buchegger schrieb:
>> Der Compiler wird einfacher, wenn er den Quelltext einfach nur 1 mal
>> durchgehen muss.
>> Vergiss nicht, dass die Ursprünge der meisten Sprachen weit in die 60-er
>> Jahre des letzten Jahrhunderts zurückreichen. Damals war Speicherplatz
>> noch kostbar und teuer.
>
> Gewiss. Darf man aber auch im 21. Jahrhundert keinen
> Multiple-Pass-Compiler für die Sprache C haben?

Man darf schon.
Aber auch dann darf der Compiler nicht eigenmächtig neue C-Regeln 
erfinden.

Ist vielleicht nicht ganz klar rüber gekommen:
So manches Sprachdetail in den älteren Programmiersprachen hat seine 
Begründung in den limitierten Resourcen von damals.

C hat seine Wurzeln in einer Zeit, in der von einer IDE noch nicht 
einmal geträumt wurde. Projekt, was ist das?

C enstand mit dem Hintergedanken: Da gibt es einen Haufen Source Files, 
die irgendwie durch den Compiler müssen. Und zwar einzeln. Alles andere 
ist Sache des Programmierers.