Hallo,
Ich versuche mir C als Programmiersprache beizubringen. Grundkenntnisse habe ich mir bereits erworben, jetzt stehe ich vor dem Problem, dass eine c File zu gross und unübersichtlich wird. Darum möchte ich das Programm in mehrere Dateien aufteilen.
Welche Regeln muss ich beim einbinden anderer Files beachten? Was hat es mit den Header Files auf sich? Wie muss ein komplexes c Projekt aussehen, wenn es regelkonform aufgebaut ist?
Danke!
Hallo,
sorry, ich programmiere nicht in C, kann Dir nicht weiterhelfen.
Gruß
Hermann
Hallo Scheunenfund123,
da möchte ich dich gleich auf ein paar Webseiten verweisen, da es dort schon schön beschrieben steht:
Da gibt es einmal das C-HowTo, welches ein Online-Tutorial ist (ein Buch gibt es auch, es geht aber auf jeder Fall ohne) und unter http://www.c-howto.de/tutorial-praeprozessor-dateien… findest du direkt etwas zu Header-Dateien.
Sehr zu empfehlen sind auch die Skripte der FH München. Zu finden unter http://netzmafia.de/skripten/index.html
Im Grunde sind alle Skripte auf der Seite wichtig und es wird auch immer wieder C verwendet. Speziell zum Lernen von C gibt es den Kurs „Programmieren in C“ (http://netzmafia.de/skripten/programmieren/index.html). Darin enthalten ist auch ein Kapitel „Programmierstil, Fallstricke, Module“ (http://netzmafia.de/skripten/programmieren/ad13.html…), in dem es auch darum geht, wie man Projekte aufteilt.
Insgesamt lässt sich sagen, dass es sehr viel zur Programmierung in C gibt. Wichtig ist aber insbesondere, dass man selber viel programmiert und auch von anderen erfahrenden Programmieren Code liest. Dafür würde ich dir empfehlen einfach mal auf GitHub zu schauen. Dort gibt es für C eine eigene Rubrik (https://github.com/languages/C).
Mich würde noch interessieren, warum du dich für C entschieden hast. Ist das deine erste Programmiersprachen oder hast du bereits anderweitig Programmiererfahrungen?
Ich wünsche dir auf jeden Fall viel Erfolg und Spaß! Falls noch Fragen auftauchen, einfach wieder melden.
Viele Grüße
Benjamin
Hallo Benjamin,
Danke für deine Antwort. Die Wahl auf c fiel aus Hobby. Mir macht es Spaß, Mikrocontroller die verschiedensten Sachen tun zu lassen. Ich habe mir deshalb Assembler beigebracht, und bin auch recht fit darin.
Aber der Nachteil von Assembler liegt auf der Hand - komplexe und verschachtelte Programme sind fast nicht machbar.
Deswegen versuche ich nun mit c zurecht zu kommen. Ich merke aber, dass c viele Eigenheiten in der Syntax hat mit denen ich erst mal klar kommen muss.
Im Endeffekt möchte ich mich in der Welt der Mikrocontroller zurecht finden. Hardwarenah programmieren, jedoch keine Programme schreiben.
Danke für die links, ich werde mir die durchlesen.
Gruß Markus
Hallo
Header Dateien: Hier gehört alles rein, was andere „Module“ von einer Klasse wissen müssen. D.h. die Deklaration der Schnittstelle.
Aufteilen: Was zusammen gehört, sollte auch zusammen in einem File bleiben. Wenn du aber (z.B. durch ein Refactoring) sinnvolle (z.B. wiederverwendbare) Elemente aus einer Klasse herauslösen kannst, dann ist natürlich ein eigenes File angebracht.
Gruss,
– christoph
Hallo,
wenn du mehrere C Dateien hast werden die im ersten Schritt voneinander unabhängig Kompiliert. Und erst beim Linken zusammen gefügt. Das hat zur Folge dass du alles was du später verwenden willst vorher deklarieren musst. Die header Dateien sind dabei das Mittel zum Zweck.
Noch die Langform:
Was du vermutlich schon weist ist dass jede Funktion, oder Variable vor der Verwendung deklariert werden muss. Die im Fall von mehreren Dateien jedes .c File einzeln Übersetzt müssen die jeweils nötigen Deklaration in jedem File vorkommen. Es wehre jedoch nicht zweckmäßig die Deklarationen in jedes .c File zu kopieren. Da dies im Falle einer Änderung zu hohem Aufwand führt. Dafür schafft das #include Statement Abhilfe. Es wird durch den Preprozessor vor dem Kompilieren durch den Inhalt der angegebenen Datei ersetzt. Nur kann man ein zu jedem .c File ein .h File erstellen dass die Deklarationen zu den implementierten Funktionen enthält.
Bsp.:
test.h:------------------------
void halloWorld();
test.c;------------------------
#include
#include „test.h“
void halloWorld()
{
printf(„Hallo World“);
}
main.c:------------------------
#include „test.h“
void main(int argc, char **argv)
{
halloWorld();
}
Ich habe hier im test.c auch test.h inkludiert. Für dieses einfache Beispiel wehre das nicht Notwendig. Wenn aber test.c mehre Funktionen Implementiert die die gegenseitig brauchen ist schnell man notwendig.
Das selbe was ich hier mit der Funktion halloWorld gemacht habe geht auch mit globalen variablen. Dabei wird das Keyword „extern“ verwendet.
Ein weiteres Problem kann das mehrfach inkludieren sein dabei sei auf http://en.wikipedia.org/wiki/Include_guard verwiesen.
Schneller wäre es wahrscheinlich gegangen, wenn du selbst mal die Internetsuche versucht hättest.
Möglicherweise hilft das hier weiter:
http://de.wikibooks.org/wiki/C-Programmierung:_Eigen…
http://www.onlinetutorials.de/programmierung/c/
Bitte suche dir Informationen bzw. Tutorials zum Thema Softwareentwicklung in C mit Make (klassische Methode) oder Eclipse (moderne Methode). Damit lernst du, wie C-Programme strukturiert werden und wie der Entwicklungsprozess abläuft.
lade dir mal „codeblocks“ herunter… da hast du eine gute entwicklungsumgebung, mit der das einbinden von files ganz leicht ist.
die header-files werden oft auch „interface-files“ genannt : dort stehen für alle sichtbar die deklarationen
der funktionen und prozeduren - zu kontroll-zwecken.
wenn du so ganz am anfang stehst, rate ich dir dringend, erst mal mit ganz kleinen projekten anzufangen. es sei denn, du bist eine art einstein.
viel spass und erfolg - drs
Hallo Scheunenfund123,
urlaubsbedingt ein wenig verspätet. Wahrscheinlich
hast Du schon Antworten.
Prinzipiell hat man in diesem Bereich große Freiheiten
und kann sich da ein eigenes System zurechtlegen.
Oberste Prämisse ist, dass man selbst oder eventuell auch jemand anderes anhand der Namen schnell zu der Stelle findet, an der er etwas ändern oder einen Fehler beheben muss.
Gibt Dein Programm z.B. Sachen auf den Bildschirm aus
und auf den Drucker macht eine Einteilung in ein
C-File drucken.c mit den Funktione DruckeZeile(), DruckeSeite() usw, und eines mit dem Namen screen.c
mit den Funktionen ZeichneAusgabe() usw.
Funktionen die allgemein verwendet werden,
können z.b. in einem utils.c ausgelagert werden.
In ein Headerfile gehören die Deklarationen
also z.B. int Name(int a, int b);
In ein C.file die Definitionen:
also z.B.
int Name(int a, int b) {
int c;
c = a + b;
return©;
}
Im C-File bindet man das H-File zu oberst mit
ein. #include „drucken.h“
plus eventuell weitere h-Files für Funktionen
aus den C-Libraries z.b.
#include /* usw. */
WICHTIG: In Deiner Projektdatei musst Du noch
die C-Files Deiner ausgelagerten Sachen angeben.
Ich hoffe, das hilft Dir zunächst mal weiter.
Teste mal das Procedere an einer einzelnen Funktion
zuerst und erweitere dann den Inhalt des neuen
C-Files.
Viel Erfolg und viele Grüße
Peter
Hi Scheunenfund123,
grundsätzlich versucht man funktional zusammengehörige Einheiten zu bilden, also Fuktionen, die einem Themengebiet zugeordnet werden können, werden in eine Datei gepackt.
Für jede .c-Datei erstellt man eine .h Datei. Die .h-Datei wird von den Dateien, die die Funktionen der .c-Datei nutzen wollen eingebunden.
In der .h-Datei verhindert man multiple Einbindungen(redefinition-problem) durch Präprozessordirektiven wie die folgenden:
#ifndef _H
#define _H
//your code here
#endif // _H
VG
linuxxer
Etwas spät eine Antwort…
Man begin mit einer main.c.
Dort bindet man per #include „modul.h“
etwas ein.
Dann bringt man in modul.c etwa
int function_tuwas(int foo)
{
//tu was
}
und in modul.h
kommt
int function_tuwas(int);
So in etwa geht das prinzipiell.
Da gibt es aber natürlich noch viel mehr:
-platformabstraktion
-attribute und spezifizierer
-speicherklassen
-globale Variablen
-coding styles
-#define 's
-inklusionskontrolle
usw.
Es empfiehlt sich sehr, fremde Quelltexte
(etwa open source projekte) ausführlich
zu studieren.