Deklaration einer Unterfunktion

[Tar (Gast)]

Wie deklariere ich die Unterfunktion richtig, so dass sie nach main 
stehen kann bzw. in einem eigenen Headerfile?

/* array10.c */
#include <stdio.h>
#include <stdlib.h>
#define MAX 10

void function(int feld[], int n_anzahl) {
   int i;

   for(i = 0; i < n_anzahl; i++)
      printf("%d; ", feld[i]);
   printf("\n");
}


int main(void) {
   int val[MAX];
   int i;

   for(i = 0; i < MAX; i++)
      val[i] = i+1;

   function(val, MAX);

   return 0;
}

[Mike M. (mikeii)]

/* array10.c */
#include <stdio.h>
#include <stdlib.h>
#define MAX 10

void function(int feld[], int n_anzahl);




int main(void) {
   int val[MAX];
   int i;

   for(i = 0; i < MAX; i++)
      val[i] = i+1;

   function(val, MAX);

   return 0;
}


void function(int feld[], int n_anzahl) {
   int i;

   for(i = 0; i < n_anzahl; i++)
      printf("%d; ", feld[i]);
   printf("\n");
}

Ansonsten den Prototypen in die *.h Datei und die Implementierung in die 
*.c Datei


Zur Erklärung, man schreibt den Kopf der Funktion erst mit Strichpunkt, 
damit der Compiler weiß, das es sowas geben wird.
Dann meckert er auch nicht, wenn die Funktion irgendwo als Aufruf 
entdeckt wird, bevor sie implementiert wurde

[Mike M. (mikeii)]

Sonst

/* array10.c */
#include <stdio.h>
#include <stdlib.h>
#include "fkt.h"

int main(void) {
   int val[MAX];
   int i;

   for(i = 0; i < MAX; i++)
      val[i] = i+1;

   function(val, MAX);

   return 0;
}

/*fkt.c*/

#include "fkt.h"
void function(int feld[], int n_anzahl) {
   int i;

   for(i = 0; i < n_anzahl; i++)
      printf("%d; ", feld[i]);
   printf("\n");
}

/*fkt.h*/
#ifndef FKT_H_INCLUDED
#define FKT_H_INCLUDED

#define MAX 10

void function(int feld[], int n_anzahl);

#endif

[Fabian O. (xfr)]

Hier ist es ausführlich erklärt:

http://www.mikrocontroller.net/articles/FAQ#Header_File.2C_wie_geht_das.3F

[Tar (Gast)]

OK funktioniert danke.

[Tar (Gast)]

Ich hatte gedacht, man schreibt nur z.b. (int) in die Deklaration, ohne 
Variablenname.

[Mike M. (mikeii)]

Nein, der Kopf muss genauso aussehen, wie bei der Implementiertung.
Der Compiler will auch prüfen ob die richtige Anzahl an Parametern, bzw. 
der richtige Typ übergeben wird, bevor er die tatsächliche 
Implementierung gefunden hat.

[Karl H. (kbuchegg)]

Mike Mike schrieb:
> Nein, der Kopf muss genauso aussehen, wie bei der Implementiertung.

Ich denke, er meinte die Angabe der Parameternamen.

> Ich hatte gedacht, man schreibt nur z.b. (int) in die Deklaration,
> ohne Variablenname.

Das kannst du natürlich tun. Die Frage ist ob das für dich als 
Programmierer sinnvoll ist.

Angenommen ich gebe dir ein Modul von mir. Also ein C-File und ein 
Header File. Anstatt lange den Code zu studieren schaust du einfach mal 
ins Header File rein, weil du eine Funktion benutzen willst, die dir aus 
einem Bruttopreis und dem Steuersatz den Nettopreis berechnen soll.

Du findest die Funktion

double calcNetto( double, double );

syntaktisch ist das korrekt. Aber: fehlt dir da nicht eine Information? 
Von den beiden double, die du der Funktion übergeben sollst, welcher ist 
denn der Bruttopreis und welcher ist der Steuersatz?

und jetzt vergleich mal mit

double calcNetto( double brutto, double taxPercent );

syntaktisch ist das immer noch die gleiche Information. Der Compiler hat 
alles was er braucht.
Aber was ist mit dir - dem Programmierer? Mit welcher Version kannst du 
auf Anhieb mehr anfangen?

[Mike M. (mikeii)]

Geht das tatsächlich? Ich hatte die Frage schon genau so verstanden.
Mein MinGW meckert das z.B. an, und meines Wissens nach muss Prototyp 
und Implementierung gleich sein.

[Peter II (Gast)]

Mike Mike schrieb:
> Geht das tatsächlich?
ja, man kann sogar verschiende namen hinschreiben

> Ich hatte die Frage schon genau so verstanden.
> Mein MinGW meckert das z.B. an, und meines Wissens nach muss Prototyp
> und Implementierung gleich sein.

dann geht ja kein default parameter, denn dort sind beide auch 
verschieden

int f( a int, b int = 0 );

int f( a int, b int ) {
  return a*b;
}

[Stefan E. (sternst)]

Mike Mike schrieb:
> Mein MinGW meckert das z.B. an,

Beispiel?

> und meines Wissens nach muss Prototyp
> und Implementierung gleich sein.

Nur den Typen nach. Die Namen im Prototyp sind für den Compiler komplett 
irrelevant.

[Mike M. (mikeii)]

/* array10.c */
#include <stdio.h>
#include <stdlib.h>
#define MAX 10
void function(int, int);

void function(int feld[], int n_anzahl) {
   int i;

   for(i = 0; i < n_anzahl; i++)
      printf("%d; ", feld[i]);
   printf("\n");
}


int main(void) {
   int val[MAX];
   int i;

   for(i = 0; i < MAX; i++)
      val[i] = i+1;

   function(val, MAX);

   return 0;
}

Gibt conflicting types for function.....



*ach ich depp....


int[] ....


Dann gehts ja wirklich :P Man lernt immer wieder was

[Tar (Gast)]

Also ich hatte das so in der Art und da kamen etliche Fehler:

void fkt (int);

int main (void {
   int b;
   fkt(b);
}

void fkt (a){
  
}

[Mike M. (mikeii)]

Naja mach mal die Klammer nach void zu

[Garden (Gast)]

Video zu Definition und Deklaration:

http://et-tutorials.de/2198/funktionen-in-c-definition-und-deklaration/

[Mike M. (mikeii)]

Naja mach mal die Klammer nach void zu und schreib bei der Funktion 
unten den Typen dazu

void fkt (int);

int main (void) {
   int b;
   fkt(b);
}

void fkt (int a){

}


Und jetz die Frage an die Profis, muss da der Typ unten dabei Stehen?
Geht ja jetzt auch ohne :P

Hab ich noch nie so gemacht

[Karl H. (kbuchegg)]

Tar schrieb:
> Also ich hatte das so in der Art

'in der Art' ist schlecht.

> und da kamen etliche Fehler:
>
> [c]
>
> void fkt (int);
>
> int main (void {
>    int b;
>    fkt(b);
> }
>
> void fkt (a){

void fkt( int a ) {
          ***

Nur weil du beim Protoyp den Parameternamen weglassen kannst, bedeutet 
das nicht im Umkehrschluss, dass du bei der Funktion den Datentyp 
weglassen kannst :-)

[Karl H. (kbuchegg)]

Mike Mike schrieb:

>
> Und jetz die Frage an die Profis, muss da der Typ unten dabei Stehen?
> Geht ja jetzt auch ohne :P

Welchen 'Typ' meinst du?

> Hab ich noch nie so gemacht

SChau.
Was ist denn der eigentliche Sinn des Funktionsprotoypen.

Der Sinn besteht darin, dass der Compiler überprüfen kann, ob beim 
Aufruf der Funktion

     fkt(b);

die Datentypen passen, ob sie passend gemacht werden können, oder ob das 
gar nicht geht.

Was braucht der Compiler dazu?

> void fkt (int);

Für den Compiler reicht das.
Daraus entnimmt er:
Die Funktion fkt existiert ganz sicher.
Sie übernimmt genau 1 Argument. Und dieses eine Argument ist ein int.
DIe Funktion liefert auch keinen Wert.

D.h. der Compiler ist damit im Bilde, was er bei

   fkt( 2.0 );

zu tun hat, nämlich den double auf einen int runterzucasten. Er weiß 
auch, dass
   fkt( 1, 2 );
illegal ist, weil die Funktion nur 1 Argument nimmt. Ebenso ist

   i = fkt( 2 );

illegal, weil die Funktion nichts liefert.

Damit hat sich die Sache für den Compiler. Für seine Zwecke ist damit 
alles erledigt.
Aber nicht so für den Programmierer. Denn der entnimmt aus dem Namen des 
Arguments noch weitere Information. Funktionsnamen und Variablennamen 
sind Hilfen für den Programmierer - nicht für den Compiler.

[Rufus Τ. F. (rufus)]

Karl Heinz Buchegger schrieb:
> bedeutet
> das nicht im Umkehrschluss, dass du bei der Funktion den Datentyp
> weglassen kannst

Das hat man früher, in Vor-ANSI-C-Zeiten. Das "gute alte" (sprich: 
schreckliche) K&R-C kannte keine Typen in Funktionsdeklarationen:


Statt

int bla(int fusel);

...

int bla(int fusel)
{
...
}

schrieb man da

int bla(fusel);

...

int bla(fusel)
int fusel;
{
...
}

Bei der Deklaration (Prototyp) einer Funktion kennt man also nur die 
Anzahl der Argumente, nicht aber deren Typen. Damit sind Prototypen in 
K&R-C recht ... nutzarm.

[Karl H. (kbuchegg)]

Rufus Τ. Firefly schrieb:


> schrieb man da
> int bla(fusel);
>

Nitpicking

int bla( int );

> Bei der Deklaration (Prototyp) einer Funktion kennt man also nur die
> Anzahl der Argumente, nicht aber deren Typen. Damit sind Prototypen in
> K&R-C recht ... nutzarm.

Und demenstprechend fehleranfällig war das ganze dann auch :-)

[Mike M. (mikeii)]

Um Gottes Willen!

also ich bleib nach wie vor dabei, den Kopf genauso wie bei der 
Implementierung zu schreiben ;)

[Rufus Τ. F. (rufus)]

Karl Heinz Buchegger schrieb:
>> schrieb man da
>> int bla(fusel);
>>
>
> Nitpicking
>
> int bla( int );

Hier haben wir uns beide geirrt:

Tatsächlich schrieb man

int bla();

Ohne Angabe der Argumentanzahl oder -Typen. Ja, K&R-C ist wirklich 
grässlich und gehört deswegen auch gründlich vergessen.