C-Syntax / Compiler

Wenn Du die Sachen in eine Datei schreibst wird dir dass als Anfänger 
viel leichter fallen. Später kann man dann die Sachen in verschiedenen 
Dateien machen
Wenn Du das unbedingt trennen willst in main.c die funktion() als extern 
deklarieren, funktionen.c mit in das Makefile einbinden und anschließend 
die beiden Objektsfiles zusammen linken. oder so ungefähr.

Werner

Gregor wrote:
> Also so?
>
> Main.c:
>
> extern void funktion(void);
> int main (void)
> {
>   funktion();
> }
>
> und
>
> Funktionen.c:
> void funktion (void)
> {
>  ; // tu was
> }
>
> So bekomme ich aber anstelle von Warnings nun jede Menge Errors.

Und die wären?
Obiges ist 100% korrektes C.
In der Praxis macht man das zwar etwas anders (über eigene
Header Files) aber auch das läuft letztendlich genau auf
das was du da geschrieben hast hinaus.

Hier sind deine Fehlermeldungen:

1

../hw_control.c: In function `tempAusgeben':

2

../hw_control.c:109: warning: implicit declaration of function `lcd_gotoxy'

3

../hw_control.c:110: warning: implicit declaration of function `lcd_puts'

4

../hw_control.c: In function `LEDsSetzen':

5

../hw_control.c:162: warning: implicit declaration of function `LEDrt0'

6

../hw_control.c:163: warning: implicit declaration of function `LEDge0'

7

../hw_control.c:164: warning: implicit declaration of function `LEDgn1'

8

../hw_control.c:169: warning: implicit declaration of function `LEDge1'

9

../hw_control.c:170: warning: implicit declaration of function `LEDgn0'

10

../hw_control.c:174: warning: implicit declaration of function `LEDrt1'

11

../hw_control.c: At top level:

12

../hw_control.c:184: error: conflicting types for 'LEDgn1'

13

../hw_control.c:164: error: previous implicit declaration of 'LEDgn1' was here

14

../hw_control.c:189: error: conflicting types for 'LEDgn0'

15

../hw_control.c:170: error: previous implicit declaration of 'LEDgn0' was here

16

../hw_control.c:194: error: conflicting types for 'LEDrt1'

17

../hw_control.c:174: error: previous implicit declaration of 'LEDrt1' was here

18

../hw_control.c:199: error: conflicting types for 'LEDrt0'

19

../hw_control.c:162: error: previous implicit declaration of 'LEDrt0' was here

20

../hw_control.c:204: error: conflicting types for 'LEDge1'

21

../hw_control.c:169: error: previous implicit declaration of 'LEDge1' was here

22

../hw_control.c:209: error: conflicting types for 'LEDge0'

23

../hw_control.c:163: error: previous implicit declaration of 'LEDge0' was here

Jede Zeile beginnt mit
../hw_control.c

Das ist der Dateiname der Source Code Datei, in der der Fehler
aufgetreten ist. Du hast zwar 2 *.c Dateien in dein ZIP File
reingepackt, aber keines von beiden ist hw_control.c

Die ersten beiden Fehlermeldungen lauten:

../hw_control.c: In function `tempAusgeben':
../hw_control.c:109: warning: implicit declaration of function 
`lcd_gotoxy'

Aha. Der Fehler befindet sich also in der Funktion tempAusgeben()
Dort wird eine Funktion lcd_gotoxy() aufgerufen. Nur hat der Compiler
keinen Prototyp für lcd_gotoxy() gesehen. Also sagt er dir das.
Wahrscheinlich hast du einfach vergessen in hw_control() ebenfalls
einen #include "lcd.h" zu machen.

Was viele Neulinge nicht bedenken:
Jedes *.c File wird unabhängig von allen anderen *.c Files
übersetzt. Wenn du in main.c einen #include auf lcd.h machst,
dann ist das zwar nett, ist aber für hw_control.c völlig
uninteressant.
Das Konzept von C sieht vor, dass jedes einzelne *.c File,
dass zu einem Projekt gehört, unabhängig von allen anderen
übersetzt werden kann. Wenn du in einem Projekt 2000 *.c
Files hast und nur an einem eine Änderung machst, dann muss
daher auch nur dieses eine*.c File und nicht alle neu
übersetzt werden.


> Kennt jemand ein Online-Tutorial oder -Kompendium für C ?

Kauf dir ein Buch. Zu empfehlen ist
immer noch der Klassiker 'Kernighan & Ritchie'
Online Tutorials kommen selten über 20 Seiten hinaus und
sind oft fehlerhaft. Ein gutes Buch hat aber mindestens
150 Seiten. Irgendeinen Unterschied muss die unterschiedliche
Seitenzahl ja haben :-)

Hi,

angehängtes pdf finde ich als Einstieg und Ref. für C ganz ok. Hat 45 
Seiten, also mehr als 20 aber deutlich weniger als 150.

Cheers
Detlef

> hw_control.c = funktionen.c

Und das kann ich riechen.

> lcd.h ist von fleury und wird in beiden files inkludiert

Dann schau noch mal in Funktionen.c rein.
Da ist kein include drinn.

>
> ../Main.c: In function `main':
> ../Main.c:55: warning: implicit declaration of function `wait_ms'
> ../Main.c:56: warning: implicit declaration of function `tempAusgeben'
> ../Main.c:57: warning: implicit declaration of function `keysAusgeben'
> ../Main.c:58: warning: implicit declaration of function `humAusgeben'
> ../Main.c:60: warning: implicit declaration of function `LEDsSetzen'
>
> ../hw_control.c: In function `tempAusgeben':
> ../hw_control.c:124: warning: implicit declaration of function
> `lcd_gotoxy'
> ../hw_control.c:125: warning: implicit declaration of function
> `lcd_puts'
>
> Build succeeded with 7 Warnings...

Es geht immer noch um dasselbe.
Du rufst eine Funktion auf, bevor der Compiler einen Prototypen
dafür gesehen hat.

C ist ein One-Pass Compiler.
D.h. der Compiler geht den Source Code von oben nach unten durch.
Ein einziges mal. Nicht öfter!
Wenn du eine Funktion aufrufst, dann muss ein Prototyp vor
dem Aufruf der Funktion vorkommen. Dahinter reicht nicht.
Ebensowenig reicht es, wenn die aufgerufene Funktion im
selben Source Code File vorkommt, wie der Aufruf:

int main()
{
  foo();
}

void foo()
{
}

Der Compiler geht von oben nach unten durch. Wenn der Aufruf
von foo() angetroffen wird, wurde nach kein Protoyp für foo()
gesehen.
* Entweder man setzt einen Prototypen an den Anfang

  void foo( void );

  int main()
  {
    foo();
  }

  void foo()
  {
  }

* oder man zieht die Funktion vor die Stelle des Aufrufs

  void foo()
  {
  }

  int main()
  {
    foo();
  }

Beide Fälle laufen auf das gleiche hinaus: Bevor der Aufruf
der Funktion foo() angetroffen wird, wurde der Compiler schon
mit der Funktion foo() vertraut gemacht: Es gibt sie (könnte
ja auch ein Schreibfehler sein), sie hat keine Argumente und
sie liefert auch keinen Returnwert. Das reicht; mehr muss der
Compiler nicht wissen um überprüfen zu können, ob der Funktions-
aufruf auch wirklich rechtens ist.

PS: Das 'extern' bei Funktionsprotoypen kannst du dir sparen.

> Es muss zwei mal deklariert werden. Im
> Main.c:
> extern void funktion(void);
> int main (void)
> {
>   funktion();
> }
>
> und
>
> Funktionen.c:
> <b>void funktion (void);</b>
> void funktion (void)
> {
>   ; // tu was
> }

Nachdem du jetzt eingesehen hast, warum das so sein muss:

Genau so macht man es dann in der Praxis nicht.
In der Praxis macht man:

Man macht eine Datei Funktionen.h

Funktionen.h
************

void funktion(void);


und includiert die dann
* auf jeden Fall in Funktionen.c
 in allen anderen .c, die eine Funktion aus Funktionen.c
  aufrufen möchten

Funktionen.c
************
#include ....
#include ....
#include "Funktionen.h"

void funktion()
{
  hier ist die Implementierung
}


Main.c
******
#include ...
#include ...
#include "Funktionen.h"     // ich möchte was aus Funktionen.c
                            // benutzen

int main()
{
  funktion();
}