Funktions-Prototyp in C

[Noki (Gast)]

Hallo,

folgendes:
ich habe zwei *.c-Datein


--------Datei 1---------
void main(void)
{
   init();
...
}

--------Datei 2---------
//Prototyp
void init(void);

void init(void)
{
  int a=0;
...
}

wenn ich compiliere, dann bekomme ich eine Fehlermeldung, dass die 
Funktion "init()" kein Prototyp besitz. Ich habe doch in der "Datei 2" 
ein Prototyp erstellt, warum bekomme ich trotzdem eine Fehlermeldung?

Muss ich in beiden *.c-Dateien den Prototyp anlegen?

Kann mir da jemand bitte behilflich sein?

[Daniel P. (ppowers)]

Also normalerweise würde man den Funktionsprototyp in einer .h-Datei 
ablegen und diese .h-Datei dann überall, wo die Funktion verwendet wird 
(also in Deinem Fall in beiden .c-Dateien) durch ein #include xxx.h 
einbinden.

[RyouArashi (Gast)]

Der Prototyp muss in der c-Datei stehen, in der die externe Funktion 
aufgerufen werden soll. Werden Funktionen von mehreren anderen Modulen 
verwendet, sollte man auf jeden Fall Header-Files benutzen, bei kleinen 
Programmen gehts aber auch ohne (Programmierer sind von Natur aus faul 
^.^)

--------Datei 1---------
//Prototyp
void init(void);

void main(void)
{
   init();
...
}

--------Datei 2---------
void init(void)
{
  int a=0;
...
}

[Peter S. (psavr)]

Die Datei-1 muss den Prototyp zum compileren ebenfalls "kennen"

--------Datei 1---------
extern void init(void);

void main(void)
{
   init();
...
}

Aber besser als das extern Keyword zu verwenden wäre, den Prototyp in 
einer Header-Datei für Datei-2 zu deklarieren dann diese Header-Datei in 
der Datei-1 und Datei-2 zu includen. Dies ist auch der übliche Weg.

--------init.h---------
//Prototyp
void init(void);
...

--------init.c---------
#include "init.h"

void init(void)
{
  int a=0;
...
}

--------main.c---------
#include "init.h"

void main(void)
{
   init();
...
}

[Noki (Gast)]

>Der Prototyp muss in der c-Datei stehen, in der die externe Funktion
>aufgerufen werden soll.

ist aber nicht der Fall.
wenn ich nicht in beiden Dateien den Prototyp einfüge, bekomme ich 
Fehlermeldung dass der Prototyp nicht existiert

ich lege doch ein "Prototyp.h"-Header an und füge es über ein, wo es 
benutzt wird. Mit der Zeit werden es immer mehr Funktionen werden, daher 
lieber jetzt schon Prototyp-Header anlegen ;-)

Vielen Danke @ All

[Karl H. (kbuchegg)]

Noki wrote:
>>Der Prototyp muss in der c-Datei stehen, in der die externe Funktion
>>aufgerufen werden soll.
>
> ist aber nicht der Fall.
> wenn ich nicht in beiden Dateien den Prototyp einfüge, bekomme ich
> Fehlermeldung dass der Prototyp nicht existiert

Das halte ich für ein Gerücht (zumindest in der obigen Konfiguration).
Du musst dir vor Augen halten, welchen Zweck denn der Protoyp
erfüllt.

Er dient dazu, damit der Compiler überprüfen kann, ob

* es eine Funktion mit dem angegebenen Namen überhaupt gibt
  (könnte ja auch ein Tippfehler im Funktionsnamen sein)

* der Funktionsaufruf auch tatsächlich so erfolgt, wie ihn
  die Funktion erwartet.
  Das heist: ob die richtige Anzahl an Argumenten angegeben it
  bzw. ob die Datentypen der Argumente korrekt sind.

  Wenn die Datentypen der Argumente nicht übereinstimmen, kann
  der Compiler durch Vergleich mit den im Protoypen angegebenen
  Datentypen auch herausfinden, ob er mit Casts eine Angleichung
  durchführen kann.

* die Funktion einen Rückgabewert liefert und, wenn ja, von welchem
  Datentyp dieser ist.
  Auch hier wieder: Liefert die Funktion einen Wert zurück und
  wird dieser Wert einer Variablen zugewiesen, so kann der
  Compiler durch Vergleich der Datentypen herausfinden, ob
  er eventuell mit einem impliziten Cast nachhelfen mus, oder
  ob eine Zuweisung aufgrund der Datentypen überhaupt nicht geht.

All diese Dinge beziehen sich rein auf die Verwendung der Funktion,
also auf den eigentlichen Funktionsaufruf. Daher muss der Protoyp
konsequenterweise lediglich beim Aufruf ichtbar sein.

Es empfiehlt sich allerdings, wie weiter oben auch schon gezeigt,
den Protoypen auch in der Source-Unit verfügbar zu machen, in der
die eigentliche Defintion der Funktion durchgeführt wird. Kein
Mensch (und auch kein Compiler) kann nämlich ansonsten in allen
Fällen sicher stellen, dass der Protoyp auch mit der tatächlich
implementierten Funktion übereinstimmt.

> ich lege doch ein "Prototyp.h"-Header an und füge es über ein, wo es
> benutzt wird. Mit der Zeit werden es immer mehr Funktionen werden, daher
> lieber jetzt schon Prototyp-Header anlegen ;-)

Das ist der richtige Weg.
Allerdings, wenn die Projekte größer werden, ist es keine so gute
Idee, alle Prototypen in nur einem einzigen Header File zu sammeln.
Die übliche und bewährte Vorgehensweise ist es, für jedes *.c
File ein Header File gleichen Namens, nur mit der Endung *.h
anzulegen.
Ein LCD.C File besitzt also ein LCD.H File.
Ein UART.C File bringt ein UART.H File mit.
Ein LISTE.C File hat ein LISTE.H File zugeordnet.

In all diesen Fällen gilt: Im Header File ist alles enthalten,
was ein Verwender der jeweiligen Funktionalität benötigt.
Also alle extern sichtbaren Datenstrukturen, Vereinbarungen von
Konstanten etc. und selbstverständlich auch die Protoypen der
Funktionen die von dieser Funktionalität zur Verfügung gestellt
werden.