Einstieg in C – Für Programmiereinsteiger geeignet

Wissen, wie’s geht.
Leseprobe
Mit diesem Buch gelingt Ihnen der Einstieg in C. In dieser Leseprobe
macht Sie Thomas Theis mit den Grundlagen vertraut und entwickelt
mit Ihnen ein erstes Programm. Außerdem können Sie einen Blick in
das vollständige Inhalts- und Stichwortverzeichnis des Buches werfen.
»Eine erste Einführung«
»Unser erstes Programm«
»Verschiedene Arten von Daten«
»Verschiedene Fälle in einem Programm«
Inhalt
Index
Der Autor
Leseprobe weiterempfehlen
Thomas Theis
Einstieg in C
447 Seiten, broschiert, mit CD, Juni 2014
24,90 Euro, ISBN 978-3-8362-2793-3
www.galileo-press.de/3557
Kapitel 1
Eine erste Einführung
Was erreichen Sie mit der Programmierung in C? Was benötigen Sie,
um anzufangen? Wie nutzen Sie dieses Buch möglichst gut?
Die Programmiersprache C gibt es schon seit Anfang der 1970er Jahre.
Dennoch ist diese Sprache nach wie vor aktuell, schnell und universell einsetzbar. Ihr Einsatzgebiet erweitert sich ständig und erstreckt sich vom
normalen Anwender-PC über das eingebettete System innerhalb eines
technischen Geräts bis hin zum vernetzten Rechnerverbund.
Universell
1.1 Welche Vorteile bietet C?
Die Sprache C besitzt einen breiten Anwendungsbereich und erfreut sich
großer Bekanntheit und Popularität. C-Programme sind zwischen den verschiedenen Rechnersystemen leicht portierbar. Sie benötigen weder eine
spezielle Laufzeitumgebung noch einen Interpreter.
Portierbar
Sie können mit C schnelle, ressourcensparende Programme erstellen. Dies
ist unter anderem dem direkten Zugriff auf den Speicherplatz und die
Hardware zu verdanken.
Schnell
C ist weitverbreitet und bindet Sie nicht an einen bestimmten Hersteller.
Der C-Compiler aus der GNU Compiler Collection (kurz: GCC C-Compiler)
steht für viele Betriebssysteme zur Verfügung und stellt das zentrale Element vieler Entwicklungsumgebungen dar. Einige davon werden auch in
diesem Buch eingesetzt.
GCC
Durch seinen einfachen Aufbau und seine geringe Anzahl an Schlüsselwörtern ist C leicht erlernbar. Seine Effizienz hat C zur Basis vieler bekannter
Sprachen gemacht.
Einfach
Sowohl zur Programmierung von Anwendungen für den Endbenutzer als
auch zur Systemprogrammierung für Bestandteile und Erweiterungen von
Betriebssystemen findet C seinen Einsatz.
15
1
1.2 Was benötige ich zum Programmieren?
Als angehender Entwickler von C-Programmen benötigen Sie:
왘 einen Editor, mit dessen Hilfe Sie den Programmcode schreiben
왘 einen Compiler, mit dessen Hilfe Sie den Programmcode in die Sprache
übersetzen, die der jeweilige Rechner versteht
IDE
GCC
Dev-C++
Darüber hinaus ist es sinnvoll, einen Debugger zu benutzen, der Ihnen bei
der Fehlersuche hilft. Die meisten Editoren bieten zur Erleichterung der
Programmierung ein sogenanntes Syntax-Highlighting, also ein farbliches
Hervorheben der Elemente von C. Sowohl unter Windows als auch unter
Ubuntu Linux und unter OS X gibt es eine Reihe von IDEs (kurz für: Integrated Development Environment, zu Deutsch: Integrierte Entwicklungsumgebung), die all dies und vieles mehr bieten.
Zusätzlich können Sie unter vielen Betriebssystemen mit dem GCC C-Compiler auf Kommandozeilenebene arbeiten. Dies vereinfacht teilweise die
Nutzung externer Bibliotheken, die Ihnen weitere Funktionen bieten.
Im Buch arbeiten wir primär unter Windows 7 in der 32-Bit-Version mit der
frei verfügbaren Entwicklungsumgebung Dev-C++ 5.4.0. Ich werde Ihnen
aber immer wieder Hinweise geben, wie es unter anderen Betriebssystemen und in anderen Entwicklungsumgebungen läuft.
In Anhang B werde ich alle notwendigen Installationen für Windows,
Ubuntu Linux und OS X beschreiben.
1.3 Wie ist dieses Buch aufgebaut?
In Kapitel 2 werde ich Ihnen anhand des klassischen Hallo-Welt-Programms
die Bedienung der Entwicklungsumgebung Dev-C++ 5.4.0 erläutern.
Grundkurs
In Kapitel 3 bis 11 lernen Sie anhand eines anschaulichen Beispiels aus dem
Alltag die wichtigen Elemente der Programmierung mit C kennen: Variablen, Operatoren, Kontrollstrukturen, Funktionen, Felder, Zeichenketten,
Zeiger, Strukturen und Dateispeicherung.
Dies geschieht Schritt für Schritt, mit ausführlicher Erläuterung der
Begriffe. Dabei werden wir die Programme Stück für Stück durch das neu
erworbene Wissen erweitern. Allerdings werden wir uns dabei nicht in
sämtlichen Details der Programmierung verzetteln.
16
1.4
Eine erste Einführung
Wie sollten Sie mit diesem Buch arbeiten?
Anschließend sind wir in der Lage, die wichtigen Begriffe richtig einzuordnen. Kapitel 12 wird die Kenntnis der Programmierelemente vertiefen. Wir schauen auch einmal links und rechts: Welche Möglichkeiten
bieten diese Elemente noch? Auf welche Weise können sie miteinander
verbunden werden?
Vertiefung
Kapitel 13 bis 18 erläutern zahlreiche nützliche Funktionen, nach Themengebieten geordnet: dynamische Felder, Zahlen und Mathematik, Präprozessor, Dateien und Verzeichnisse, Datum und Zeit sowie die Kommunikation mit dem Betriebssystem.
In Kapitel 19, 21 und 22 werde ich Ihnen die Vielfalt der Programmierung
mit C anhand von drei Beispielen zeigen. Sie lernen:
Datenbanken, GUIs,
Hardware
왘 wie Sie auf SQLite-Datenbanken zugreifen
왘 wie Sie grafische Benutzeroberflächen mit Hilfe von GTK+ erstellen
왘 wie Sie elektronische Schaltungen mit Hilfe des Einkartencomputers
Raspberry Pi programmieren
Kapitel 20 bietet einige größere Beispielprojekte. Mehrere Spiele und
andere Programme dienen zur Verbindung vieler Elemente der bisherigen
Kapitel, jeweils in einem umfangreichen Programm.
In Anhang A werde ich einige der Änderungen ansprechen, die C in den Jahren seit seinem ersten Einsatz erfahren hat. Die weiteren Anhänge bieten
schließlich die notwendigen Installationsanleitungen, wichtige Befehle
unter Unix, die Schlüsselwörter der Sprache C, eine Funktionsreferenz und
die Lösungen der Übungsaufgaben.
Für die Hilfe bei der Erstellung dieses Buchs bedanke ich mich bei Anne
Scheibe, Petra Biedermann, Jan Hohlmann und dem ganzen Team von
Galileo Press.
1.4 Wie sollten Sie mit diesem Buch arbeiten?
Lernen Sie Schritt für Schritt die einzelnen Programmierelemente, ihre
Besonderheiten und ihre Vorteile kennen. Die Beispielprogramme und die
Erläuterungen helfen Ihnen dabei.
Beispiele
Verändern Sie die Programme, und prüfen Sie, ob die Ergebnisse so sind,
wie Sie sie erwartet haben. Lösen Sie die Übungsaufgaben, aber erstellen Sie
Programmieren
17
1
Eine erste Einführung
auch Programme nach eigenen Aufgabenstellungen, die die neu erlernten
Programmierelemente enthalten.
Fehler
Das Buch gibt Ihnen Hinweise auf viele typische Einsteigerfehler. Sollten
Sie gerade überlegen, warum Ihr Programm nicht das ausführt, was Sie
erwarten, dann prüfen Sie es einmal dahingehend.
Die Compiler und die verschiedenen Entwicklungsumgebungen setzen
den C-Standard nicht einheitlich um und lassen daher manchmal unterschiedliche Schreibweisen zu. In den Beispielprogrammen des Buchs
verwende ich jeweils die Schreibweise, die unter möglichst vielen Umgebungen lauffähig ist.
Datenträger
zum Buch
E-Book-Ausgabe
Auf dem beigelegten Datenträger finden Sie die Software, die wir im
Laufe des Buches benötigen. Außerdem habe ich dort unter Programme
alle Beispielprogramme des Buches fertig beigefügt. Der Dateiname steht
jeweils in der Listing-Unterschrift; den Code aus Listing 2.1 finden Sie also
beispielsweise unter <Datenträger> Programme\hallo.c..
Leser der E-Book-Ausgabe finden die Beispielprogramme in den Materialien zum Buch unter:
http://www.galileo-press.de/3557
Kapitel 2
Unser erstes Programm
Anhand des ersten Programms lernen Sie die Entwicklungsumgebung
Dev-C++ und die Grundbegriffe eines C-Programms kennen.
Bei unserem ersten Programm handelt es sich um einen Klassiker, mit dem
viele Entwickler in vielen Programmiersprachen starten. Auf dem Bildschirm wird einfach nur folgender Text ausgegeben:
Hallo Welt
Hallo Welt
Sehen Sie als Entwickler diese Ausgabe vor sich, dann wissen Sie, dass Sie
den ersten wichtigen Schritt bewältigt haben.
2.1 Wie gebe ich das Programm ein?
Starten Sie die Entwicklungsumgebung Dev-C++. Die Installation dieser
Software beschreibe ich in Abschnitt B.1.1, »Dev-C++«. Sie bietet unter anderem einen Editor, in dem Sie den Code Ihrer Programme eingeben können.
In Dev-C++ wählen Sie den Menüpunkt Datei 폷 Neu 폷 Quelldatei. Dies
geht auch einfacher mit Hilfe der Tastenkombination (Strg)+(N). Im rechten Teil erscheint ein neues Fenster, das zunächst den Titel Unbenannt1
hat. Geben Sie darin den Code des folgenden Listings ein (siehe auch Abbildung 2.1):
Neue Datei
#include <stdio.h>
int main()
{
printf("Hallo Welt\n");
return 0;
}
Listing 2.1 Datei »hallo.c«
18
19
2
2.2
Unser erstes Programm
Das Programm wird gespeichert
Sonderzeichen
Die vielen Sonderzeichen stellen eine erste Hürde dar. Die geschweiften
Klammern { und } sowie das Backslash-Zeichen \ können Sie mit Hilfe
der Tastenkombinationen (Alt_Gr)+({), (Alt_Gr)+(}) und (Alt_Gr)+(\)
eingeben.
Sonderzeichen \n bewirkt einen anschließenden Zeilenumbruch. Das Steuerzeichen n steht für new line. Jede Anweisung muss mit einem Semikolon
beendet werden.
Klammern,
Einrückungen
Nach der Eingabe einer geöffneten Klammer erscheint in Dev-C++ von
selbst die passende schließende Klammer. Falls es sich um eine geschweifte Klammer handelt, dann wird die nächste Zeile automatisch
eingerückt. Nach einer kurzen Eingewöhnung werden Sie feststellen,
dass sich dieses selbständige Verhalten des Editors als hilfreich erweist
und Sie bei der Erstellung von gut lesbaren Programmen unterstützt.
Diese Unterstützung erhalten Sie auch in vielen anderen Entwicklungsumgebungen.
Bedeutung wird aber im weiteren Verlauf des Buchs klarer. Sie dienen dazu,
Die restlichen Zeilen sehen momentan noch etwas abstrakt aus. Ihre
rund um die Anweisung printf(...); ein vollständiges C-Programm zu
erstellen, das übersetzt und ausgeführt werden kann.
Die Anweisung return 0; liefert die Zahl 0 zurück. Für uns bedeutet das
zunächst vereinfacht, dass kein Fehler aufgetreten ist.
Beide genannten Anweisungen stehen innerhalb der Funktion main().
Jedes C-Programm besteht aus einer oder mehreren Funktionen, die unterschiedliche Namen haben und miteinander arbeiten. Die Funktion main()
bildet stets den Startpunkt eines Programms. Nach dem Namen einer
Funktion folgen stets runde Klammern. Alle Anweisungen einer Funktion
müssen innerhalb eines Blocks stehen, erkennbar an den geschweiften
Klammern.
main()
Die Angabe int besagt, dass die Funktion main() eine ganze Zahl (englisch:
integer) zurückliefert, in diesem Falle 0.
Die Anweisung #include zu Beginn des Programms dient dazu, Funktionen
#include
aus bestimmten Bibliotheken für das Programm verfügbar zu machen.
Über die sogenannte Header-Datei stdio.h erreichen Sie eine Bibliothek mit
Standardfunktionen zur Ein- und Ausgabe. Die Abkürzung stdio steht dabei
case sensitivity
Abbildung 2.1 Erste Eingabe
für standard input output.
In C wird nach Klein- und Großbuchstaben unterschieden. Dieses Verhalten wird auch case sensitivity genannt. Sie sollten also zum Beispiel printf
nicht mit einem großen P schreiben. Dies wird in der Regel zu einem Fehler
führen.
Über stdio.h wird unter anderem die Funktion printf() erreichbar gemacht. Ohne diese Header-Datei wären C-Programme nicht in der Lage, etwas auf dem Bildschirm auszugeben oder Angaben des Benutzers von der
Tastatur einzulesen. Im weiteren Verlauf des Buchs werden wir noch Funktionen aus anderen Bibliotheken benötigen.
stdio.h
Was bedeuten die einzelnen Zeilen?
Bei der Erläuterung der Programmzeilen arbeiten wir uns, ein wenig ungewöhnlich, von innen nach außen vor.
printf()
20
In der Mitte des Programms finden Sie die Anweisung printf("Hallo
Welt\n");. Sie dient zur Ausgabe des gewünschten Texts auf dem Bildschirm. Der Text wird in doppelte Anführungsstriche eingeschlossen. Das
2.2 Das Programm wird gespeichert
Nach der Eingabe speichern Sie das Programm über den Menüpunkt Datei
폷 Speichern oder mit der Tastenkombination (Strg)+(S). Es erscheint das
Dialogfeld Datei speichern.
21
2
2.3
Unser erstes Programm
Dateiendung ».c«
Sie können mit Hilfe von Dev-C++ sowohl in der Sprache C als auch in der
Sprache C++ programmieren. Dateien mit Programmen in der Sprache C
haben die Endung .c. Falls es sich um Programme in der Sprache C++ handelt, dann haben die Dateien die Endung .cpp. In diesem Buch programmieren wir in C, und unser Programm gibt ein »Hallo Welt« aus, also geben Sie
im Feld Dateiname zum Beispiel den Namen »hallo.c« ein (siehe auch
Abbildung 2.2).
Wie starte ich das fertige Programm?
2.3 Wie starte ich das fertige Programm?
Ich gehe davon aus, dass Sie die Datei gespeichert und aktuell geöffnet
haben. Sie können das Programm über den Menüpunkt Ausführen 폷
Kompilieren oder die Funktionstaste (F9) in die Sprache des Rechners
übersetzen. Dies wird auch kompilieren genannt. Der entsprechende
Bestandteil der Entwicklungsumgebung nennt sich Compiler.
Übersetzen
Beim Kompilieren können Syntaxfehler festgestellt werden. Unter der
Syntax
Syntax eines Programms versteht man seinen Aufbau gemäß den Regeln
der Programmiersprache. Falls das Programm keinen Syntaxfehler enthält,
erscheint ein Dialogfeld wie in Abbildung 2.3.
Abbildung 2.2 Dateiname eingeben
C:\CProgramme
Wählen Sie ein Verzeichnis aus. Ich habe das Verzeichnis C:\CProgramme
ausgewählt und beziehe mich auch in späteren Anleitungen darauf. Zum
Abspeichern im richtigen Verzeichnis haben Sie nun mehrere Möglichkeiten:
왘 Verwenden Sie ein vorhandenes Verzeichnis.
왘 Erzeugen Sie beim Abspeichern im Dialogfeld Datei speichern ein
neues Verzeichnis: Nach Betätigung der rechten Maustaste erscheint
das bekannte Kontextmenü des Windows-Explorers mit dem Menüpunkt Neu 폷 Ordner.
Im Dialogfeld Datei speichern klicken Sie den Button Speichern.
Einige nützliche Hinweise
Schließen
왘 Sie können die Datei schließen, und zwar über den Menüpunkt DATEI 폷
SCHLIEßEN oder mit der Tastenkombination (Strg)+(W).
Öffnen
Sollte das Programm Syntaxfehler aufweisen, erscheinen eine oder meh-
Fehlermeldung
rere Fehlermeldungen. Zur Demonstration (siehe Abbildung 2.4) habe ich
einmal das Semikolon am Ende der ersten Anweisung weggelassen. Die
Fehlermeldung besagt, dass in Zeile 6 ein Semikolon vor return erwartet
wird. Der Fehler, der in Zeile 5 gemacht wurde, wird also erst in Zeile 6
bemerkt. Nach Beseitigung des Fehlers muss das Programm erneut übersetzt werden.
왘 Sie können eine vorhandene Datei erneut öffnen: über den Menüpunkt
DATEI 폷 PROJEKT ODER DATEI ÖFFNEN, oder mit der Tastenkombination
(Strg)+(O).
왘 Sie können an mehreren Programmen parallel arbeiten, falls Sie zum
Beispiel einzelne Elemente eines Programms in ein anderes Programm
übernehmen möchten. Jedes Programm erscheint rechts in einem eigenen Fenster.
22
Abbildung 2.3 Erfolgreiche Übersetzung
Hinweis
Es ist häufig so, dass sich Fehler erst in späteren Programmzeilen auswirken. Falls Sie also nach der Ursache eines Fehlers suchen, dann beginnen
Sie in der Zeile mit der Fehlermeldung und arbeiten sich anschließend
Zeile für Zeile nach oben.
Suchen nach oben
23
2
2.4
Unser erstes Programm
Eine weitere Möglichkeit zum Starten
2.4 Eine weitere Möglichkeit zum Starten
Diesen Abschnitt können Sie zunächst übergehen und später bei Bedarf
lesen. Aber vielleicht würden Sie gerne einmal Folgendes ausprobieren:
왘 Ihr Programm direkt von der Kommandozeile aus aufrufen.
왘 Ihr Programm auf einem anderen Windows-PC nutzen.
Abbildung 2.4 Übersetzung mit Fehlermeldung
Ausführen
Nach einer erfolgreichen Übersetzung können Sie das Programm über den
Menüpunkt Ausführen 폷 Ausführen oder die Funktionstaste (F10) starten. Es erscheint ein Konsolenfenster mit der Ausgabe des Programms,
siehe Abbildung 2.5. Nach einem Tastendruck wird das Konsolenfenster
wieder geschlossen.
Sie haben mit Hilfe der Entwicklungsumgebung Dev-C++ aus dem C-Programm in der Datei hallo.c bereits ein ausführbares Programm in der Datei
hallo.exe erstellt. Es befindet sich im selben Verzeichnis wie die Datei
hallo.c, also in C:\CProgramme. Im Kommandozeilenmodus können Sie es
direkt aus diesem Verzeichnis heraus aufrufen.
Ausführbare Datei
Sie erreichen den Kommandozeilenmodus unter Windows 7 sowohl über
das Startmenü 폷 Alle Programme 폷 Zubehör 폷 Eingabeaufforderung
als auch über die Tastenkombination (œ)+(R) und die anschließende Eingabe des Befehls cmd. Unter Windows 8 gibt es die letztere Möglichkeit
ebenso.
Kommandozeile
Wechseln Sie im Kommandozeilenmodus in das Verzeichnis C:\CProgramme, und zwar wie in Abbildung 2.6 mit dem Befehl cd C:\CProgramme.
Lassen Sie sich mit dem Befehl dir alle Dateien im Verzeichnis anzeigen.
Starten Sie das ausführbare Programm in der Datei hallo.exe – dazu dient
der Befehl hallo. Es erscheint die Ausgabe des Programms: Hallo Welt.
Ausführen
Abbildung 2.5 Ausgabe des Programms
F11
Nach einer Änderung können Sie Ihr Programm auch auf einen Schlag speichern, übersetzen und ausführen. Dies geschieht mit Hilfe des Menüpunkts Ausführen 폷 Kompilieren + Ausführen oder der Funktionstaste
(F11). Diese Abkürzung erweist sich in der Praxis als sehr hilfreich.
Hinweis
Größere Programme bestehen häufig aus mehreren Dateien und werden
in Dev-C++ in einem zusammenhängenden Projekt gespeichert. Dazu finden Sie eine Erläuterung in Abschnitt B.1.1, »Dev-C++«.
24
Abbildung 2.6 Eingabeaufforderung, mit Programmaufruf
25
2
Programm kopieren
Codeseite
Sie können die Datei hallo.exe einfach auf einen anderen Windows-PC
kopieren, etwa mit Hilfe eines USB-Sticks. Anschließend können Sie das
Programm auf dem anderen Windows-PC starten.
Standardmäßig ist unter Windows die Codeseite 850 eingestellt. Falls Sie
die deutschen Umlaute und das scharfe S (ß) ausgeben möchten, sollten Sie
im Kommandozeilenfenster mit Hilfe des Befehls chcp 1252 auf die Codeseite 1.252 umstellen.
2.5 Kommentare sind wichtig
Gute Entwickler kommentieren den Code ihrer Programme. Auf diese
Weise erläutern sie den Zweck und den Aufbau wichtiger Bestandteile des
Programms für sich selbst und für andere Entwickler.
Weitere
Entwicklung
Häufig nimmt sich ein Entwickler ein Programm nach Wochen oder Monaten noch einmal vor, um es zu verbessern oder ein anderes Programm auf
seiner Basis zu erschaffen. Oder er muss ein Programm bearbeiten, das
ursprünglich von einem anderen Entwickler erstellt wurde. In diesen Fällen ist es sehr hilfreich, wenn die Programme gut kommentiert sind.
/* Kommentar */
Kommentare werden nicht übersetzt und sind nur in der Datei mit dem
C-Quellcode sichtbar. Sie stehen zwischen den Zeichenfolgen /* und */ und
können sich über mehrere Zeilen erstrecken.
// Kommentar
Viele Entwicklungsumgebungen (so auch Dev-C++ 5.4.0) setzen bereits
einige, aber nicht alle Vorgaben des Sprachstandards C99 um. Somit sind
normalerweise auch einzeilige Kommentare möglich. Sie beginnen nach
der Zeichenfolge // und erstrecken sich bis zum Ende der Zeile. Weitere
Informationen zum C99-Standard finden Sie in Anhang A, Ȁnderungen
der Programmierung mit C«.
Ein Beispiel:
#include <stdio.h>
int main()
{
/* Es gibt lange Kommentare.
Diese stehen in mehreren Zeilen */
printf("Es gibt auch lange"
" Texte.\nDiese stehen"
26
2.6
Unser erstes Programm
Eine Übungsaufgabe
" auch in mehreren Zeilen.\n");
return 0; // Kommentar bis zum Ende der Zeile, seit C99
}
Listing 2.2 Datei »kommentar.c«
Zu Beginn der Funktion main() steht ein Kommentar über zwei Zeilen.
Nach der Anweisung mit return steht ein einzeiliger Kommentar.
Gleichzeitig sehen Sie in diesem Programm, wie Sie einen längeren Ausgabetext unterteilen können. Die einzelnen Textstücke stehen jeweils innerhalb von doppelten Anführungsstrichen. Die Zeichenfolge \n sorgt für
einen Zeilenumbruch. Die Ausgabe sieht wie folgt aus:
Langer Text
Es gibt auch lange Texte.
Diese stehen auch in mehreren Zeilen.
Hinweis
Kommentare geben Ihnen auch die Möglichkeit, bestimmte Teile eines
Programms zeitweilig von der Übersetzung auszuschließen. Dies kann
sich während der Entwicklung eines größeren Programms oder bei der
Fehlersuche als nützlich erweisen.
2.6 Eine Übungsaufgabe
Schreiben Sie ein Programm in der Datei u_name.c. Es soll die folgende
Ausgabe erzeugen:
Guten Morgen.
Mein Name ist Claus Clever.
Kommentieren Sie jede Zeile innerhalb der Funktion main(). Eine mögliche Lösung zu der Übungsaufgabe finden Sie in Abschnitt D.1, »Datei
›u_name.c‹«. Denken Sie daran: Es kann zu jeder Aufgabe beliebig viele
richtige Lösungen geben. Falls Ihre Lösung von meiner Lösung abweicht,
dann überlegen Sie, welche Lösung für Sie verständlicher ist.
27
Kapitel 3
Verschiedene Arten von Daten
Sie speichern Zahlenwerte, geben Sie auf dem Bildschirm aus, lesen Sie von
Tastatur ein und rechnen mit ihnen. Außerdem lernen Sie, wie Sie Fehler
leichter finden können.
Innerhalb eines Programms müssen unterschiedliche Daten ermittelt,
gespeichert, weiterverarbeitet und ausgegeben werden. Dies können Zahlen, aber auch Texte sein.
In vielen Beispielen dieses Buchs wird mit den Daten eines alltäglichen,
leicht verständlichen Anwendungsbeispiels gearbeitet: Wir tätigen einen
Einkauf in einem Geschäft. Schritt für Schritt lernen Sie weitere Programmierelemente kennen, die Ihnen die Möglichkeit geben, diesen Einkauf
und die Erstellung der zugehörigen Rechnung immer realistischer zu
gestalten.
Ein Einkauf
Sie erlernen zunächst die verschiedenen Programmierelemente und setzen sie in einem anschaulichen Zusammenhang ein. Später, ab Kapitel 12,
zeige ich Ihnen ihre vielfältigen Möglichkeiten.
3.1 Daten bekannt machen und speichern
Nehmen wir an, Sie kaufen zwei Äpfel. Jeder Apfel kostet 1,45 Euro, da es
sich um besonders gute Äpfel aus zertifiziertem Bio-Anbau handelt. Damit
haben wir unsere ersten Daten. Die Anzahl der gekauften Äpfel ist eine
ganze Zahl. Beim Preis der Äpfel handelt es sich um eine Zahl mit Stellen
nach dem Komma.
Zahlenarten
Einzelne Daten werden in Variablen gespeichert. Variablen können ihren
Wert verändern. In C gibt es unterschiedliche Typen von Variablen. Jeder
dieser sogenannten Datentypen hat einen eigenen Einsatzzweck und bietet
bestimmte Vorteile. Wir beschränken uns zunächst auf die Datentypen int
für ganze Zahlen und double für Zahlen mit Nachkommastellen.
Datentypen
29
3
3.2
Verschiedene Arten von Daten
Ein Beispiel:
#include <stdio.h>
int main()
{
/* Deklaration */
int anzahl;
double preis;
/* Zuweisung */
anzahl = 2;
preis = 1.45;
return 0;
}
Listing 3.1 Datei »daten.c«
Deklaration
Eine Deklaration dient dazu, einer Variablen einen Namen zu geben und sie
einem Datentyp zuzuordnen. Eine Variable kann erst nach einer Deklaration verwendet werden, daher stehen Deklarationen normalerweise zu
Beginn.
int, double
In der Variablen anzahl vom Typ int kann eine ganze Zahl gespeichert werden, in der Variablen preis vom Typ double eine Zahl mit Nachkommastellen.
Zuweisung
Eine Variable kann per Zuweisung einen Wert erhalten. Eine Zuweisung
wird mit Hilfe des Zeichens = notiert. Die Variable auf der linken Seite
erhält den Wert, der auf der rechten Seite des Gleichheitszeichens steht.
Erleichtern Sie sich die Entwicklung: Geben Sie den Variablen aussagekräftige Namen. Sie können den Preis eines eingekauften Artikels auch in der
Variablen x speichern. Dann weiß aber später niemand mehr, was sich
dahinter verbirgt. Falls Sie zwei verschiedene Preise speichern möchten,
dann nehmen Sie zum Beispiel die Namen preisApfel und preisBanane.
Diese gut lesbare Schreibweise nennt sich camelCase, wegen des »Kamelhöckers« mitten im Wort.
Sie können zu jedem Zeitpunkt des Programms den aktuellen Wert einer
Variablen auf dem Bildschirm ausgeben. Dazu werden sogenannte Platzhalter benötigt. Diese stehen bei der Ausgabe mit Hilfe der Funktion
printf() genau an der Stelle des Textes, an der der Wert ausgegeben werden soll. Variablen vom Typ int können mit dem Platzhalter %d (oder auch
mit dem Platzhalter %i) ausgegeben werden. Bei Variablen vom Datentyp
double nimmt man den Platzhalter %f.
왘 Die deutschen Umlaute und das scharfe S (ß) gehören nicht zu den
erlaubten Buchstaben.
왘 Der Name darf nicht mit einer Ziffer beginnen.
왘 Eines der Schlüsselwörter der Sprache C (siehe Abschnitt C.3, »Schlüsselwörter der Sprache C«) darf nicht als Name verwendet werden.
30
Platzhalter %d
und %f
Ein Beispiel:
#include <stdio.h>
int main()
{
/* Deklaration mit Initialisierung */
int anzahl = 2;
double preis = 1.45;
/* Ausgabe */
printf("Anzahl: %d\n", anzahl);
printf("Preis: %f Euro\n", preis);
printf("Preis: %.2f Euro\n", preis);
return 0;
Einige Regeln für die Namen der Variablen:
왘 Es sind nur Buchstaben, Ziffern und der Unterstrich gestattet.
Aussagekräftige
Namen
3.2 Wie gebe ich Daten auf dem Bildschirm aus?
Vor der ersten Zuweisung hat eine Variable einen zufälligen Wert. Im Verlauf des Programms kann sich der Wert einer Variablen beliebig oft ändern.
Sie können das Programm übersetzen und ausführen. Allerdings erzeugt
es keine Ausgabe auf dem Bildschirm.
Namensregeln
Wie gebe ich Daten auf dem Bildschirm aus?
}
Listing 3.2 Datei »daten_aus.c«
Diesmal erhalten die Variablen bereits bei der Deklaration einen Wert. Dieser Vorgang wird Initialisierung genannt und macht das Programm ein
wenig kompakter. Die Werte der Variablen können sich nach wie vor im
Verlauf des Programms ändern.
Initialisierung
31
3
3.3
Verschiedene Arten von Daten
Das Programm hat die folgende Ausgabe:
{
/* Deklaration */
int anzahl;
double preis;
Anzahl: 2
Preis: 1.450000 Euro
Preis: 1.45 Euro
Formatierte
Ausgabe
Dezimalpunkt
Wie kann der Benutzer seine Daten per Tastatur eingeben?
/* Erste Eingabe */
printf("Anzahl eingeben: ");
scanf("%d", &anzahl);
Der Wert der Variablen anzahl steht am Ende der ersten Ausgabe. Der Wert
der Variablen preis wird jeweils mitten in der zweiten und dritten Ausgabe
eingebettet. Ohne genauere Angabe führt %f zu einer Formatierung der
Ausgabe auf sechs Nachkommastellen. Durch die Angabe %.2f findet eine
Formatierung auf zwei Nachkommastellen statt.
/* Zweite Eingabe */
printf("Preis in Euro eingeben: ");
scanf("%lf", &preis);
Beachten Sie die englische Schreibweise: mit einem Dezimalpunkt statt
einem Dezimalkomma.
/* Ausgabe */
printf("Anzahl: %d\n", anzahl);
printf("Preis: %.2f Euro\n", preis);
3.3 Wie kann der Benutzer seine Daten
per Tastatur eingeben?
return 0;
}
scanf()
Ein Programm wird erst dann interaktiv, wenn sein Benutzer die Möglichkeit hat, Eingaben zu machen. Dazu setzen Sie als Entwickler die Funktion
scanf() ein. Was bewirkt sie?
왘 Das Programm hält an und wartet auf eine Eingabe. Sie sollten dem
Benutzer vorher mitteilen, welche Information von ihm an dieser Stelle
erwartet wird.
왘 Nach der Eingabe per Tastatur betätigt der Benutzer die Taste (¢). Erst
dann läuft das Programm weiter, speichert die eingegebenen Daten in
Variablen und verarbeitet sie im weiteren Verlauf des Programms.
Adressoperator
Auch bei scanf() werden Platzhalter benötigt, wie bei der Funktion
printf(). Bei Variablen des Datentyps int können Sie weiterhin %d verwenden. Eine double-Variable muss allerdings mit %lf eingelesen werden, also
mit dem kleinen Buchstaben l vor dem f. Außerdem muss vor dem Namen
der Variablen das Zeichen & angegeben werden. Dabei handelt es sich um
den sogenannten Adressoperator, der auf die Adresse der Variablen im
Speicher verweist.
Ein Beispiel:
#include <stdio.h>
int main()
32
Listing 3.3 Datei »daten_ein.c«
Die Ausgabe des Programms könnte, mit einigen Beispieleingaben des
Benutzers, wie folgt aussehen:
Anzahl eingeben: 3
Preis in Euro eingeben: 1.35
Anzahl: 3
Preis: 1.35 Euro
Die Funktion scanf() bietet einige Stolperfallen für den Benutzer:
왘 Er muss bei der Eingabe wiederum die englische Schreibweise beachten,
mit einem Dezimalpunkt statt einem Dezimalkomma.
Dezimalpunkt
왘 Sollte er mehrere Eingaben auf einmal vornehmen, Buchstaben statt
Ziffern eingeben oder ein Komma statt eines Punkts, führt dies leider zu
einem unerwarteten Programmverlauf.
Falsche Eingaben
Sie werden in Abschnitt 12.6, »Zeichen und Texte speichern«, Möglichkeiten kennenlernen, mit denen Sie als Entwickler falsche Eingaben des
Benutzers abfangen können. Zunächst gehen wir davon aus, dass er richtige Eingaben vornimmt.
Abfangen
33
3
3.4
Verschiedene Arten von Daten
Auch Sie als Entwickler können Fehler machen. Hier einige Tipps, die Sie
beim Einsatz der Funktion scanf() beachten sollten:
summeRechnung = anzahlApfel * preisApfel
+ anzahlBirne * preisBirne;
preisMittel = summeRechnung / (anzahlApfel + anzahlBirne);
preisDifferenz = preisApfel - preisBirne;
왘 Innerhalb der Anführungsstriche sollte allein der Platzhalter notiert
werden, also nur %d oder %lf, nicht etwa %d\n oder %.2lf.
왘 Vergessen Sie nicht, den Adressoperator & zu notieren.
Fehler bei der
Ausführung
Vielfalt
Das Gefährliche an den genannten Fehlern des Entwicklers: Es sind keine
Syntaxfehler. Das Programm wird also leider übersetzt, ohne sichtbare Fehlermeldung. Erst während der Laufzeit des Programms treten Fehler auf,
weil zum Beispiel eine Variable nicht den richtigen Eingabewert erhalten
hat und in der Folge ein unverständliches Ergebnis auftritt.
Sie werden sich fragen: Wieso meldet der Compiler diese Fehler nicht als
Syntaxfehler? Der Grund liegt unter anderem in der Vielfalt der Programmierung mit C. Es gibt auch Operationen für andere Einsatzzwecke, die
genau diese Schreibweise erfordern, die zunächst als falsch erscheint.
3.4 Berechnungen mit Operatoren
Grundrechenarten
Punkt vor Strich
In diesem Abschnitt führen wir einige Berechnungen im Bereich der
Grundrechenarten durch. Wir benutzen die Operatoren + für die Addition,
- für die Subtraktion, * für die Multiplikation und / für die Division.
/* Ausgabe */
printf("Summe der Rechnung: %.2f Euro\n", summeRechnung);
printf("Mittlerer Preis: %.2f Euro\n", preisMittel);
printf("Preis-Differenz: %.2f Euro\n", preisDifferenz);
return 0;
}
Listing 3.4 Datei »daten_rechnen.c«
Was passiert bei diesem Einkaufsvorgang?
왘 Es werden zwei verschiedene Artikel eingekauft, in unterschiedlicher
Anzahl. Daher werden weitere Variablen benötigt. Mehrere Variable desselben Typs können Sie durch Komma getrennt innerhalb einer Anweisung deklarieren und auch initialisieren.
Mehrere
Deklarationen
왘 Es werden Variable für die Ergebnisse der Rechenoperationen deklariert.
왘 Zur Berechnung der Summe der Rechnung werden die Einzelsummen
pro Artikel ermittelt. Anschließend werden diese Einzelsummen addiert.
Summe
왘 Der mittlere Preis eines Artikels dieses Einkaufsvorgangs ergibt sich,
indem wir die Summe der Rechnung durch die Gesamtanzahl der Artikel teilen. Wir müssen Klammern setzen, da ansonsten die Division Vorrang hätte.
Mittelwert
Zunächst das Programm:
왘 Als Letztes wird die preisliche Differenz der beiden Artikel ermittelt.
Differenz
#include <stdio.h>
int main()
{
/* Deklaration, teilweise mit Initialisierung */
int anzahlApfel = 2, anzahlBirne = 4;
double preisApfel = 1.45, preisBirne = 0.85;
double summeRechnung, preisMittel, preisDifferenz;
Es ergibt sich die folgende Ausgabe:
Wie in der Mathematik gilt: Punktrechnung vor Strichrechnung. Die Operatoren * und / haben also Vorrang vor den Operatoren + und -. Sie können
zusätzlich Klammern setzen, um die Reihenfolge der Berechnung zu beeinflussen. Sie finden in Abschnitt 12.1.9, »Alle Operatoren«, eine Tabelle mit
den Vorrangregeln für die Operatoren.
/* Berechnung */
34
Berechnungen mit Operatoren
Summe der Rechnung: 6.30 Euro
Mittlerer Preis: 1.05 Euro
Preis-Differenz: 0.60 Euro
Eine Rechenoperation, an der eine ganze Zahl und eine Zahl mit Nachkommastellen beteiligt sind, ergibt in C eine Zahl mit Nachkommastellen.
Ein Beispiel: Bei der Berechnung des mittleren Preises pro Artikel wird eine
Daten umwandeln
35
3
double-Variable durch die Summe von zwei int-Variablen geteilt. Es ergibt
sich ein double-Wert.
Hinweis
Ganzzahldivision
Falls an einer Division zwei ganze Zahlen beteiligt sind, ergibt sich wiederum eine ganze Zahl. Sollten sich Nachkommastellen ergeben, dann
werden diese abgeschnitten. Ein Beispiel: 11 durch 4 ergibt den Wert 2
und nicht etwa 2,75, wie es mathematisch richtig wäre.
Als Abhilfe kann zum Beispiel Folgendes dienen:
왘 Sie schreiben 11.0 / 4 oder 11 / 4.0, geben also eine der beiden Zahlen
als double-Wert an.
왘 Sie schreiben 1.0 * 11 / 4, multiplizieren also einen double-Wert mit der
ersten Zahl.
3.5 Entwicklung eines Programms
Teile eines
Programms
Einfache Version
Bei der Entwicklung Ihrer eigenen Programme sollten Sie Schritt für Schritt
vorgehen. Stellen Sie zuerst einige Überlegungen an, wie das gesamte Programm aufgebaut sein sollte, und zwar auf Papier. Aus welchen Teilen
sollte es nacheinander bestehen? Versuchen Sie dann nicht, das gesamte
Programm mit all seinen komplexen Bestandteilen auf einmal zu schreiben! Dies ist der größte Fehler, den Einsteiger (und manchmal auch Fortgeschrittene) machen können.
Schreiben Sie zunächst eine einfache Version des ersten Programmteils.
Anschließend testen Sie sie. Erst nach einem erfolgreichen Test fügen Sie
den folgenden Programmteil hinzu. Nach jeder Änderung testen Sie wiederum. Sollte sich ein Fehler zeigen, so wissen Sie, dass er aufgrund der letzten Änderung aufgetreten ist. Nach dem letzten Hinzufügen haben Sie eine
einfache Version Ihres gesamten Programms.
Komplexe Version
Nun ändern Sie einen Teil Ihres Programms in eine komplexere Version ab.
Auf diese Weise machen Sie Ihr Programm Schritt für Schritt komplexer,
bis Sie schließlich das gesamte Programm so erstellt haben, wie es Ihren
anfänglichen Überlegungen auf Papier entspricht.
Änderungen
Manchmal ergibt sich während der praktischen Programmierung noch die
eine oder andere Änderung gegenüber Ihrem Entwurf. Das ist kein Pro-
36
3.6
Verschiedene Arten von Daten
Fehler suchen
blem, solange sich nicht der gesamte Aufbau ändert. Sollte dies allerdings
der Fall sein, so kehren Sie noch einmal kurz zum Papier zurück und überdenken den Aufbau. Das bedeutet nicht, dass Sie die bisherigen Programmzeilen löschen müssen, sondern möglicherweise nur ein wenig ändern und
anders anordnen.
Schreiben Sie Ihre Programme übersichtlich. Falls Sie gerade überlegen,
wie Sie drei, vier bestimmte Schritte Ihres Programms auf einmal machen
können: Machen Sie daraus einfach einzelne Anweisungen, die der Reihe
nach ausgeführt werden. Dies vereinfacht eine eventuelle Fehlersuche.
Falls Sie (oder jemand anders) Ihr Programm später einmal ändern oder
erweitern möchten, dann gelingt der Einstieg in den Aufbau des Programms wesentlich schneller.
Einzelne Schritte
Sie können die Funktion printf() und das nachfolgend beschriebene
Debugging zur Kontrolle von Werten und zur Suche von logischen Fehlern
einsetzen. Zusätzlich können Sie einzelne Zeilen Ihres Programms als
Kommentar kennzeichnen, um festzustellen, welcher Teil des Programms
fehlerfrei läuft und welcher Teil demnach fehlerbehaftet ist.
3.6 Fehler suchen
Sollte eines Ihrer Programme unerwartete Ergebnisse haben, so müssen
Sie sich auf die Suche nach dem Fehler machen. Wie auch andere Entwicklungsumgebungen bietet Ihnen Dev-C++ einige Möglichkeiten für dieses
sogenannte Debugging.
Debugging
Diese möchte ich Ihnen schon zu diesem frühen Zeitpunkt vorstellen,
damit Sie sich an die Handhabung gewöhnen. Sie können Ihr Programm
schrittweise ablaufen lassen, um die Werte bestimmter Variablen zu unterschiedlichen Zeitpunkten des Programms zu kontrollieren.
Werte kontrollieren
Klicken Sie einmal auf den grauen Balken vor einer Programmzeile.
Anschließend wird die Zeile rot unterlegt. Sie dient nun als Haltepunkt. Sie
können auf diese Weise mehrere Haltepunkte setzen. Ein erneuter Klick in
derselben Programmzeile entfernt den Haltepunkt wieder. In Abbildung 3.1 sehen Sie im Programm daten_rechnen.c zwei Haltepunkte.
Haltepunkt
Bei der normalen Ausführung des Programms mit Hilfe des Menüpunkts
Ausführen 폷 Kompilieren + Ausführen (Funktionstaste (F11)) ändert
sich durch die Haltepunkte noch nichts.
37
3
3.7
Verschiedene Arten von Daten
Eine Übungsaufgabe
Sie können im Menü Fehlersuche auch jederzeit den Menüpunkt Watch
hinzuf. aufrufen. Anschließend geben Sie in dem kleinen Dialogfeld
Neuer Variablen Watch den Namen einer Variablen ein, zum Beispiel
»preisMittel«, siehe Abbildung 3.3.
Watch hinzufügen
Abbildung 3.1 Zwei Haltepunkte
Programm hält an
Aktuelle Werte
Falls Sie aber das Menü Fehlersuche und darin den Menüpunkt Fehlersuche wählen (Funktionstaste (F5)), dann hält das Programm vor dem
Ausführen der Zeile mit dem Haltepunkt an. Falls es schon Ausgaben gegeben hat, so stehen diese bereits im Ausgabefenster. Steht das Programm
zum Beispiel am zweiten Haltepunkt in Abbildung 3.1, dann wurde die
Summe der Rechnung bereits ausgegeben.
Lassen Sie die Maus über einer der Variablen schweben (ohne zu klicken),
dann wird der aktuelle Wert der Variablen in einem kleinen Feld sichtbar.
In Abbildung 3.2 sehen Sie den aktuellen Wert der Variablen preisMittel,
nachdem Programmzeile 13 durchlaufen wurde.
Abbildung 3.2 Wert einer Variablen im Tooltip-Feld
Einzelschritte
Weiterspringen
38
Die Auswahl des Menüpunkts Nächster Schritt im Menü Fehlersuche
(Funktionstaste (F7)) führt dazu, dass genau eine Programmzeile bearbeitet wird. Auf diese Weise können Sie also Ihr Programm schrittweise ablaufen lassen. Dies habe ich in Abbildung 3.1 bereits mehrmals durchgeführt,
so dass das Programm aktuell auf Programmzeile 14 steht.
Der Menüpunkt Fortsetzen im Menü Fehlersuche bewirkt, dass das
Programm zum nächsten Haltepunkt vorrückt, falls vorhanden. Falls es
keinen weiteren Haltepunkt geben sollte, wird die Fehlersuche beendet.
Dasselbe passiert, wenn Sie den Menüpunkt Ausführung stoppen im
Menü Fehlersuche wählen (Funktionstaste (F6)).
Abbildung 3.3 Watch hinzufügen
Diese Variable erscheint dann inklusive ihres jeweils aktuellen Werts dauerhaft auf der Registerkarte Fehlersuche im Projekt/Klassen-Browser
auf der linken Seite, siehe Abbildung 3.4. Sollte der Browser nicht zu sehen
sein, so können Sie ihn über den entsprechenden Menüpunkt im Menü
Ansicht einblenden.
Dauerhafte Anzeige
Abbildung 3.4 Variable im Watch-Fenster
3.7 Eine Übungsaufgabe
Schreiben Sie ein Programm in der Datei u_daten.c. Es soll die folgende
Ausgabe ermöglichen (hier mit Eingaben des Benutzers):
Erster Artikel, Anzahl: 5
Erster Artikel, Preis in Euro: 2.10
Zweiter Artikel, Anzahl: 2
Zweiter Artikel, Preis in Euro: 1.60
Summe ohne Rabatt: 13.70 Euro
Summe mit Rabatt: 10.96 Euro
39
3
Verschiedene Arten von Daten
Rabatt berechnen
Der Benutzer soll also Anzahl und Preis für zwei verschiedene eingekaufte Artikel eingeben. Anschließend wird die Summe der Rechnung
ermittelt. Außerdem wird ein Rabatt von 20 % gewährt. Als Letztes soll die
Summe einschließlich des eingerechneten Rabatts ausgegeben werden.
Wählen Sie geeignete Variablennamen, und kommentieren Sie Ihr Programm ausreichend. Eine mögliche Lösung finden Sie im Anhang in
Abschnitt D.2, »Datei ›u_daten.c‹«.
Kapitel 4
Verschiedene Fälle in einem Programm
Ein Programm kann unterschiedliche Anweisungen durchlaufen,
abhängig vom Wahrheitswert einer oder mehrerer Bedingungen.
In den bisherigen Programmen wurden alle Anweisungen Zeile für Zeile
ausgeführt. Ein Programm soll aber auch in der Lage sein, auf unterschiedliche Situationen zu reagieren. Sie als Entwickler können nicht wissen, was
der Benutzer eingibt oder welche Inhalte eine Datei bietet, die Daten für Ihr
Programm bereitstellt.
In diesen Fällen sollte Ihr Programm verzweigen. Es sollte abhängig von
der Situation unterschiedliche Anweisungen durchlaufen. Eine Verzweigung wird mit Hilfe einer Bedingung formuliert. Eine Bedingung hat einen
Wahrheitswert. Dieser ist entweder wahr oder falsch.
Verzweigung
4.1 Eine einfache Bedingung mit »if«
Sie können eine Verzweigung durch das Schlüsselwort if einleiten. Nach
dem if folgt in runden Klammern eine Bedingung. Ist diese Bedingung
wahr, wird die folgende Anweisung oder der folgende Block von Anweisungen ausgeführt. Eine Bedingung bilden Sie mit Hilfe eines Vergleichsoperators.
Wahr
Einen Block von Anweisungen erzeugen Sie mit Hilfe von geschweiften
Klammern. Jede Funktion, also auch die Funktion main(), enthält einen solchen Block von Anweisungen.
Anweisungsblock
Ein Beispiel:
#include <stdio.h>
int main()
{
40
41
4
4.2
Verschiedene Fälle in einem Programm
double preis = 0.85;
4.2 Welche Bedingungen gibt es?
/* Bedingte Ausführung eines Blocks von Anweisungen */
if(preis > 0.99)
{
printf("Ein teurer Artikel\n");
printf("Brauchen wir den wirklich?\n");
}
Beim Vergleich von Zahlen stehen Ihnen sechs verschiedene Vergleichsoperatoren zur Verfügung. Neben > und < gibt es vier Operatoren, die
jeweils aus zwei Zeichen bestehen: >= (größer als oder gleich), <= (kleiner als
oder gleich), == (gleich) und != (ungleich).
/* Bedingte Ausführung einer einzelnen Anweisung */
if(preis < 1.0)
printf("Ein billiger Artikel\n");
#include <stdio.h>
int main()
{
double preisApfel = 1.45, preisBirne = 0.85, preisKiwi = 1.45;
/* Größer */
if(preisApfel > preisBirne)
printf("Apfel ist teurer als Birne\n");
}
Listing 4.1 Datei »fall_if.c«
/* Kleiner */
if(preisBirne < preisKiwi)
printf("Birne ist billiger als Kiwi\n");
Es werden die beiden Vergleichsoperatoren > (größer als) und < (kleiner als)
verwendet. Liegt der Preis über 99 Cent, dann handelt es sich um einen teuren Artikel, und es wird der Block mit den beiden Anweisungen zur Ausgabe durchgeführt. Liegt der Preis unterhalb von einem Euro, dann ist der
Artikel billig, und es wird die einzelne Anweisung ausgeführt.
/* Größer oder gleich */
if(preisApfel >= preisKiwi)
printf("Apfel ist mindestens so teuer wie Kiwi\n");
Das Programm erzeugt die folgende Ausgabe:
Ein billiger Artikel
/* Kleiner oder gleich */
if(preisBirne <= preisKiwi)
printf("Birne ist hoechstens so teuer wie Kiwi\n");
Ändern Sie einmal den Preis so ab, dass die andere Ausgabe erfolgt.
Einrückung
> < >= <= == !=
Alle Vergleichsoperatoren werden in folgendem Beispiel genutzt:
return 0;
Vergleichsoperatoren
Welche Bedingungen gibt es?
Eine Empfehlung: Erhöhen Sie die Lesbarkeit Ihrer Programme, indem Sie
die Anweisung(en) innerhalb einer Verzweigung einrücken, wie Sie dies im
vorliegenden Programm sehen.
/* Gleich */
if(preisApfel == preisKiwi)
printf("Apfel und Kiwi haben denselben Preis\n");
Hinweis
/* Ungleich */
if(preisBirne != preisKiwi)
printf("Birne und Kiwi haben unterschiedliche Preise\n");
Achten Sie darauf, nach der Bedingung kein Semikolon zu notieren. Dies
würde die Verzweigung unmittelbar beenden. Der Compiler meldet diesen Fehler nicht. Die anschließende Anweisung wäre nicht mehr mit der
Verzweigung verbunden und würde stets ausgeführt.
return 0;
}
Listing 4.2 Datei »fall_vergleich.c«
42
43
4
4.4
Verschiedene Fälle in einem Programm
Es werden die Preise von drei unterschiedlichen Artikeln miteinander verglichen. Das Programm erzeugt die folgende Ausgabe:
Apfel
Birne
Apfel
Birne
Apfel
Birne
ist
ist
ist
ist
und
und
teurer als Birne
billiger als Kiwi
mindestens so teuer wie Kiwi
hoechstens so teuer wie Kiwi
Kiwi haben denselben Preis
Kiwi haben unterschiedliche Preise
Bei den hier gewählten Preisen werden alle Bedingungen erfüllt, und es
erfolgen alle Ausgaben. Ändern Sie einmal einzelne Preise ab, und überlegen Sie, welche Ausgaben dann erfolgen und welche nicht. Starten Sie erst
anschließend zur Bestätigung das Programm.
Wie kann ich Bedingungen kombinieren?
/* Ansonsten, falls also Bedingung nicht zutrifft */
else
{
printf("Ein billiger Artikel\n");
printf("Den nehmen wir\n");
}
return 0;
}
Listing 4.3 Datei »fall_else.c«
Das Programm erzeugt in jedem Fall eine Ausgabe. Hier ist es die folgende:
Ein billiger Artikel
Den nehmen wir
Hinweis
= und ==
Achten Sie auf den Unterschied zwischen einer Zuweisung mit = und
einem Vergleich mit ==. Der Compiler übersetzt auch die Anweisung
if(preis = 1.5) ohne Fehlermeldung. Allerdings haben Sie damit nicht
geprüft, ob der Preis 1,50 Euro beträgt, sondern den Preis mit 1,50 Euro
festgelegt. Dies führt nicht zu den erwarteten Ergebnissen.
Hinweis
Achten Sie auch darauf, nach dem else kein Semikolon zu notieren. Dies
würde diesen Zweig der Verzweigung unmittelbar beenden. Der Compiler meldet diesen Fehler ebenfalls nicht. Die anschließende Anweisung
wäre nicht mehr mit der Verzweigung verbunden und würde stets ausgeführt.
4.3 Zwei Möglichkeiten, mit »if« und »else«
Nicht wahr
Sie können eine Verzweigung durch das Schlüsselwort else erweitern. Ist
die Bedingung nach dem if nicht wahr, dann wird die Anweisung oder der
Block von Anweisungen ausgeführt, der dem else folgt.
Ein Beispiel:
#include <stdio.h>
int main()
{
double preis = 0.85;
/* Falls Bedingung zutrifft */
if(preis > 0.99)
printf("Ein teurer Artikel\n");
44
4.4 Wie kann ich Bedingungen kombinieren?
Der Ablauf innerhalb einer Verzweigung kann auch von mehreren Bedingungen abhängig sein, die miteinander verknüpft werden. Die wichtigste
Frage ist: Sollen alle Bedingungen wahr sein, oder reicht es aus, wenn eine
der Bedingungen wahr ist?
Verknüpfung
왘 Falls alle Bedingungen zutreffen sollen, dann verknüpfen Sie sie mit
Hilfe des Operators &&. Er steht für das logische Und.
Und &&
왘 Reicht dagegen eine Bedingung aus, dann nutzen Sie den Operator ||.
Er steht für das logische Oder.
Oder ||
Es gibt noch einen dritten logischen Operator: Das Zeichen ! steht für das
logische Nicht. Mit diesem Operator wird der Wahrheitswert einer Bedin-
Nicht !
45
4
4.5
Verschiedene Fälle in einem Programm
Eine Übungsaufgabe
gung umgedreht: Aus wahr wird falsch und umgekehrt. Manche Verzweigung lässt sich mit Hilfe dieses Operators einfacher formulieren.
Bedingungen ermittelt wird. Erst anschließend werden die Bedingungen
verknüpft.
Ein Beispiel:
Allerdings hat der Operator ! für das logische Nicht Vorrang vor den Vergleichsoperatoren. Daher wird die Bedingung in Klammern gesetzt, bevor
ihr Wahrheitswert umgekehrt wird. Sie finden in Abschnitt 12.1.9, »Alle
Operatoren«, eine Tabelle mit den Vorrangregeln für die Operatoren.
#include <stdio.h>
int main()
{
double preisApfel = 1.45, preisBirne = 0.85, preisBanane = 0.75;
/* Logisches Und */
if(preisBirne < 1.0 && preisBanane < 1.0)
printf("Beide Artikel sind billig\n");
4.5 Eine Übungsaufgabe
Schreiben Sie ein Programm in der Datei u_fall.c. Es soll die folgende Ausgabe ermöglichen (hier mit Eingaben des Benutzers):
/* Logisches Oder */
if(preisApfel > 0.99 || preisBirne > 0.99)
printf("Mindestens einer der Artikel ist teuer\n");
Anzahl: 5
Preis in Euro: 3.20
Summe der Rechnung: 12.80 Euro
/* Logisches Nicht */
if(!(preisBanane > 0.99))
printf("Artikel ist nicht teuer\n");
Der Benutzer soll Anzahl und Preis für einen eingekauften Artikel eingeben. Anschließend wird die Summe der Rechnung ermittelt. Falls diese
Summe 10 Euro überschreitet, soll ein Rabatt von 20% gewährt werden;
ansonsten soll kein Rabatt gewährt werden. Wählen Sie geeignete Variablennamen, und kommentieren Sie Ihr Programm ausreichend. Eine mögliche Lösung finden Sie in Abschnitt D.3, » Datei ›u_fall.c‹«.
return 0;
}
Vorrangregeln
Listing 4.4 Datei »fall_kombi.c«
Es werden die Preise von drei unterschiedlichen Artikeln miteinander
verglichen. Das Programm erzeugt die folgende Ausgabe:
Beide Artikel sind billig
Mindestens einer der Artikel ist teuer
Artikel ist nicht teuer
Bei den hier gewählten Preisen werden alle Bedingungen erfüllt, und es
erfolgen alle Ausgaben. Ändern Sie einmal einzelne Preise ab, und überlegen Sie, welche Ausgaben dann erfolgen und welche nicht. Starten Sie
erst anschließend zur Bestätigung das Programm.
Vergleich vor
Verknüpfung
46
Die Vergleichsoperatoren haben Vorrang vor den logischen Operatoren &&
und ||. Das bedeutet, dass zunächst der Wahrheitswert der einzelnen
47
Auf einen Blick
Auf einen Blick
1
Eine erste Einführung ...........................................................................................
15
2
Unser erstes Programm .......................................................................................
19
3
Verschiedene Arten von Daten .........................................................................
29
4
Verschiedene Fälle in einem Programm ........................................................
41
5
Programmteile wiederholen ..............................................................................
49
6
Programme übersichtlich aufteilen ................................................................
61
7
Große Datenmengen speichern .......................................................................
69
8
Zeichen und Texte speichern .............................................................................
75
9
Indirekter Zugriff mit Zeigern ...........................................................................
83
10
Unterschiedliche Daten zusammenfassen ...................................................
89
11
Daten auf der Festplatte ..................................................................................... 101
12
Eine Vertiefung der bisherigen Themen ........................................................ 107
13
Daten dynamisch im Speicher verwalten ..................................................... 215
14
Arbeiten mit Zahlen .............................................................................................. 227
15
Präprozessor-Anweisungen ............................................................................... 247
16
Zugriff auf Dateien und Verzeichnisse ........................................................... 255
17
Umgang mit Datum und Uhrzeit ..................................................................... 269
18
Kommunikation mit dem Betriebssystem .................................................... 281
19
Datenbanken ........................................................................................................... 287
20
Beispielprojekte ..................................................................................................... 309
21
Grafische Benutzeroberflächen mit GTK+ .................................................... 337
22
Raspberry Pi ............................................................................................................. 361
Inhalt
Inhalt
1
Eine erste Einführung
15
1.1
Welche Vorteile bietet C? .......................................................................................
15
1.2
Was benötige ich zum Programmieren? ..............................................................
16
1.3
Wie ist dieses Buch aufgebaut? .............................................................................
16
1.4
Wie sollten Sie mit diesem Buch arbeiten? .........................................................
17
2
Unser erstes Programm
19
2.1
Wie gebe ich das Programm ein? ..........................................................................
19
2.2
Das Programm wird gespeichert ...........................................................................
21
2.3
Wie starte ich das fertige Programm? ..................................................................
23
2.4
Eine weitere Möglichkeit zum Starten .................................................................
25
2.5
Kommentare sind wichtig ......................................................................................
26
2.6
Eine Übungsaufgabe ................................................................................................
27
3
Verschiedene Arten von Daten
29
3.1
Daten bekannt machen und speichern ................................................................
29
3.2
Wie gebe ich Daten auf dem Bildschirm aus? .....................................................
31
3.3
Wie kann der Benutzer seine Daten per Tastatur eingeben? ..........................
32
3.4
Berechnungen mit Operatoren ..............................................................................
34
3.5
Entwicklung eines Programms ..............................................................................
36
3.6
Fehler suchen .............................................................................................................
37
3.7
Eine Übungsaufgabe ................................................................................................
39
5
Inhalt
Inhalt
6
4
Verschiedene Fälle in einem Programm
41
4.1
Eine einfache Bedingung mit »if« .........................................................................
41
4.2
Welche Bedingungen gibt es? ................................................................................
43
4.3
Zwei Möglichkeiten, mit »if« und »else« ............................................................
44
4.4
Wie kann ich Bedingungen kombinieren? ..........................................................
45
4.5
Eine Übungsaufgabe ................................................................................................
47
5
Programmteile wiederholen
49
5.1
Regelmäßige Wiederholungen mit »for« ............................................................
50
5.2
Bedingte Wiederholungen mit »do-while« ........................................................
52
5.3
Besser vorher prüfen mit »while«? .......................................................................
54
5.4
Tabellen formatieren ...............................................................................................
57
5.5
Eine Übungsaufgabe zu Tabellen ..........................................................................
58
5.6
Eine Übungsaufgabe zur Eingabekontrolle .........................................................
59
6
Programme übersichtlich aufteilen
61
6.1
Wie definiere ich eine Funktion? ...........................................................................
61
6.2
Wie rufe ich eine Funktion auf? .............................................................................
63
6.3
Werte an eine Funktion übergeben ......................................................................
64
6.4
Ein Ergebnis von einer Funktion zurückerhalten ...............................................
66
6.5
Eine Übungsaufgabe ................................................................................................
67
7
Große Datenmengen speichern
69
7.1
Felder erzeugen und mit Daten füllen .................................................................
69
7.2
Wie gebe ich die Daten aus? ..................................................................................
71
7.3
Wie kann der Benutzer ein Feld füllen? ...............................................................
72
7.4
Eine Übungsaufgabe ................................................................................................
74
8
Zeichen und Texte speichern
75
8.1
Zeichenketten erzeugen und füllen ......................................................................
75
8.2
Wie gebe ich eine Zeichenkette aus? ...................................................................
77
8.3
Wie kann der Benutzer eine Zeichenkette füllen? ............................................
78
8.4
Mehrere Zeichenketten ...........................................................................................
79
8.5
Wie kann ich Zeichenketten formatieren? ..........................................................
80
8.6
Eine Übungsaufgabe ................................................................................................
81
9
Indirekter Zugriff mit Zeigern
83
9.1
Wie arbeite ich mit Zeigern und Adressen? ........................................................
83
9.2
Wie nutze ich Zeiger bei Funktionen? ..................................................................
85
9.3
Wir zeigen auf Felder ...............................................................................................
86
9.4
Eine Übungsaufgabe ................................................................................................
88
10
Unterschiedliche Daten zusammenfassen
89
10.1
Strukturen definieren ..............................................................................................
89
10.2
Wie erzeuge ich Strukturdaten? ............................................................................
90
10.3
Wie gebe ich die Daten aus? ..................................................................................
91
10.4
Wie kann der Benutzer Strukturen füllen? .........................................................
92
10.5
Mehrere Strukturdaten ...........................................................................................
94
10.6
Wie übergebe ich Strukturdaten? .........................................................................
95
10.7
Eine Übungsaufgabe ................................................................................................
98
7
Inhalt
Inhalt
11
Daten auf der Festplatte
12.4.6
101
12.5
11.1
Wie speichere ich Daten auf der Festplatte? ...................................................... 101
11.2
Wie lese ich Daten von der Festplatte? ................................................................ 104
11.3
Eine Übungsaufgabe ................................................................................................ 106
12
Eine Vertiefung der bisherigen Themen
12.1
Verschiedene Arten von Daten .............................................................................. 107
12.1.1
12.1.2
12.1.3
12.1.4
12.1.5
12.1.6
12.1.7
12.1.8
12.1.9
12.2
12.8
Varianten der »for«-Schleife ....................................................................
Schleifen vorzeitig abbrechen oder später fortsetzen ..........................
Eine Schleife in einer Schleife ..................................................................
Eine mehrfache Schleife abbrechen .......................................................
Funktionen deklarieren ............................................................................ 140
Lokale und globale Variablen .................................................................. 141
Statische Variable ..................................................................................... 143
Rekursive Funktionen ............................................................................... 144
Zeiger auf Funktionen .............................................................................. 146
166
167
169
171
172
174
175
177
179
181
Rechnen mit Zeigern und Adressen ........................................................
190
Vereinfachung durch »typedef« ..............................................................
Strukturen in Strukturen ..........................................................................
Enumerationen .........................................................................................
193
193
195
Daten auf der Festplatte ......................................................................................... 197
12.9.1
12.9.2
12.9.3
12.9.4
12.9.5
12.9.6
132
135
137
138
Einzelne Zeichen .......................................................................................
Code eines Zeichens .................................................................................
Funktionen für Zeichenketten .................................................................
Zeichenketten vergleichen .......................................................................
Zeichenketten zerlegen ............................................................................
Sicheres Einlesen von Wörtern ................................................................
Sicheres Einlesen von Zeichenketten ......................................................
Zeichenketten und Zahlen umwandeln .................................................
Sicheres Einlesen von Zahlen ...................................................................
Operationen mit Zeichenketten ..............................................................
Unterschiedliche Daten zusammenfassen .......................................................... 192
12.8.1
12.8.2
12.8.3
12.9
150
156
158
162
Indirekter Zugriff mit Zeigern ................................................................................ 190
12.7.1
12.9.7
Programme übersichtlich aufteilen ...................................................................... 139
12.4.1
12.4.2
12.4.3
12.4.4
12.4.5
8
Wahrheitswerte ........................................................................................ 124
Bedingte Zuweisung ................................................................................. 126
Mehr als zwei Fälle .................................................................................... 127
Fälle zusammenfassen ............................................................................. 128
Nebenwirkungen bei logischen Verknüpfungen .................................. 130
12.7
Programmteile wiederholen .................................................................................. 131
12.3.1
12.3.2
12.3.3
12.3.4
12.4
107
109
111
113
115
116
118
120
122
Verschiedene Fälle in einem Programm .............................................................. 124
12.2.1
12.2.2
12.2.3
12.2.4
12.2.5
12.3
Mehrere Daten auf einmal einlesen .......................................................
Datentypen für ganze Zahlen ..................................................................
Datentypen für Zahlen mit Nachkommastellen ...................................
Umwandlungen zwischen Datentypen ..................................................
Konstanten sind unveränderlich .............................................................
Zufällige Zahlen ........................................................................................
Kombinierte Zuweisungen ......................................................................
Daten tauschen .........................................................................................
Alle Operatoren .........................................................................................
Operationen mit Feldern ..........................................................................
Mehrdimensionale Felder ........................................................................
Felder sortieren .........................................................................................
Elemente in einem Feld suchen ..............................................................
Zeichen und Texte speichern .................................................................................. 166
12.6.1
12.6.2
12.6.3
12.6.4
12.6.5
12.6.6
12.6.7
12.6.8
12.6.9
12.6.10
107
148
Große Datenmengen speichern ............................................................................. 149
12.5.1
12.5.2
12.5.3
12.5.4
12.6
Beliebige Anzahl von Parametern ...........................................................
Programm mit Ein- und Ausgabe ............................................................
Umlenkung der Ein- und Ausgabe ..........................................................
CSV-Dateien schreiben .............................................................................
CSV-Dateien lesen .....................................................................................
Datensätze mit fester Länge schreiben ..................................................
Datensätze mit fester Länge lesen ..........................................................
197
199
200
203
205
207
Datensätze mit fester Länge schreiben und lesen ................................ 209
13
Daten dynamisch im Speicher verwalten
13.1
Warum benötige ich dynamische Felder? ........................................................... 215
13.2
Eine Datenreihe dynamisch speichern ................................................................. 216
215
9
Inhalt
Inhalt
10
13.3
Größe eines dynamischen Felds ändern .............................................................. 218
16.4
Inhalt eines Verzeichnisbaums .............................................................................. 263
13.4
Eine Tabelle dynamisch speichern ........................................................................ 220
16.5
Dateien ändern .......................................................................................................... 266
13.5
Wie übergebe ich ein dynamisches Feld an eine Funktion? ............................ 223
16.6
Verzeichnisse ändern ............................................................................................... 267
14
Arbeiten mit Zahlen
227
17
Umgang mit Datum und Uhrzeit
14.1
Winkelfunktionen .................................................................................................... 227
17.1
Weltzeit ausgeben .................................................................................................... 269
14.2
Runden, Nachkommastellen, Modulo .................................................................. 229
17.2
Lokale Zeit ausgeben und formatieren ................................................................ 270
14.3
Weitere mathematische Funktionen ................................................................... 231
17.3
Zeitangaben erzeugen ............................................................................................. 273
14.4
Komplexe Zahlen darstellen .................................................................................. 232
17.4
Zeitspanne messen ................................................................................................... 274
14.5
Rechnen mit komplexen Zahlen ............................................................................ 234
17.5
Zeit abwarten ............................................................................................................ 276
14.6
Weitere Funktionen für komplexe Zahlen .......................................................... 236
17.6
Alter berechnen ......................................................................................................... 278
14.7
Bit-Operatoren .......................................................................................................... 237
14.8
Umwandlung von Dualzahlen ............................................................................... 241
14.9
Bitfelder ...................................................................................................................... 243
18
Kommunikation mit dem Betriebssystem
18.1
Wie übergebe ich Daten an ein Programm? ....................................................... 281
18.2
Wie nutze ich die Rückgabe eines Programms? ................................................. 283
18.3
Systemkommandos ausführen .............................................................................. 286
19
Datenbanken
19.1
Aufbau einer Datenbank ......................................................................................... 287
19.2
Datenbanken mit SQLite ......................................................................................... 288
19.3
Datenbank und Tabelle erzeugen ......................................................................... 289
19.4
Datensätze einfügen ................................................................................................ 291
15
Präprozessor-Anweisungen
15.1
Einbinden von Dateien ............................................................................................ 247
15.2
Definitionen und Makros ........................................................................................ 248
15.3
Definitionen und Verzweigungen ......................................................................... 250
15.4
Eine Systemweiche ................................................................................................... 252
247
269
281
287
16
Zugriff auf Dateien und Verzeichnisse
16.1
Attribute von Dateien und Verzeichnissen ......................................................... 255
19.5
Anzeigen der Datensätze ........................................................................................ 293
16.2
Zugriffsrechte ändern .............................................................................................. 258
19.6
Auswahl von Datensätzen und Feldern ............................................................... 295
16.3
Inhalt eines Verzeichnisses ..................................................................................... 261
19.7
Auswahl mit Platzhaltern ....................................................................................... 298
255
11
Inhalt
Inhalt
19.8
Auswahl nach Eingabe ............................................................................................. 300
21.5
Eigenschaften setzen und abrufen ....................................................................... 349
19.9
Sortieren der Ausgabe ............................................................................................. 302
21.6
Ereignisfunktionen ................................................................................................... 351
19.10 Ändern von Datensätzen ........................................................................................ 304
21.7
Positionierung von Widgets ................................................................................... 352
19.11 Löschen von Datensätzen ....................................................................................... 305
21.8
Auswahl- und Eingabe-Widgets ............................................................................ 354
20
Beispielprojekte
309
22
Raspberry Pi
20.1
Lernspiel: Hauptstädte der EU ............................................................................... 309
22.1
Einzelteile und Installation ..................................................................................... 361
20.2
Lernspiel: Kopfrechnen ............................................................................................ 315
20.2.1
20.2.2
20.2.3
20.3
315
319
320
Ausgabe von Morsezeichen .................................................................................... 323
20.3.1
20.3.2
20.3.3
20.4
Das Basisprogramm ..................................................................................
Version mit Zeitmessung .........................................................................
Version mit Highscore-Datei ...................................................................
Textdatei als Datenquelle ........................................................................
Morse-Code auf dem Bildschirm .............................................................
Morse-Code per Lautsprecher .................................................................
22.1.1
22.1.2
324
325
326
22.1.3
22.1.4
22.1.5
22.2
22.3
21
Grafische Benutzeroberflächen mit GTK+
21.1
Datentypen der »Glib« ............................................................................................ 337
21.2
Zeichenketten mit »GString« ................................................................................. 339
21.3
Felder mit GArray ...................................................................................................... 341
21.3.1
21.3.2
21.3.3
21.3.4
21.3.5
21.3.6
21.3.7
21.4
12
Aufbau des Programms ............................................................................
Rahmen des Programms ..........................................................................
Hilfsfunktion zum Einlesen ......................................................................
Ausgabe aller Elemente ............................................................................
Einfügen am Anfang und am Ende .........................................................
Einfügen an beliebiger Position ..............................................................
Löschen eines Elements ...........................................................................
337
341
341
343
344
344
345
346
Die erste Benutzeroberfläche ................................................................................. 347
22.6
Gleichspannungs-Stromkreis ..................................................................
Spannung ist Information ........................................................................
Bauelemente und Ausrüstung ................................................................
Widerstände ..............................................................................................
367
368
368
369
Bibliothek »wiringPi« ................................................................................
373
Leuchtdiode ................................................................................................................ 373
22.4.1
22.4.2
22.4.3
22.4.4
22.5
362
364
Installation ................................................................................................. 365
Update ........................................................................................................ 366
WLAN und Internet ................................................................................... 366
Aufbau des GPIO-Anschlusses ................................................................................ 371
22.3.1
22.4
Einzelteile ...................................................................................................
Zusammenbau ..........................................................................................
Elektronische Schaltungen ..................................................................................... 367
22.2.1
22.2.2
22.2.3
22.2.4
Spiel Mastermind ...................................................................................................... 330
361
Schaltung ...................................................................................................
LED ein- und ausschalten .........................................................................
LED blinken lassen ....................................................................................
LED blinkt Morsezeichen ..........................................................................
374
374
375
376
Taster ........................................................................................................................... 378
22.5.1
Schaltung ...................................................................................................
22.5.2
22.5.3
Einfache Prüfung des Tasters ..................................................................
Verbesserte Prüfung des Tasters .............................................................
378
379
380
Ein Reaktionsspiel ..................................................................................................... 382
22.6.1
22.6.2
Schaltung ...................................................................................................
Programm ..................................................................................................
382
383
13
Inhalt
Anhang
A
Änderungen der Programmierung mit C ............................................................. 389
A.1
A.2
A.3
A.4
A.5
B
Installationen unter Windows ................................................................
Installationen unter Ubuntu Linux .........................................................
Installationen unter OS X .........................................................................
397
405
407
Hilfestellungen und Übersichten .......................................................................... 411
C.1
C.2
C.3
C.4
D
389
389
391
393
393
Installationen ............................................................................................................ 397
B.1
B.2
B.3
C
C-Standards ...............................................................................................
C99, neue Datentypen .............................................................................
C99, erweiterte Deklarationen ................................................................
C99, boolesche Variable ...........................................................................
C11, Überladen von Funktionen ...............................................................
Windows – einige Tastenkombinationen ..............................................
Unix-Befehle ..............................................................................................
Schlüsselwörter der Sprache C ................................................................
Liste der Funktionen .................................................................................
411
411
415
415
Lösungen der Übungsaufgaben ............................................................................. 423
D.1
D.2
D.3
D.4
D.5
D.6
D.7
D.8
D.9
D.10
D.11
D.12
Datei »u_name.c« (Abschnitt 2.6) ...........................................................
Datei »u_daten.c« (Abschnitt 3.7) ...........................................................
Datei »u_fall.c« (Abschnitt 4.5) ................................................................
Datei »u_schleife_for.c« (Abschnitt 5.5) .................................................
Datei »u_schleife_do.c« (Abschnitt 5.6) .................................................
Datei »u_funktion.c« (Abschnitt 6.5) ......................................................
Datei »u_feld.c« (Abschnitt 7.4) ..............................................................
Datei »u_text.c« (Abschnitt 8.6) ..............................................................
Datei »u_zeiger.c« (Abschnitt 9.4) ..........................................................
423
423
424
425
426
427
428
429
430
Datei »u_struktur.c« (Abschnitt 10.7) ..................................................... 432
Datei »u_datei.c« (Abschnitt 11.3) ........................................................... 433
Datei »u_fall_mehrere.c« (Abschnitt 12.2.3) .......................................... 434
Index .......................................................................................................................................... 435
14
Index
Index
- (Vorzeichen) .............................................................. 120
! ........................................................................................... 45
!=......................................................................................... 43
- ........................................................................................... 34
--.................................................................................. 72, 118
#define................................................................... 117, 248
#elif ................................................................................. 251
#else................................................................................ 251
#endif............................................................................. 251
#if..................................................................................... 251
#ifdef .............................................................................. 251
#ifndef ........................................................................... 251
#include .................................................................. 21, 247
$?....................................................................................... 285
% (Modulo) ................................................................... 116
% (SQL) .......................................................................... 298
%=..................................................................................... 120
%[^\n]............................................................................. 176
%c ....................................................................................... 77
%d ................................................................................ 31–32
%e...................................................................................... 112
%errorlevel% ............................................................... 285
%f......................................................................................... 31
%hd................................................................................... 111
%hu................................................................................... 111
%i......................................................................................... 31
%ld .................................................................................... 111
%Le .................................................................................. 391
%Lf ................................................................................... 391
%lf ...................................................................................... 32
%lld......................................................................... 258, 391
%llu.................................................................................. 391
%lu .................................................................................... 111
%o ..................................................................................... 111
%p ............................................................................ 166, 191
%s ....................................................................................... 77
%u ..................................................................................... 111
%X ..................................................................................... 111
%x ..................................................................................... 111
& ....................................................................... 32, 239, 242
&&...................................................................................... 45
* ........................................................................................... 34
* (Zeiger)........................................................................... 84
** (Zeiger auf Zeiger) ................................................. 222
*= ...................................................................................... 120
+ .......................................................................................... 34
++................................................................................ 72, 118
+=...................................................................................... 120
, (Komma-Operator) ................................................. 134
. (Punkt-Operator) ....................................................... 91
. (Verzeichnis)............................................ 262, 265, 412
.. (Verzeichnis)........................................... 262, 265, 412
.c ......................................................................................... 22
.cpp .................................................................................... 22
/........................................................................................... 34
/* */ .................................................................................... 26
//......................................................................................... 26
/= ...................................................................................... 120
: (Bitfeld)........................................................................ 245
< .......................................................................................... 42
< (SQL) ............................................................................ 297
< (umlenken) ............................................................. 200
<<..................................................................................... 240
<=........................................................................................ 43
<= (SQL).......................................................................... 297
<> (SQL).......................................................................... 297
-=....................................................................................... 120
= ................................................................................... 30, 44
= (SQL) ............................................................................ 297
==........................................................................................ 43
->......................................................................................... 98
> .......................................................................................... 42
> (SQL) ............................................................................ 297
> (umlenken) ............................................................. 200
>=........................................................................................ 43
>= (SQL).......................................................................... 297
>>............................................................................ 240, 243
?......................................................................................... 126
 (Ohm)......................................................................... 367
[ ]......................................................................................... 70
\.......................................................................................... 20
\0........................................................................................ 76
\n.................................................................................. 21, 27
^ ....................................................................................... 240
_ (SQL) ........................................................................... 298
__DATE__ ................................................................... 250
435
Index
Index
__FILE__ ...................................................................... 250
__LINE__ ..................................................................... 250
__TIME__ .................................................................... 250
__unix............................................................................ 253
_Generic ........................................................................ 395
_WIN32........................................................................... 253
{ }........................................................................................ 20
| ........................................................................................ 239
|| .......................................................................................... 45
~ ....................................................................................... 240
A
A (Ampere) ................................................................... 367
a (Öffnungsmodus)................................................... 198
abs() ................................................................................. 232
Addition .......................................................................... 34
Adresse............................................................................. 83
Adressoperator ............................................................. 32
Aktueller Parameter ................................................... 65
Ampere .......................................................................... 367
AND ................................................................................. 297
Anführungsstriche
doppelte ............................................................... 20, 27
Anode ............................................................................. 374
Anweisung....................................................................... 21
Anweisungsblock................................ 21, 41, 52, 54, 56
append ........................................................................... 198
Arkuskosinus............................................................... 227
Arkussinus.................................................................... 227
Arkustangens .............................................................. 227
Array ................................................................................ 69
ASC.................................................................................. 303
ASCII-Code............................................................. 167, 171
asctime()....................................................................... 270
atof()................................................................................ 178
atoi()................................................................................ 178
Aufzählung................................................................... 195
Ausgabe .......................................................................... 20
formatierte .................................................... 32, 57, 81
langer Text................................................................. 27
Zahl................................................................................ 31
Zeichenkette.............................................................. 77
Auswertungsrichtung.............................................. 122
auto_increment ........................................................ 290
436
B
Backslash........................................................................ 20
doppelter .................................................................. 262
Bauteil
elektronisches......................................................... 368
Bedingung ........................................................ 41, 54, 124
mehrere....................................................................... 45
Nebenwirkung........................................................ 130
Benutzerdefinierter Datentyp................................ 89
Benutzername pi ....................................................... 365
Betrag ............................................................................. 232
Betriebssystem
Datenaustausch .................................................... 281
Kommando ............................................................. 286
Bibliothek ........................................................................ 21
Binär ............................................................................... 124
Binäre Suche....................................................... 162, 164
Bit..................................................................................... 237
prüfen ........................................................................ 239
schieben .......................................................... 240, 243
setzen........................................................................ 240
Bitfeld ............................................................................. 243
Bit-Operator................................................................. 237
Bitweise Inversion.................................................... 240
Bitweises Exklusiv-Oder ........................................ 240
Bitweises Oder ............................................................ 239
Bitweises Und..................................................... 239, 242
Block ........................................................ 21, 41, 52, 54, 56
Bogenmaß ........................................................... 227, 234
bool ................................................................................. 393
Breadboard.................................................................. 369
break ....................................................................... 130, 135
bsearch()........................................................................ 164
Bubble Sort................................................................... 159
Byte ................................................................................. 237
C
C (Taster) ....................................................................... 379
C++..................................................................................... 22
C11
Entwicklungsumgebung .................................... 394
Überladen ................................................................ 393
C90 ................................................................................. 389
C95 .................................................................................. 389
C99............................................................................ 26, 232
boolesche Variable ............................................... 393
Datentyp.................................................................. 389
Deklaration ............................................................. 391
Programm übersetzen ........................................ 391
cabs()............................................................................... 234
Callback-Funktion ............................................ 348, 351
call-by-reference ........................................... 86, 97, 121
call-by-value............................................................ 86, 97
camelCase ........................................................................ 31
carg() ............................................................................... 234
case .................................................................................. 128
Case Sensitivity ........................................................... 20
Cast-Operator..................................................... 113, 230
cd ................................................................................ 25, 413
ceil()................................................................................ 230
cexp() ............................................................................. 236
char.................................................................... 75, 111, 166
CHAR_MAX.................................................................. 110
CHAR_MIN ................................................................... 110
chdir() ............................................................................. 267
chmod ............................................................................ 261
chmod() ......................................................................... 258
cimag() ........................................................................... 234
clock() ............................................................................. 274
CLOCKS_PER_SEC...................................................... 274
clog() .............................................................................. 236
closedir()........................................................................ 261
Code::Blocks............................................................... 406
Codeseite
umstellen.................................................................... 26
Compiler.................................................................... 16, 23
complex double ......................................................... 234
complex.h..................................................................... 233
conj() .............................................................................. 236
const ................................................................................ 115
continue ........................................................................ 135
cos() ................................................................................. 227
cp ...................................................................................... 414
cpow() ............................................................................ 236
creal() .............................................................................. 234
CREATE TABLE............................................................ 290
csqrt()............................................................................. 236
C-Standard................................................................... 389
CSV-Datei
lesen .......................................................................... 203
schreiben ................................................................ 200
ctime() .................................................................. 256, 270
D
Datei
anhängen an .......................................................... 198
anlegen ..................................................................... 413
CSV................................................................... 200, 203
Eigenschaften......................................................... 255
einbinden ................................................................. 247
erzeugen ...................................................................... 19
feste Datensatzlänge....................... 205, 207, 209
Größe ................................................................ 256, 258
kopieren.................................................................... 414
lesen .................................................................. 105, 198
löschen ............................................................. 266, 414
Modus........................................................................ 256
neu erzeugen ............................................................. 19
öffnen ................................................................. 22, 102
Position..................................................................... 101
schließen............................................................ 22, 103
schreiben ......................................................... 103, 198
sequentielle ............................................................. 101
speichern ..................................................................... 21
umbenennen.................................................. 266, 414
Umlenkung.............................................................. 199
unbekannte Menge lesen................................... 197
verschieben.............................................................. 414
versteckte ................................................................. 413
Zugriff bei OS X ...................................................... 104
Zugriff prüfen ......................................................... 103
Zugriffsrechte ................................................ 256, 258
Zugriffsrechte ändern ............................... 259–260
Zugriffszeitpunkt ......................................... 256, 258
Dateiliste
anzeigen ..................................................................... 25
Dateizeiger ................................................................... 101
Position.................................................................... 207
setzen........................................................................ 207
Daten
austauschen.................................................... 101, 201
speichern .................................................................... 29
Datenbank .................................................................... 287
betroffene Datensätze ........................................ 305
Datensatz................................................................. 287
Datensatz ändern ................................................ 304
Datensatz ausgeben ............................................ 294
Datensatz erzeugen ............................................. 291
Datensatz löschen ................................................ 305
Datensatz sortieren ............................................ 302
437
Index
Index
Datensätze, betroffene ...................................... 305
erzeugen .................................................................. 289
Feld ............................................................................. 287
Feld auswählen ...................................................... 297
Inhalt auswählen .................................................. 293
Primärschlüssel .................................................... 290
Struktur.................................................................... 288
Tabelle ....................................................................... 287
Tabelle erzeugen .................................................. 289
Verbindung öffnen .............................................. 290
Verbindung schließen ......................................... 291
Verbindungszeiger .............................................. 290
Datenfeld ....................................................................... 69
Datensatzlänge
Unix ........................................................................... 207
Windows .................................................................. 207
Datentyp ......................................................................... 29
benutzerdefinierter ................................................ 89
definieren .......................................................... 89, 193
explizit umwandeln .............................................. 113
Genauigkeit............................................................... 111
Glib ............................................................................. 337
Speicherbedarf ...................................................... 109
Umwandlung..................................................... 35–36
Umwandlung, explizite ....................................... 113
Wertebereich.......................................................... 109
Datum ........................................................................... 269
Debian............................................................................ 361
Debugger......................................................................... 16
Debugging ...................................................................... 37
anhalten ..................................................................... 38
Watch hinzufügen .................................................. 39
default ............................................................................ 130
Definition .................................................................... 248
prüfen ......................................................................... 251
Deklaration ..................................................................... 31
im Block .................................................................... 392
mehrere....................................................................... 35
mittendrin................................................................ 392
Variable ..................................................................... 30
Dekrementoperator .................................................. 118
delay()............................................................................. 375
DELETE .......................................................................... 305
Dereferenzierungsoperator..................................... 84
DESC............................................................................... 303
Dev-C++ ............................................................ 16, 19, 397
Projekt anlegen..................................................... 399
438
Dezimalkomma............................................. 32–33, 201
Dezimalpunkt ................................................ 32–33, 201
Dezimalsystem.......................................................... 109
Dezimalzahl zu Dualzahl........................................ 241
digitalRead()................................................................ 380
digitalWrite() ............................................................... 375
DIR ................................................................................... 261
dir....................................................................................... 25
Division ........................................................................... 34
ganze Zahlen .................................................... 36, 113
Rest .............................................................................. 116
do while ........................................................................... 52
double ........................................................................ 31–32
Dualzahl ........................................................................ 239
zu Dezimalzahl ...................................................... 241
Dynamisches Feld ...................................................... 215
E
e (Eulersche Zahl)....................................................... 232
echo................................................................................. 285
Editor.......................................................................... 16, 19
Raspberry Pi ........................................................... 366
Eingabe
falsche ......................................................................... 33
formatierte ...................................................... 107, 175
mehrere Daten ....................................................... 107
Prüfung ....................................................................... 52
Zahl............................................................................... 32
Zeichenkette.............................................................. 78
Eingabepuffer........................................................ 78, 175
Einplatinencomputer .............................................. 361
Einrückung.............................................................. 20, 42
Einzelschritt................................................................... 38
Elektronische Schaltung ................................ 361, 367
Elektronisches Bauteil ............................................ 368
Elektrostatik ............................................................... 364
Element .......................................................................... 69
else..................................................................................... 44
Ende-Zeichen 0............................................. 76, 167, 171
Endlosschleife...................................................... 135, 137
Entwicklungsumgebung .......................................... 16
enum .............................................................................. 195
Enumeration ...................................................... 195, 245
EOF ................................................................................... 175
Ereignis ......................................................................... 348
errorlevel....................................................................... 285
Eulersche Zahl e.......................................................... 232
Exklusiv-Oder
bitweises .................................................................. 240
exp() ................................................................................ 232
Exponentialfunktion ............................................... 232
Exponentialzahl .......................................................... 112
F
f (float)............................................................................. 112
fabs() ............................................................................... 232
Farbcode
Widerstand ............................................................. 369
fclose() ............................................................................ 103
Fehlermeldung ............................................................. 23
Fehlersuche....................................................... 23, 27, 37
Feld ........................................................................... 69, 149
Adresse ........................................................................ 87
an Funktion............................................................... 87
dynamisches ............................................................ 215
Element ....................................................................... 69
Element einfügen .................................................. 154
Element löschen .................................................... 154
GArray ....................................................................... 341
Größe ........................................................................... 70
Größe ermitteln ...................................................... 152
größter Wert............................................................. 153
Initialisierung............................................ 72, 98, 157
kleinster Wert .......................................................... 153
kopieren ..................................................................... 155
mehrdimensional ................................................. 156
mit 0 füllen................................................................ 72
Operationen ............................................................ 150
sortieren.................................................................... 158
Speicher anfordern ....................................... 217–218
Speicher freigeben ................................................ 218
Strukturvariable ...................................................... 94
umdrehen.................................................................. 155
variable Größe ....................................................... 392
von Zeichenketten .................................................. 79
von Zeigern.............................................................. 222
Wert suchen............................................................. 162
zweidimensionales ................................................. 79
zweidimensionales dynamisches .................. 220
Festplatte .............................................................. 101, 197
fflush()............................................................................. 177
fgets()............................................................................... 177
FILE * ............................................................................... 102
float ................................................................................... 111
float.h .............................................................................. 112
floor()............................................................................. 230
fmax()............................................................................. 231
fmin().............................................................................. 231
fmod()............................................................................ 230
fopen()............................................................................ 102
Formaler Parameter ................................................... 65
Formatierung.................................. 32, 57, 81, 178, 270
for-Schleife ..................................................................... 50
Varianten .................................................................. 132
fprintf() ................................................................. 103, 198
free()................................................................................ 218
fscanf() .................................................................. 105, 198
fseek() ............................................................................ 207
ftell()............................................................................... 207
Führende Null ............................................................... 58
Funktion............................................................ 21, 61, 139
Adresse ...................................................................... 146
Adresse übergeben ................................................. 86
aufrufen...................................................................... 63
Datentyp .................................................................... 66
definieren .................................................................... 61
Deklaration ............................................................. 140
mathematische...................................................... 227
Name ........................................................................... 62
Parameter .................................................................. 64
Parameter »const« ................................................ 115
Parameter beliebig............................................... 148
rekursive ........................................................... 145, 263
vordefinierte .............................................................. 61
Werte übergeben..................................................... 64
Zeiger ......................................................................... 146
zum Vergleichen .................................................... 161
Fußgesteuert ................................................................. 52
G
g_array_append_val() ............................................. 345
g_array_free().............................................................. 343
g_array_index().......................................................... 344
g_array_insert_val()................................................ 346
439
Index
Index
g_array_new() ............................................................. 343
g_array_prepend_val()............................................ 345
g_array_remove_index() ...................................... 346
g_object_get() ............................................................ 350
g_object_new() .......................................................... 348
g_object_set()............................................................. 350
g_print()......................................................................... 338
g_signal_connect()........................................... 348, 352
g_string_append().................................................... 340
g_string_assign() ...................................................... 340
g_string_insert() ....................................................... 340
g_string_new()........................................................... 340
g_string_prepend() .................................................. 340
Ganze Zahl ...................................................................... 29
Ganzzahldivision ................................................. 36, 113
GArray ............................................................................ 341
Element einfügen ................................................. 346
Element löschen ................................................... 346
Elementzugriff........................................................ 344
erweitern .................................................................. 345
erzeugen ................................................................... 343
freigeben................................................................... 343
gboolean........................................................................ 338
gchar ............................................................................... 338
gdouble .......................................................................... 338
gedit ............................................................................... 405
General Purpose Input Output 씮 GPIO
getchar().......................................................................... 175
getcwd() ......................................................................... 267
gettimeofday() ............................................................ 274
GID................................................................................... 258
GIMP Toolkit................................................................ 337
gint .................................................................................. 338
Gleich................................................................................ 43
Glib .................................................................................. 337
Datentyp................................................................... 337
Globale Variable .......................................................... 141
gmtime()....................................................................... 270
GNU C-Compiler ....................................... 16, 405, 409
GPIO .............................................................. 363, 368, 371
Ausgang.................................................................... 375
Ein- und Ausgang.................................................. 372
Eingang..................................................................... 378
GND ............................................................................ 372
Pin 1 ............................................................................. 371
Spannungsversorgung........................................ 372
gpointer ......................................................................... 338
Grafische Benutzeroberfläche 씮 GUI
440
Großbuchstaben......................................................... 20
Größer als ....................................................................... 42
Größer als oder gleich................................................ 43
Gruppen-ID .................................................................. 258
GString........................................................................... 339
einfügen................................................................... 340
erweitern ................................................................. 340
erzeugen .................................................................. 340
zuweisen.................................................................. 340
GTK+ ............................................................................... 337
Installation......................................... 404, 407, 409
Programm erzeugen......................... 339, 405, 407
gtk_container_add()................................................ 349
gtk_init() ...................................................................... 348
gtk_layout_put()........................................................ 354
gtk_main()................................................................... 349
gtk_main_quit()........................................................ 349
gtk_widget_show_all() ........................................... 349
GtkButton..................................................................... 352
GtkCheckButton ........................................................ 354
GtkEntry........................................................................ 354
GtkLabel ....................................................................... 348
GtkLayout ..................................................................... 354
GtkRadioButton ......................................................... 354
GtkWindow ................................................................. 348
GUI................................................................................... 347
beenden ........................................................... 347, 349
Button ....................................................................... 352
Eingabefeld.............................................................. 354
Endlosschleife......................................................... 349
Ereignis »changed« .............................................. 357
Ereignis »clicked« ................................ 352, 355, 357
Fenster....................................................................... 348
Kontrollkästchen .................................................. 354
Layout ....................................................................... 352
Radio-Button .......................................................... 354
Radio-Button-Gruppe ......................................... 356
Textausgabe ........................................................... 348
Gültigkeitsbereich...................................................... 141
H
Halbleiter ...................................................................... 373
Hallo Welt ....................................................................... 19
Haltepunkt ..................................................................... 37
Hardware-Ebene ........................................................ 237
HDMI .............................................................................. 363
Header-Datei .................................................................. 21
Hexadezimalsystem................................................ 109
HIGH .............................................................................. 368
hoch ................................................................................ 232
I
I (Strom)......................................................................... 367
I2C .................................................................................... 373
id....................................................................................... 258
IDE...................................................................................... 16
if.......................................................................................... 41
Index................................................................................ 69
Indirektionsoperator ................................................. 84
Inhaltsoperator *........................................... 84, 98, 121
Initialisierung................................................................. 31
Inkrementoperator.................................................... 118
INSERT INTO ............................................................... 292
Installation
für OS X .................................................................... 407
für Ubuntu Linux ................................................. 405
für Windows............................................................ 397
int.......................................................................... 29, 31–32
INT_MAX....................................................................... 110
INT_MIN........................................................................ 110
Inter-Integrated Circuit 씮 I2C
Inversion
bitweise .................................................................... 240
K
Kathode ......................................................................... 374
Klammer
eckige ........................................................................... 70
geschweifte......................................................... 20–21
Vorrang....................................................................... 34
Kleinbuchstaben......................................................... 20
Kleiner als ....................................................................... 42
Kleiner als oder gleich ............................................... 43
Kommandozeile.......................................................... 411
Parameter ................................................................ 281
Rückgabewert......................................................... 283
Kommandozeilenmodus ......................................... 25
Komma-Operator ...................................................... 134
Kommentar ................................................................... 26
einzeiliger................................................................... 26
mehrzeiliger .............................................................. 26
kompilieren ................................................................... 23
Komplexe Zahl ........................................................... 233
Betrag ........................................................................ 234
Exponentialfunktion ........................................... 236
hoch............................................................................ 236
Imaginärteil ............................................................ 234
konjugierte komplexe ......................................... 236
Logarithmus ........................................................... 236
Realteil ...................................................................... 234
Rechenoperationen.............................................. 234
Winkel........................................................................ 234
Wurzel ....................................................................... 236
Komponente ................................................................ 90
Zeiger -> ...................................................................... 98
Konsolenfenster .......................................................... 24
Konstante ..................................................... 115, 117, 248
mehrere..................................................................... 195
vordefinierte ........................................................... 253
Kopfgesteuert ............................................................... 54
Kopfrechnen................................................................. 315
Kosinus.......................................................................... 227
Kosinus Hyperbolicus ............................................. 227
Kreiszahl Pi................................................................... 227
L
LAN-Kabel..................................................................... 363
Laufbedingung .............................................................. 51
Laufzeitfehler ................................................................ 34
Leafpad ......................................................................... 366
LED .................................................................................. 373
anschließen ............................................................. 374
blinken ...................................................................... 375
ein- und ausschalten ........................................... 374
Vorwiderstand ....................................................... 374
Leuchtdiode 씮 LED
LibreOffice Calc .......................................................... 201
Light Emitting Diode 씮 LED
LIKE (SQL)..................................................................... 298
limits.h.......................................................................... 109
Lineare Suche ..................................................... 162–163
-lm.................................................................................... 229
localtime() ................................................................... 270
log() ................................................................................. 232
log10()............................................................................. 232
Logarithmus ................................................................ 232
Logischer Operator ..................................................... 45
Logisches Nicht ............................................................ 45
441
Index
Index
Logisches Oder.............................................................. 45
Nebenwirkung........................................................ 130
Logisches Und............................................................... 45
Nebenwirkung........................................................ 130
Lokale Variable ..................................................... 65, 141
long................................................................................... 111
long double .................................................................. 391
long long .............................................................. 258, 391
LONG_MAX.................................................................. 110
LONG_MIN ................................................................... 110
LOW................................................................................ 368
ls -al ................................................................................. 413
ls -l........................................................................... 258, 412
LXTerminal.................................................................. 366
N
Name
aussagekräftiger ...................................................... 31
Regeln.......................................................................... 30
NC (Taster) .................................................................... 379
New Line........................................................................... 21
New Out Of Box Software 씮 NOOBS
Nicht
logisches ..................................................................... 45
NO (Taster) ................................................................... 379
NOOBS .......................................................................... 364
NOT ................................................................................. 297
NULL ............................................................................... 103
Null
führende ..................................................................... 58
M
M_E.................................................................................. 232
M_PI....................................................................... 227, 232
main() ......................................................................... 21, 61
Parameter ................................................................ 281
Rückgabewert......................................................... 283
Makro ............................................................................ 248
vordefiniertes ........................................................ 250
malloc() .......................................................................... 217
Mastermind ................................................................ 330
math.h............................................................................ 227
Mathematik ................................................................. 227
Maximum..................................................................... 231
Midori............................................................................ 366
MinGW.......................................................................... 399
Minimum...................................................................... 231
mkdir .............................................................................. 413
mkdir() ........................................................................... 267
mktime()........................................................................ 273
modf()............................................................................ 230
Modularisierung .................................................. 61, 142
Modulo-Operator ............................................. 116, 230
Monitor......................................................................... 363
Morse-Code......................................................... 323, 376
MS Excel ........................................................................ 201
Multiplikation............................................................... 34
mv.................................................................................... 414
O
Oder
bitweises ................................................................... 239
logisches ..................................................................... 45
Öffnungsmodus............................. 103, 105, 198, 209
Ohm ................................................................................ 367
Ohmsches Gesetz ...................................................... 367
Oktalsystem................................................................ 109
opendir() ....................................................................... 261
Operator
Auswertungsrichtung .......................................... 122
Bit- .............................................................................. 237
logischer ..................................................................... 45
Priorität ..................................................................... 122
Rechen- ....................................................................... 34
Vergleichs- .................................................................. 41
Verknüpfungs- ......................................................... 45
Vorrang........................................................ 34, 46, 122
OR .................................................................................... 297
ORDER BY .................................................................... 302
OS X
Dateizugriff ............................................................. 104
P
Parameter ....................................................................... 64
aktueller...................................................................... 65
formaler...................................................................... 65
442
Pelles C ................................................................. 394, 403
Peripherie .................................................................... 362
Pfad ändern................................................................ 400
Pi....................................................................................... 227
pi (Benutzername) .................................................... 365
Pi Store.......................................................................... 366
pinMode() ..................................................................... 375
Platzhalter ....................................................... 31–32, 109
Pointer ............................................................................. 83
Postfix-Notation ........................................................ 120
pow() ............................................................................... 232
Präfix-Notation .......................................................... 120
Präprozessor........................................................ 117, 247
PRIMARY KEY ............................................................. 290
printf() ............................................................................. 20
Priorität ......................................................................... 122
Programm
ausführen............................................................ 24–25
binden....................................................................... 402
Code eingeben .......................................................... 19
Entwicklung .............................................................. 36
kopieren ...................................................................... 26
Lesbarkeit............................................................ 20, 42
Startpunkt................................................................... 21
Teil wiederholen ...................................................... 49
übersetzen.................................................................. 23
übersetzen und ausführen .................................. 24
zerlegen....................................................................... 61
Punktoperator . ............................................................ 91
Q
qsort() ............................................................................ 160
Quadratwurzel ............................................................ 232
Quick Sort .................................................................... 160
Raspberry Pi (Forts)
CPU-Informationen .............................................. 371
Ein-Aus-Schalter .................................................... 365
Festplatte ................................................................. 362
Gehäuse .................................................................... 363
Haftung .................................................................... 364
herunterfahren ...................................................... 365
Maus .......................................................................... 363
Modell........................................................................ 362
Neustart.................................................................... 365
Revision .................................................................... 362
Schäden .................................................................... 364
Sicherheit ................................................................. 364
Tastatur .................................................................... 363
Update...................................................................... 366
WLAN........................................................................ 366
raspberrypi.org........................................................... 361
Raspbian........................................................................ 361
installieren............................................................... 365
read ................................................................................. 105
readdir()......................................................................... 261
realloc() .......................................................................... 218
reboot............................................................................. 365
Rechenoperator............................................................ 34
Rechte
Unix.................................................................... 365, 412
Rekursion............................................................. 145, 263
remove()....................................................................... 266
rename()....................................................................... 266
return ....................................................................... 21, 103
rewinddir() ................................................................... 261
rm .................................................................................... 414
rmdir............................................................................... 413
rmdir()............................................................................ 267
round() .......................................................................... 230
Rückgabewert............................................................... 66
rwx................................................................................... 412
R
r (Öffnungsmodus) ................................................... 105
R (Widerstand) ............................................................ 367
r+ (Öffnungsmodus)................................................ 209
rand() .............................................................................. 116
RAND_MAX ................................................................. 116
Raspberry Pi................................................................. 361
Benutzeroberfläche .............................................. 365
Browser .................................................................... 366
S
scanf() ............................................................................... 32
formatiert ................................................................ 107
mehrere Daten ....................................................... 107
Schaltjahr...................................................................... 274
Schaltung
elektronische ................................................. 361, 367
scharfes s.................................................................. 26, 30
443
Index
Index
Schleife..................................................................... 49, 131
abbrechen .......................................................... 49, 135
abwärts ...................................................................... 132
Anzahl bekannt ....................................................... 50
bedingungsgesteuert................................ 49, 52, 54
Endlos-................................................................ 135, 137
fortsetzen .................................................................. 135
fußgesteuerte............................................................ 52
kopfgesteuerte ......................................................... 54
läuft nie..................................................................... 134
mehrfache................................................................. 137
mehrfache, abbrechen ........................................ 138
regelmäßige .............................................................. 49
Zahl mit Nachkommastellen............................. 133
Schleifenvariable .......................................................... 51
doppelte .................................................................... 134
Schlüsselwörter ........................................................... 30
Schnittstelle
seriell.......................................................................... 373
Scope................................................................................ 141
SD-Karte........................................................................ 362
formatieren ............................................................ 364
SEEK_CUR .................................................................... 209
SEEK_END.................................................................... 209
SEEK_SET...................................................................... 209
Semikolon........................................................................ 21
Sequentielle Datei ..................................................... 101
Serial Peripheral Interface 씮 SPI
Serielle Schnittstelle ................................................. 373
short................................................................................. 111
SHRT_MAX................................................................... 110
SHRT_MIN .................................................................... 110
shutdown...................................................................... 365
sin().................................................................................. 227
Sinus ............................................................................... 227
Sinus Hyperbolicus................................................... 227
sizeof...................................................................... 109, 152
Sleep() ............................................................................. 277
sleep() ............................................................................. 277
Sommerzeit ................................................................. 272
Sortieralgorithmus ................................................... 158
Spannung...................................................................... 367
Spannungsquelle ....................................................... 367
Spannungsversorgung ........................................... 368
Speicheradresse............................................................ 83
Speicherbedarf........................................................... 109
Speicherung
dauerhafte ....................................................... 101, 197
444
Speicherzuteilung ...................................................... 217
SPI .................................................................................... 373
Spiel
Lernen....................................................................... 309
Reaktionsfähigkeit ............................................... 382
sprintf().......................................................................... 178
SQL.................................................................................. 288
Befehl ausführen ................................................... 291
logischer Operator ............................................... 297
Vergleichsoperator............................................... 297
SQLite ............................................................................ 288
Ausgabefunktion .................................................. 294
Datentyp ................................................................. 290
Installation......................................... 404, 406, 409
Programm erzeugen................................. 404, 406
Programm übersetzen ........................................ 291
sqlite3 (Struktur) ....................................................... 290
sqlite3_changes() ...................................................... 305
sqlite3_close() ............................................................. 291
sqlite3_exec() .............................................................. 291
sqlite3_open() ............................................................ 290
sqrt()................................................................................ 232
srand() ............................................................................. 116
st_atime ........................................................................ 256
st_mode ........................................................................ 256
st_size............................................................................. 256
Startanweisung ............................................................. 51
startx .............................................................................. 365
Startzuweisung
doppelte.................................................................... 134
stat (Struktur).............................................................. 255
stat() ................................................................................ 255
static ............................................................................... 144
Statische Variable ...................................................... 144
-std=c11.......................................................................... 389
-std=c99 ........................................................................ 389
stdarg.h.......................................................................... 148
stdio.h ............................................................................... 21
stdlib.h ........................................... 116, 158, 162, 178, 217
Steckbrett..................................................................... 369
Steckbrücke................................................................. 369
Steckernetzteil ............................................................ 362
Steuerelement ............................................................ 347
strcat() ............................................................................ 170
strcmp() .......................................................................... 171
strcpy() ............................................................................. 76
strftime() ...................................................................... 270
String ................................................................................ 75
string.h.................................................................... 75, 169
strlen() ............................................................................ 170
Strom.............................................................................. 367
Stromfluss
Richtung ................................................................... 367
Stromkreis .................................................................... 367
schließen................................................................... 378
strstr()............................................................................. 170
strtok()............................................................................ 172
struct....................................................................... 90, 193
struct dirent................................................................. 261
Struktur .................................................................. 89, 192
Definition ................................................................... 89
Feld ............................................................................... 94
in Struktur................................................................ 193
Initialisierung................................................... 91, 195
Variable ..................................................................... 90
Zeiger ........................................................................... 96
Subtraktion .................................................................... 34
Suchalgorithmus ....................................................... 162
Suche
binäre......................................................................... 162
lineare........................................................................ 162
sudo................................................................................. 365
Summe
berechnen.................................................................... 51
switch case.................................................................... 128
Syntaxfehler ........................................................... 23, 34
system() ........................................................................ 286
Systemweiche ............................................................. 252
T
Tabelle
Ausgabe ...................................................................... 57
tan() ................................................................................. 227
Tangens ......................................................................... 227
Tangens Hyperbolicus............................................. 227
Taste
F5 ................................................................................... 38
F6 ................................................................................... 38
F7 ................................................................................... 38
F9 ................................................................................... 23
F10................................................................................. 24
F11 .................................................................................. 24
Tastenkombination
Alt+F4 ........................................................................ 347
AltGr+ .......................................................................... 20
AltGr+{......................................................................... 20
AltGr+}......................................................................... 20
Cmd+. .................................................................. 49, 135
Strg+C .................................................................. 49, 135
Strg+N........................................................................... 19
Strg+O ......................................................................... 22
Strg+S............................................................................ 21
Strg+W......................................................................... 22
Win+E ......................................................................... 411
Win+I .......................................................................... 411
Win+R ................................................................... 25, 411
Win+X ......................................................................... 411
Taster.............................................................................. 378
prüfen ........................................................................ 378
Temperaturkoeffizient
Widerstand ............................................................... 371
Terminal........................................................................ 412
Raspberry Pi ........................................................... 366
Ternär..................................................................... 124, 126
Text ........................................................................... 75, 166
TextWrangler ............................................................. 409
time() ............................................................................. 270
time_t............................................................................ 270
timeval........................................................................... 276
timezone....................................................................... 276
tm.................................................................................... 270
touch.............................................................................. 366
Trigonometrie ............................................................ 227
typedef........................................................................... 193
Typloser Zeiger ............................................................ 114
U
U (Spannung) .............................................................. 367
UART............................................................................... 373
UCHAR_MAX .............................................................. 110
Uhrzeit .......................................................................... 269
UID .................................................................................. 258
UINT_MAX ................................................................... 110
ULONG_MAX .............................................................. 110
Umlaut...................................................................... 26, 30
Unär ....................................................................... 120, 124
445
Index
Index
Und
bitweises .......................................................... 239, 242
logisches ..................................................................... 45
Ungleich .......................................................................... 43
Universal Asynchronous Receiver
Transmitter 씮 UART
Unix
Befehle ........................................................................ 411
neuer Zeitstempel ................................................ 366
unsigned ........................................................................ 111
unsigned char .............................................................. 111
unsigned int.................................................................. 111
unsigned long .............................................................. 111
unsigned long long ................................................... 391
unsigned short............................................................. 111
UPDATE ........................................................................ 304
update ........................................................................... 366
USB ................................................................................. 363
User-ID ........................................................................... 258
USHRT_MAX ............................................................... 110
UTC ................................................................................. 269
V
V (Volt) ........................................................................... 367
va_arg() .......................................................................... 148
va_end()......................................................................... 148
va_list ............................................................................. 148
va_start() ....................................................................... 148
Variable............................................................................ 29
deklarieren................................................................ 30
globale........................................................................ 141
Gültigkeitsbereich.................................................. 141
Initialisierung......................................................... 144
kontrollieren ............................................................. 37
Lebensdauer............................................................ 144
lokale ................................................................... 65, 141
Name........................................................................... 30
sicher einlesen ........................................................ 179
Startwert.................................................................... 30
statische.................................................................... 144
tauschen ................................................................... 120
Vergleichsfunktion ................................................... 161
Vergleichsoperator ..................................................... 41
446
Verzeichnis
aktuelles ................................................................... 412
anlegen ..................................................................... 413
Eigenschaft.............................................................. 255
ermitteln................................................................... 267
erzeugen ................................................................... 267
Hierarchie ................................................................ 412
Inhalt ......................................................................... 412
Inhalt auflisten ...................................................... 261
löschen .............................................................. 267, 413
übergeordnet.......................................................... 412
verstecktes ............................................................... 413
wechseln .................................................... 25, 267, 413
Verzeichnisbaum
Inhalt auflisten ...................................................... 263
Verzweigung.......................................................... 41, 124
Fälle zusammenfassen ....................................... 128
mehrfache................................................................. 127
Präprozessor- ........................................................ 250
void ................................................................................... 62
void *................................................................................ 114
Volt.................................................................................. 367
Vorrang.......................................................................... 122
Vorzeichenlos ............................................................... 111
Vorzeichen-Operator ............................................... 120
W
w (Öffnungsmodus).................................................. 103
Wahrheitswert ...................................................... 41, 124
umdrehen................................................................... 45
Wertebereich.............................................................. 109
while ................................................................................. 54
Whitespace-Zeichen ................................................ 108
Widerstand......................................................... 367, 369
Farbcode.................................................................. 369
Temperaturkoeffizient......................................... 371
Widget............................................................................ 347
anzeigen ................................................................... 349
Container ................................................................. 349
Eigenschaft abrufen............................................. 350
Eigenschaft setzen................................................ 350
erzeugen ................................................................... 348
mit Ereignis verbinden................................ 348, 351
positionieren........................................................... 352
Winkelfunktion .......................................................... 227
wiringPi ......................................................................... 373
Programm erzeugen............................................ 373
wiringPiSetup()........................................................... 375
WLAN............................................................................. 363
konfigurieren ......................................................... 366
Wochentag ................................................................... 272
WPA-TKIP..................................................................... 366
write ................................................................................ 103
Würfel.............................................................................. 118
Wurzel ............................................................................ 232
X
Xcode
Installation............................................................. 407
Z
Zahl
ganze............................................................................ 29
mit Nachkommastellen........................................ 29
runden ....................................................................... 229
umwandeln ............................................................. 229
vorzeichenlose.......................................................... 111
Zeichen ................................................................... 75, 166
Code............................................................................ 167
vergleichen .............................................................. 169
Zeichenkette ......................................................... 75, 166
einfügen.................................................................... 187
Ende.............................................................................. 76
erweitern .................................................................. 170
GString ...................................................................... 339
kopieren ...................................................................... 76
Länge ......................................................................... 170
Operationen ............................................................. 181
rechtsbündige............................................................ 81
sicher einlesen ................................................ 174–175
suchen .............................................................. 170, 189
Teil austauschen ................................................... 188
Teil löschen...................................................... 185, 187
Teil speichern................................................. 184, 186
umwandeln .............................................................. 177
vergleichen ............................................................... 171
zerlegen...................................................................... 172
Zeiger....................................................................... 83, 190
auf Funktion ................................................... 146, 161
auf nichts ................................................................. 103
bei Funktionen ......................................................... 85
Datentyp .................................................................. 190
explizit umwandeln .............................................. 113
rechnen ..................................................................... 165
Strukturvariable...................................................... 96
typloser ...................................................................... 114
Umwandlung, explizite ....................................... 113
Zeigerarithmetik............................................... 165, 190
Zeilenumbruch....................................................... 21, 27
Zeitangabe
erzeugen ................................................................... 273
formatierte ............................................................. 270
Komponenten ....................................................... 270
lokale ........................................................................ 270
Zeitspanne
addieren.................................................................... 274
messen ...................................................................... 274
pausieren.................................................................. 276
Zufallszahlengenerator ............................................ 116
Zuweisung ..................................................................... 30
bedingte.................................................................... 126
Fehlerquelle ............................................................... 44
kombinierte.............................................................. 118
mehrfache................................................................ 120
Wahrheitswert ....................................................... 126
447
Wissen, wie’s geht.
Thomas Theis ist Diplom-Ingenieur für Technische
Informatik und verfügt über langjährige Erfahrung als
EDV-Dozent, unter anderem an der Fachhochschule
Aachen. Er leitet Schulungen zu C/C++, Visual Basic
und zur Webprogrammierung.
Thomas Theis
Einstieg in C
447 Seiten, broschiert, mit CD, Juni 2014
24,90 Euro, ISBN 978-3-8362-2793-3
www.galileo-press.de/3557
Wir hoffen sehr, dass Ihnen diese Leseprobe gefallen hat. Gerne dürfen Sie
diese Leseprobe empfehlen und weitergeben, allerdings nur vollständig mit
allen Seiten. Die vorliegende Leseprobe ist in all ihren Teilen urheberrechtlich geschützt. Alle Nutzungs- und Verwertungsrechte liegen beim Autor
und beim Verlag.
Teilen Sie Ihre Leseerfahrung mit uns!