13,99 €
Mehr erfahren.
- Herausgeber: Wiley-VCH Verlag GmbH & Co. KGaA
- Kategorie: Wissenschaft und neue Technologien
- Serie: ...für Dummies
- Sprache: Deutsch
- Veröffentlichungsjahr: 2017
Für dieses Buch müssen Sie kein Vorwissen mitbringen. Trotzdem werden auch fortgeschrittene C-Themen wie Zeiger und verkettete Listen behandelt - und das alles im aktuellen C11-Standard. Der besondere Clou ist die Verwendung der Programmierumgebung Code::Blocks, die es für Windows-, Mac- und Linux-Betriebssysteme gibt. Zahlreiche Beispiele, viele, viele Übungen und die Programmtexte zum Herunterladen sorgen dafür, dass Sie nach dem Durcharbeiten dieses Buchs über solide Programmiertechniken verfügen. Dann sind Sie bereit für noch mehr: eigene Projekte und das Lernen weiterer Programmiersprachen.
Sie lesen das E-Book in den Legimi-Apps auf:
Seitenzahl: 453
Ähnliche
C programmieren lernen für Dummies
Schummelseite
Bibliografische Information der Deutschen Nationalbibliothek
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.
1. Auflage 2017
© 2017 WILEY-VCH Verlag GmbH & Co. KGaA, Weinheim
Original English language edition Beginning Programming with C For Dummies © 2014 by Wiley Publishing, Inc.All rights reserved including the right of reproduction in whole or in part in any form. This translation published by arrangement with John Wiley and Sons, Inc.
Copyright der englischsprachigen Originalausgabe Beginning Programming with C For Dummies © 2014 by Wiley Publishing, Inc.Alle Rechte vorbehalten inklusive des Rechtes auf Reproduktion im Ganzen oder in Teilen und in jeglicher Form. Diese Übersetzung wird mit Genehmigung von John Wiley and Sons, Inc. publiziert.
Wiley, the Wiley logo, Für Dummies, the Dummies Man logo, and related trademarks and trade dress are trademarks or registered trademarks of John Wiley & Sons, Inc. and/or its affiliates, in the United States and other countries. Used by permission.
Wiley, die Bezeichnung »Für Dummies«, das Dummies-Mann-Logo und darauf bezogene Gestaltungen sind Marken oder eingetragene Marken von John Wiley & Sons, Inc., USA, Deutschland und in anderen Ländern.
Das vorliegende Werk wurde sorgfältig erarbeitet. Dennoch übernehmen Autoren und Verlag für die Richtigkeit von Angaben, Hinweisen und Ratschlägen sowie eventuelle Druckfehler keine Haftung.
Coverfoto: © 3dkombinat - Fotolia.com
Korrektur: Christiane Bils
Satz Mitterweger & Partner, Plankstadt
Print ISBN: 978-3-527-71342-4
ePub ISBN: 978-3-527-80692-8
mobi ISBN: 978-3-527-80693-5
Über den Autor
Dan Gookin schreibt seit mehr als 25 Jahren Technologiebücher. Seine Liebe zum Schreiben ist verbunden mit dem manischen Drang, Bücher zu produzieren, die informativ, unterhaltend und nicht langweilig sind. Mit über 130 Titeln und zwölf Millionen gedruckten Exemplaren in mehr als 30 Sprachen kann Dan überzeugend belegen, dass sein Rezept für das Verfassen von Computerwälzern aufgeht.
Sein vielleicht bekanntestes Buch ist DOS für Dummies, das 1991 veröffentlicht wurde. Es wurde zum weltweit am schnellsten verkauften Computerbuch, von dem einmal mehr Exemplare pro Woche verkauft wurden als vom damaligen New-York-Times-Bestseller (leider konnte das Buch als Ratgeber nicht in die Bestsellerliste aufgenommen werden). DOS für Dummies gab außerdem den Startschuss für die gesamte Für Dummies-Buchreihe, die bis heute ein Phänomen auf dem Buchmarkt ist.
Zu den beliebtesten Titeln von Dan zählen PCs für Dummies und Android Smartphones für Dummies. Er unterhält außerdem die umfangreiche und hilfreiche Website www.wambooli.com.
Dan hat einen Abschluss in Kommunikation/Visuelle Künste von der University of California, San Diego. Er lebt im Nordwesten der USA und genießt es, mit seinen Söhnen Videospiele zu spielen oder in den Wäldern von Idaho herumzustreifen.
Inhaltsverzeichnis
Über den Autor
Einführung
Ist die Sprache C wichtig?
Der Ansatz dieses Buchs
Wie dieses Buch vorgeht
Symbole in diesem Buch
Gedanken zum Schluss
Teil I: Mit der Programmierung in C beginnen
Kapitel 1 Ein schneller Start für die Ungeduldigen
Was Sie zum Programmieren benötigen
Tools zum Programmieren besorgen
Eine Entwicklungsumgebung (HREFE) besorgen
Die IDE Code::Blocks betrachten
Code::Blocks installieren
Eine Reise durch den Arbeitsbereich von Code::Blocks
Ihr erstes Projekt
Ein neues Projekt erstellen
Den Quelltext überprüfen
Das Projekt erstellen und laufen lassen
Speichern und schließen
Kapitel 2 Die Sache mit dem Programmieren
Die Geschichte des Programmierens
Ein Überblick über die frühe Geschichte des Programmierens
Die Einführung der Programmiersprache C
Der Prozess des Programmierens
Das Programmieren verstehen
Quellcode schreiben
In Objektcode verwandeln
Mit der Bibliothek von C verknüpfen
Durchlaufen und testen
Kapitel 3 Die Anatomie von C
Teile der Programmiersprache C
Schlüsselwörter
Funktionen
Operatoren
Variablen und Werte
Anweisungen und Strukturen
Kommentare
Ein typisches Programm in C betrachten
Programmstrukturen in C verstehen
Die Funktion main( ) bestimmen
Etwas an das Betriebssystem zurückgeben
Eine Funktion hinzufügen
Teil II: Das kleine Einmaleins der C-Programmierung
Kapitel 4 Versuch und Irrtum
Zeug auf dem Bildschirm anzeigen
Eine witzige Botschaft anzeigen
Die Funktion puts() einführen
Weiteren Text hinzufügen
Eine Anweisung auskommentieren
Mit Absicht Mist bauen
Mehr Anzeigeblödsinn
Text mithilfe von printf() anzeigen
Die Funktion printf() einführen
Den Zeilenvorschub verstehen
Escape–Sequenzen einsetzen
Nochmal mit Absicht Mist bauen
Kapitel 5 Werte und Konstanten
Ein Treffpunkt für verschiedene Werte
Werte verstehen
Werte mithilfe von printf() anzeigen
Die zusätzlichen Nullen beachten
Der Computer macht die Mathematik
Einfache Arithmetik ins Spiel bringen
Die Sache mit den ganzen Zahlen und den Gleitkommazahlen überdenken
Immer das Gleiche
Den gleichen Wert immer wieder verwenden
Konstanten einführen
Konstanten verwenden
Kapitel 6 Ein Abstellplatz
Werte, die variieren
Ein schnelles Beispiel erstellen
Typen von Variablen einführen
Variablen verwenden
Variabler Wahnsinn
Charakteristischere Variablentypen verwenden
Mehrere Variablen erzeugen
Einen Wert bei der Erzeugung zuordnen
Variablen wiederverwenden
Kapitel 7 Eingabe und Ausgabe
Ein- und Ausgabe von Zeichen
Eingabe- und Ausgabegeräte verstehen
Zeichen mit getchar() abrufen
Die Funktion putchar() verwenden
Mit Zeichen-Variablen arbeiten
Text-Ein- und Ausgabe, aber meistens Eingabe
Strings speichern
Die Funktion scanf() einführen
Einen String mit scanf() lesen
Werte mit scanf() lesen
fgets() zur Texteingabe verwenden
Kapitel 8 Entscheidungsfindung
Was wäre, wenn?
Einen einfachen Vergleich anstellen
Das Schlüsselwort if einführen
Werte auf verschiedene Arten vergleichen
Vergessen, wo das Semikolon stehen muss
Mehrere Entscheidungen
Unübersichtlichere Entschehrefungen fällen
Eine dritte Möglichkeit hinzufügen
Mehrere Vergleiche mithilfe der Logik durchführen
Einen logischen Vergleich erstellen
Einige logische Operatoren hinzufügen
Der alte Trick mit der switch-case-Anweisung
Multiple-Choice-Entschehrefungen treffen
Die switch-case-Struktur verstehen
Keine Pausen einlegen
Das verrückte Werkzeug ?:
Kapitel 9 Schleifen, Schleifen, Schleifen
Ein kleines Déjà–Vu
Der Kick der Schleifen
Etwas x-mal machen
Die Schleife for einführen
Mit der Anweisung for zählen
Buchstabenschleifen durchlaufen
Schleifen verschachteln
Die Freuden der while–Schleife
Eine while–Schleife strukturieren
Die do–while–Schleife verwenden
Und noch mehr zum Thema Schleifen
Endlosschleifen
Endlosschleifen absichtlich verwenden
Aus einer Endlosschleife entkommen
Eine Schleife vermasseln
Kapitel 10 Mit Funktionen Spaß haben
Anatomie einer Funktion
Eine Funktion erstellen
Prototyping (oder nicht)
Funktionen und Variablen
Variablen in Funktionen verwenden
Einen Wert an eine Funktion übergeben
Mehrere Werte zu einer Funktion schicken
Funktionen erzeugen, die Werte zurückgeben
Vorzeitig zurückgeben
Teil III: Auf dem vorhandenen Wissen aufbauen
Kapitel 11 Das unvermeidliche Mathematikkapitel
Mathematische Operatoren außerhalb der Unendlichkeit
Inkrementieren und Dekrementieren
Die Operatoren ++ und – – voranstellen
Den Rest (Modulo) entdecken
Mit Zuweisungsoperatoren Zeit sparen
Der Wahnsinn: Mathematische Funktionen
Gebräuchliche mathematische Funktionen erkunden
Die Trigonometrie erlehrefen
Es ist absolut zufällig
Zufallszahlen ausspucken
Die Zahlen noch zufälliger machen
Die heilige Rangordnung
In die richtige Reihenfolge bringen
Mithilfe von Klammern die Rangordnung ändern
Kapitel 12 Her mit den Arrays
Schauen Sie sich das Array an
Arrays vermehrefen
Arrays verstehen
Initialisierung eines Arrays
Mit char–Arrays (Strings) spielen
Mit leeren char–Arrays arbeiten
Arrays sortieren
Mehrdimensionale Arrays
Ein zwehrefimensionales Array
Mit drehrefimensionalen Arrays ausflippen
Ein initialisiertes mehrdimensionales Array deklarieren
Arrays und Funktionen
Ein Array an eine Funktion übergeben
Eine Funktion gibt ein Array zurück
Kapitel 13 Mit Text Spaß haben
Funktionen zum Verändern von Zeichen
CTYPEs einführen
Zeichen testen
Zeichen ändern
Massenweise Stringfunktionen
Stringfunktionen betrachten
Text vergleichen
Strings erstellen
Mit der Formatierung printf() Spaß haben
Gleitkommazahlen formatieren
Die Ausgabebreite festlegen
Die Ausgabe ausrichten
Sanft den Fluss hinab
Das Flussprinzip veranschaulichen
Mit dem Flussprinzip arbeiten
Kapitel 14 Die multivariablen Strukturen
Hallo Struktur
Die Vielfachvariable einführen
struct verstehen
Eine Struktur füllen
Arrays aus Strukturen erzeugen
Sonderbare Strukturkonzepte
Strukturen in Strukturen packen
Eine Struktur an eine Funktion weitergeben
Kapitel 15 Das Leben in der Kommandoeingabezeile
Ein Bildschirmfenster hervorzaubern
Ein Bildschirmfenster öffnen
Im Textmodus Code starten
Die Argumente der Funktion main()
Die Kommandozeile lesen
Die Argumente von main() verstehen
Zeit zum Aussteigen
Das Programm verlassen
Ein anderes Programm starten
Kapitel 16 Variabler Blödsinn
Variablenkontrolle
Typumwandlung bis zur Ungläubigkeit
Neue Dinge mit typedef erzeugen
Statische Variablen erzeugen
Variablen – Variablen überall
Globale Variablen verwenden
Eine globale Strukturvariable
Kapitel 17 Binärer Wahnsinn
Binäre Grundlagen
Die Zweiheit verstehen
Binäre Werte anzeigen
Die Manipulation von Bits
Den bitweise arbeitenden Operator | verwenden
& bitweise verwenden
Ausschließlich mit dem exklusiven ODER (XOR) arbeiten
Die Operatoren ~ und ! verstehen
Binäre Werte verschieben
Die Funktion binbin() erklären
Viel Freude mit Hex
Teil IV: Für Fortgeschrittene
Kapitel 18 Einführung in Pointer
Das größte Problem bei Pointern
Die Größe des Variablenspeichers abschätzen
Die Speicherung von Variablen verstehen
Die Größe einer Variablen auslesen
Die Adresse einer Variablen überprüfen
Die Informationen zur Speicherung von Variablen zusammenfassen
Das scheußlich komplexe Thema der Pointer
Pointer einführen
Mit Pointern arbeiten
Kapitel 19 Tief im Pointer-Land
Pointer und Arrays
Die Adresse eines Arrays erhalten
Pointer–Mathematik in einem Array
Die Array–Notation durch Pointer ersetzen
Strings sind Pointer–Dinge
Zum Anzeigen eines Strings Pointer verwenden
Einen String durch die Verwendung eines Pointers deklarieren
Ein Array aus Pointern erstellen
Strings sortieren
Pointer in Funktionen
Einen Pointer an eine Funktion weitergeben
Von einer Funktion einen Pointer zurückbekommen
Kapitel 20 Verkettete Listen
Her mit dem Speicher!
Die Funktion malloc() einführen
Strings speichern
Speicherplatz frei geben
Erfassen Sie diese Verkettung
Platz für eine Struktur zuteilen
Eine verkettete Liste erzeugen
Eine verkettete Liste bearbeiten
Eine verkettete Liste speichern
Kapitel 21 Es wird Zeit
Wie spät ist es?
Den Kalender verstehen
Mit der Zeit in C arbeiten
Zeit zu programmieren
Die Uhr kontrollieren
Einen Zeitstempel betrachten
Den Zeitstring aufschnehrefen
Schlummern
Teil V: Und der ganze Rest
Kapitel 22 Dauerhafte Speicherfunktionen
Sequenzieller Dateizugriff
Den Zugriff auf Dateien in C verstehen
Text in eine Datei schreiben
Text aus einer Datei auslesen
Text an eine Datei anhängen
Binäre Daten schreiben
Mit Dateien mit binären Daten arbeiten
Direktzugriffsdateien
Eine Struktur in eine Datei schreiben
Lesen und zurückspulen
Eine bestimmte Aufzeichnung finden
Eine verkettete Liste in einer Datei speichern
Kapitel 23 Verwaltung von Dateien
Verzeichnis–Wahnsinn
Ein Verzeichnis aufrufen
Weitere Informationen über Dateien sammeln
Dateien von Verzeichnissen trennen
Den Verzeichnisbaum erkunden
Rund um Dateien
Eine Datei umbenennen
Eine Datei kopieren
Eine Datei löschen
Kapitel 24 Projekte für Fortgeschrittene und Hartgesottene
Ein aus zahlreichen Modulen bestehendes Monster
Zwei Quelltextdateien verbinden
Variablen, die von mehreren Modulen gemeinsam genutzt werden
Eine benutzerdefinierte Header-Datei erstellen
Mit anderen Bibliotheken verbinden
Chapter 25 Programmfehler raus!
Debugger von Code::Blocks
Die Einstellung Debugging
Der Debugger bei der Arbeit
Einen Haltepunkt markieren
Variablen ansehen
Probleme durch die Verwendung von printf() und puts() lösen
Probleme dokumentieren
Kommentare für Ihr zukünftiges Ich speichern
Verbesserte Fehlermeldungen
Teil VI: Der Top-Ten-Teil
Kapitel 26 Zehn gängige Schnitzer
Bedingungsfehler
Gefährliche Semikolons in Schleifen
Kommata in for-Schleifen
Fehlende Pause in einer switch–Struktur
Fehlende runde und geschweifte Klammern
Beherzigen Sie diese Warnung
Endlosschleifen
Patzer bei scanf()
Fließende Eingabebeschränkungen
Anhang A: ASCII-Codes
Anhang B: Schlüsselwörter
Anhang C: Operatoren
Anhang D: Typen von Variablen
Anhang E: Escape-Sequenzen
Anhang F: Umwandlungszeichen
Anhang G: Rangordnung
Stichwortverzeichnis
Wiley End User License Agreement
Einführung
Sagen Sie »Hallo, Welt« zu C programmieren lernen für Dummies, einem Buch, das Sie von einem wohlmeinenden, einfühlsamen menschlichen Wesen in ein bewundertes Mitglied der Untergrund–Nerd–Subkultur verwandeln wird, dem Programmierer.
Ja, das ist eine tolle Sache.
Wenn Sie lernen in C zu schreiben, werden Sie der unbeschränkte Herrscher über eine Vielzahl elektronischer Spielereien. Sie können Ihre eigenen Programme erstellen und Computern, Tablets und Handys Ihre Launen und Wünsche aufzwingen. Und die Elektronik gehorcht pflichtgetreu. Mit den Informationen aus diesem Buch können Sie den Programmierkurs schaffen, Ihre Freunde beeindrucken, von Hollywood bewundert werden oder selbst eine eigene Software–Firma starten. Sie sehen, Programmieren lernen ist wohlinvestierte Zeit.
Dieses Buch hilft Ihnen zu lernen, wie man verständlich und mit Spaß programmiert. Sie benötigen keine Programmiererfahrung – Sie müssen nicht einmal neue Software erwerben. Alles, was Sie brauchen, ist der Wunsch, in C zu programmieren, und die Fähigkeit, dabei Spaß zu haben.
Ist die Sprache C wichtig?
Im Abstand von wenigen Jahren taucht immer wieder das Argument auf, das Lernen von C führe zu nichts. Es gebe neuere und bessere Programmiersprachen und es sei sehr viel besser, diese zu lernen und seine Zeit nicht mit C zu verschwenden.
Papperlapapp!
In einem gewissen Sinn ist C das Latein der Programmiersprachen. Fast jede neuaufkommende Sprache baut auf der Syntax von C auf. Die Schlüsselwörter von C und selbst bestimmte Funktionen haben ihren Weg in andere Sprachen gefunden, von C++ über Java bis zu Python oder wie die gerade angesagte Sprache auch heißen mag.
Mein Standpunkt ist: Wenn man einmal C gelernt hat, sind all diese anderen Programmiersprachen leicht. In der Tat setzen viele der Bücher, die diese anderen Sprachen lehren, beim Start einige Grundlagen von C voraus. Das kann für jeden Anfänger manchmal frustrierend sein – es sei denn, er kennt C bereits.
Daher ist, egal was die Koryphäen und selbst ernannten Experten auch sagen, C immer noch wichtig. Die Programmierung von Mikrokontrollern, Betriebssystemen und wichtigen Softwarepaketen erfolgt immer noch mit dem guten alten C. Sie verschwenden Ihre Zeit also nicht!
Der Ansatz dieses Buchs
Als Programmierer habe ich mich durch sehr, sehr viele Programmierbücher gequält. Ich weiß ziemlich gut, was ich nicht mehr sehen möchte, aber bedauerlicherweise immer wieder sehe: Der Autor schreibt seitenlange Codes oder prahlt mit seiner Kenntnis, um seine Freak–Freunde zu beeindrucken, nicht aber, um irgendetwas zu lehren. Von diesen Schulungsbüchern gibt es viel zu viele; wahrscheinlich haben Sie aus genau dem Grund dieses Buch gewählt.
Mein Ansatz in diesem Buch ist ziemlich einfach: Kurze Programme. Darstellungen, die den Kern treffen. Viele Beispiele. Sehr viele Übungen.
Der beste Weg, etwas zu lernen, ist es anzuwenden. Jeder in diesem Buch vorgestellte Begriff wird von einem Beispielcode begleitet. Die Programme sind so kurz, dass Sie sie schnell eintippen können – und ich empfehle nachdrücklich, dass Sie dies auch tun. Dann können Sie das Programm erstellen und laufen lassen, um zu sehen, wie es arbeitet. Diese sofortige Rückmeldung ist nicht nur befriedigend, sondern auch ein ausgezeichnetes Mittel zum Lernen.
Falls ich Sie nicht überzeugen konnte: Die Codefiles dieses Buchs finden Sie hier: http://www.wiley–vch.de/publish/dt/books/ISBN3–527–71342–5
Beispielprogramme werden von Übungen abgelöst, die Sie bearbeiten sollten, um Ihre Fähigkeiten zu testen und Ihr Wissen zu erweitern. Mögliche Lösungen der Übungen finden Sie (in englischer Sprache) auf dieser Internetseite: http://www.c–for–dummies.com/begc4d/exercises
Wie dieses Buch vorgeht
Dieses Buch behandelt die Programmiersprache C. Es geht von der Annahme aus, dass Sie nur wenig oder überhaupt nichts über das Programmieren wissen und es endet mit einigen fortgeschrittenen Möglichkeiten der Programmiersprache C.
Um in C zu programmieren, benötigen Sie einen Computer. Für dieses Buch ist es unerheblich, welchen Computer Sie besitzen. Es kann ein Windows–PC sein, ein MacIntosh, aber auch ein Linux–System. Grundlage für die gesamte Programmierung in diesem Buch ist die Installation und Nutzung der integrierten Entwicklungsumgebung (IDE) von Code::Blocks. Die dazu erforderlichen Schritte werden in Kapitel 1 erläutert.
Dieses Buch verliert keine Zeit, Sie gehen schon in Kapitel 1 an den Start. Aber nichts wird ohne eine ausführliche Erläuterung eingeführt, obwohl es aufgrund der Eigenart der Programmierung einige Ausnahmen gibt (diese sind allerdings sorgfältig im Text aufgeführt). Abgesehen davon entwickelt sich der Stoff von Anfang bis zum Ende des Buchs. Dies ist daher auch die beste Art, das Buch zu lesen.
C–Schlüsselwörter und Funktionen sind in einem Monofont gesetzt, wie etwa printf() oder break. Einige Schlüsselwörter, beispielsweise for oder if, können einen Satz sehr komisch klingen lassen; aus diesem Grund werden diese Worte in Monofont gesetzt.
Auch Filenamen erscheinen in Monofont: program.exe.
Wenn Sie etwas eingeben sollen, erscheint der Text ebenfalls in Monofont. Beispielsweise meint »Geben Sie den blorfus–Befehl ein«, dass Sie auf der Tastatur blorfus eingeben sollen. Außerdem werden Sie aufgefordert, wenn Sie drücken sollen (wenn überhaupt).
Programmbeispiele werden als Ausschnitte auf der Seite dargestellt, also beipielsweise:
Sie brauchen ein Beispiel nicht einzutippen, es sei denn, Sie werden dazu aufgefordert.
Vollständige Programmlistings sind in den einzelnen Kapiteln durchnummeriert, wie das folgende Beispiel zeigt:
Listing 1.1: Das Code::Blocks–Gerüst
#include <stdio.h> #include <stdlib.h> int main() { printf("Hello world!\n"); return(0); }
Da die Seitenbreite dieses Buchs begrenzt ist, kann es vorkommen, dass ein Text umbrochen wird und in die nächste Zeile reicht. Sie müssen das bei der Eingabe nicht nachahmen; zudem weise ich Sie jedes Mal auf einen solchen Fall hin.
Die Listings in diesem Buch enthalten keine Zeilennummern, aber vom Code::Blocks–Editor werden sie angegeben (wie auch von den meisten anderen gebräuchlichen Editoren). Im Buch wird auf die Nummern der Zeilen in den Listings Bezug genommen. In diesem Fall sollten Sie die Zeilennummern des Editors verwenden.
Die Übungen sind kapitelweise durchnummeriert. Die dritte Übung in Kapitel 13 heißt dementsprechend Übung 13.3. Im Text werden Sie aufgefordert, bestimmte Übungen zu bearbeiten, beispielsweise:
Übung 1.1: Geben Sie den Quelltext von Listing 1.1 in den Code::Blocks–Editor ein. Speichern Sie ihn unter dem Filenamen ex0101. Erstellen und laufen lassen.
Die Lösungen aller Übungen finden Sie (in englischer Sprache) im Internet:
http://www.c–for–dummies.com/begc4d/exercises
Symbole in diesem Buch
Das Erinnerungs–Symbol kennzeichnet Informationen, die Sie sich merken sollten. Natürlich empfehle ich Ihnen, so viel wie möglich zu behalten, aber den mit diesem Symbol markierten Stoff dürfen Sie auf keinen Fall vergessen.
Dieses Tipp–Symbol enthält eine Empfehlung, einen Trick oder etwas besonders Verrücktes, das Ihnen weiterhilft.
Dieses Symbol kennzeichnet etwas, was Sie unbedingt vermeiden sollten. Es enthält einen Hinweis, der auch ein Tipp–Symbol tragen könnte, aber wenn Sie ihn missachten, hat das hier üble Folgen.
Sehen Sie der Wahrheit ins Auge: Jede Art der Programmierung ist technischer Natur. Ich verwende dieses Symbol für technische Leckerbissen, Nebensächlichkeiten und Anekdoten. Nennen Sie es »Stoff für Nerds«.
Gedanken zum Schluss
Ich liebe es zu programmieren. Es ist ein Hobby, ich empfinde es als ziemlich spannend, frustrierend und bereichernd. Ich gehe davon aus, dass diese Einschätzung nicht nur von einigen wenigen geteilt wird. Natürlich kann es auch sein, dass Sie ein sich quälender Student sind oder Karriere machen möchten. Wie auch immer: Haben Sie Spaß beim Programmieren. Wenn Sie sich das Programm, das Sie auf dem Schirm schreiben wollen, vorstellen können, können Sie es auch realisieren. Das mag länger dauern als Ihnen lieb ist, aber es wird werden.
Bearbeiten Sie bitte die Übungen in diesem Buch. Denken Sie sich neue aus, die das Thema variieren. Arbeiten Sie beständig an diesen Aufgaben, bis Sie sie gelöst haben. Ein faszinierender Aspekt des Programmierens ist, dass es keine einzigartige, allein gültige Lösung gibt, etwas zu realisieren. Immer, wenn Sie üben, lernen Sie etwas.
Falls möglich, suchen Sie sich einen programmierenden Freund, der Ihnen helfen kann. Lassen Sie ihn nicht die Arbeit für Sie machen oder sich erklären, wie es geht, sondern benutzen Sie ihn als eine Quelle. Natürlich kann man Programmieren alleine durchziehen, aber es ist gut, gelegentlich gemeinsam mit jemanden zu leiden, der auch in C programmiert – oder einer anderen Sprache.
Zu diesem Buch gibt es einige begleitende Internetseiten:
Die Lösungen der Übungen finden Sie (in englischer Sprache) auf der folgenden Seite:
http://www.c–for–dummies.com/begc4d/exercises
Um die Codefiles dieses Buchs zu finden, gehen Sie zu:
http://www.wiley–vch.de/publish/dt/books/ISBN3–527–71342–5
Sie können mir auch eine E–Mail senden:
dan@c–for–dummies.com
Ich wäre glücklich, wenn ich von Ihnen hören würde. Natürlich kann ich nicht für Sie die Codes schreiben. Ich kann auch nicht das Stellensystem der Universitäten erklären. Aber wenn Sie irgendwelche Fragen zu diesem Buch haben, können Sie sie mir jederzeit (in englischer Sprache) senden.
Viel Spaß beim Programmieren mit C!
Teil I
Mit der Programmierung in C beginnen
IN DIESEM TEIL…
Mit der Entwicklungsumgebung (IDE) Code::Blocks beginnen
Sich durch Ihr allererstes Programm arbeiten
Lernen, wie das Programmieren funktioniert
Die Bestandteile der Programmiersprache C entdecken
Mithilfe von Code::Blocks das grundlegende Gerüst von C schreiben
Kapitel 1
Ein schneller Start für die Ungeduldigen
IN DIESEM KAPITEL
Die Entwicklungsumgebung (IDE) Code::Blocks herunterladen
Ihr erstes Projekt vorbereiten
Den Code eingeben
Das Projekt und laufen lassen
Sie sind wahrscheinlich begierig darauf, mit dem Programmieren in C zu beginnen. Ich will nicht Ihre Zeit vergeuden.
Was Sie zum Programmieren benötigen
Um Ihren Computer, Ihr Tablet, Ihr Handy, Ihre Spielkonsole oder was auch immer vollständig zu beherrschen, benötigen Sie einige Softwaretools. Die gute Neuigkeit ist, dass zum jetzigen Zeitpunkt, im 21. Jahrhundert, all diese Tools über das Internet frei und einfach verfügbar sind. Sie müssen nur wissen, was erforderlich ist und wo Sie es bekommen.
Tools zum Programmieren besorgen
Die beiden wichtigsten Dinge, die Sie für den Start Ihres Programmierabenteuers benötigen sind:
Ein Computer
Ein Internetzugang
Der Computer ist Ihr wichtigstes Instrument zum Schreiben und Erstellen von Programmen. Sogar wenn Sie nur ein Spiel für die Xbox schreiben, benötigen Sie zum Programmieren einen Computer. Der Computer kann ein PC oder ein Macintosh sein. Er kann mit Windows oder Linux arbeiten.
Der Internetzugang ist notwendig, um die restlichen Programmiertools zu bekommen. Sie benötigen einen Texteditor, um den Code zu schreiben, und einen Compiler, um den Code in ein Programm zu verwandeln. Der Compiler kommt gewöhnlich zusammen mit anderen Tools, die Sie brauchen, wie einem Linker und einem Debugger. All diese Tools finden Sie kostenfrei im Internet.
Flippen Sie nicht aus! Die Begriffe Compiler, Linker und Debugger werden alle in Kapitel 2 erläutert.
Eine Entwicklungsumgebung (IDE) besorgen
Es ist völlig normal, dass Sie Ihre Reise in die Programmierwelt beginnen, indem Sie einen Texteditor, einen Compiler und andere Tools zusammenstellen. Die Verwendung von getrennten Programmen in der Kommandozeile in einem Bildschirmfenster ist die Art, in der ich in grauer Vorzeit das Programmieren gelernt habe. Das ist ein Weg, den man gehen kann, aber er ist etwas altmodisch.
Der geradlinige, professionelle Weg zum Erstellen von Codes besteht heutzutage in der Verwendung einer Integrierten Entwicklungsumgebung (engl. Integrated Development Environment), die von den echten Programmierern IDE genannt wird. Sie verbindet alle Tools, die Sie zum Programmieren benötigen, zu einer kompakten, furchterregenden und einschüchternden Einheit.
Sie verwenden die IDE zum Schreiben von Codes, zum Erstellen von Programmen, zum Auffinden von Fehlern und zur Durchführung aller Arten von Zauberei, obwohl es nostalgisch ist, einen separaten Texteditor oder Compiler zu verwenden. Alle Profis nutzen eine IDE. Das empfehle ich für den Gebrauch in diesem Buch ebenfalls.
Die Beschaffung einer IDE löst unzählige Probleme wie das Einrichten eines Compilers, die Konfigurierung des Texteditors und die Aufgabe, diese verschiedenen Elemente dazu zu bringen, zusammen zu arbeiten. Eine IDE zu haben, ist der beste Weg, um mit dem Programmieren zu beginnen – worauf Sie wahrscheinlich ziemlich scharf sind.
Die IDE Code::Blocks betrachten
Sie werden im Internet mehr als genug IDEs finden und sie sind alle ziemlich gut. Doch um konsistent zu sein, arbeitet dieses Buch mit der IDE Code::Blocks, die unter Windows, Mac OS X und Linux läuft. Sie hat alles, was Sie benötigen.
Wenn Sie bereits eine IDE haben – großartig! Ich bin sicher, dass sie das gleiche wie Code::Blocks kann, obwohl in diesem Buch die Abbildungen und Beispiele, vor allem in den ersten Kapiteln, typisch für Code::Blocks sind.
Code::Blocks installieren
Sie erhalten Code::Blocks im Internet auf folgender Webseite: www.codeblocks.org
Diese Webseite wird sich zweifellos im Verlauf der Zeit ändern, so dass sich die folgenden Schritte zur Installation der IDE etwas ändern können:
1. Verwenden Sie den Webbrowser Ihres Computers, um die Webseite Code::Blocks zu besuchen.
2. Gehen Sie in den Bereich zum Herunterladen.
Laden Sie eine binäre oder lauffähige Version von Code::Blocks herunter. Sie muss für das Betriebssystem Ihres Computers geeignet sein. Suchen Sie außerdem eine Version mit einem C–Compiler, wie etwa dem gebräuchlichen Compiler MinGW.
3. Klicken Sie auf den Link zum Anzeigen der binären oder lauffähigen Installation von Code::Blocks.
Als dieses Buch in den Druck ging, hieß der Link Downl oad t he Binar y Rel ease.
4. Wählen Sie das Betriebssystem Ihres Computers oder scrollen Sie zu dem Teil des Bildschirms, der Optionen für dieses Betriebssystem enthält.
Sie finden Abschnitte (oder Seiten) für Windows, Linux und Mac OS X.
5. Klicken Sie auf den Link, der den für Ihr Betriebssystem geeigneten Compiler und die entsprechende IDE herunterlädt.
Die Version des IDEs und des Compilers für Windows ist folgendermaßen benannt:
codeblocks-xx.yymingw-setup.exe
xx und yy sind dabei Platzhalter für die Nummern der jeweiligen Version des Code::Blocks.
In Linux können Sie je nach Ihrer Linux–Distribution, kurz Distro, die 32– oder die 64–Bit–Version und das von Ihnen gewünschte Dateiformat auswählen. Ich empfehle eine stabile Version.
Die Nutzer von Mac OS X können wählen, ob sie eine .dmg–Datei (Disk–Image–Datei) oder eine herkömmliche Zip–Datei herunterladen wollen.
6. Extrahieren Sie das Code::Blocks–Installationsprogramm aus dem Archiv.
Ungeachtet des Für Dummies–Titels dieses Buches gehe ich davon aus, dass Sie mit .zip, .gz, .dmg und anderen Dateiformaten in dem von Ihnen genutzten Betriebssystem erfolgreich arbeiten können.
7. Starten Sie das Installationsprogramm.
Achten Sie auf die Anweisungen auf dem Bildschirm. Führen Sie eine Standardinstallation durch; Sie müssen zu diesem Zeitpunkt nichts individuell einrichten.
Wenn Sie unter Windows arbeiten, stellen Sie sicher, dass Sie den MinGW–Compiler installieren. Wenn diese Option nicht im Fenster für die Wahl der Komponenten angezeigt wird, haben Sie die falsche Version von Code::Blocks heruntergeladen. Dann gehen Sie zurück zu Schritt 5.
8. Beenden Sie die Installation, indem Sie Code::Blocks laufen lassen.
Auf meinem Bildschirm erschien eine Anzeige, die fragte, ob ich Code::Blocks laufen lassen möchte. Ich klickte auf »Yes«. Wenn Sie diese Abfrage nicht sehen, verwenden Sie das Betriebssystem des Computers, um Code::Blocks so zu starten wie jedes andere Programm auch.
9. Schließen Sie das Fenster zur Installation.
Auch wenn Sie Code::Blocks über den Bildschirm laufen sehen, müssen Sie trotzdem die Installation beenden, indem Sie das Installationsfenster schließen.
Der folgende Abschnitt bietet einen Überblick über die Benutzeroberfläche des Code::Blocks–Programms.
Eine Reise durch den Arbeitsbereich von Code::Blocks
Wenn Code::Blocks noch nicht gestartet ist, schreiten Sie voran, indem Sie es starten. Man startet es wie jedes andere Programm: Gehen Sie zu seinem Icon im Startmenü oder zu dem entsprechenden Icon auf der Bildschirmoberfläche. Dies ist der einfachste Weg zum Starten von Code::Blocks unter Windows 8.
Abbildung 1.1 zeigt den Arbeitsbereich, wie der offizielle Name des gewaltigen Mosaiks aus Fenstern lautet, die Sie auf dem Bildschirm sehen.
Abbildung 1.1 Der Arbeitsbereich von Code::Blocks
Die Einzelheiten in Abbildung 1.1 sind relativ klein, aber Sie sollten die wesentlichen Bereiche kennen, die in der Abbildung angegeben sind:
Symbolleisten (engl. Toolbars): Diese vertrackten Leisten, die mit verschiedenen Kommandozeichen verziert sind, sind am oberen Ende des Code::Blocks–Fensters angeordnet. Es gibt acht Leisten, die Sie umordnen, anzeigen oder verstecken können. Legen Sie sich nicht mit ihnen an, bevor Sie sich mit der Benutzeroberfläche angefreundet haben.
Verwaltung (engl. Management): Das Fenster im linken Bereich des Arbeitsbereichs zeigt vier Reiter (engl. Tabs), obwohl Sie vielleicht nicht alle vier gleichzeitig sehen. Es bietet einem praktische Beaufsichtigung Ihrer Programmierbemühungen.
Statuszeile (engl. Status bar): Am unteren Ende des Bildschirms sehen Sie Informationen über das Projekt, den Editor und über andere Aktivitäten, die in Code::Blocks ablaufen.
Editor: Das große Fenster in dem mittleren und rechten Bereich des Bildschirms ist der Bereich, in dem Sie den Code eingeben.
Protokolldateien (engl. Logs): Im unteren Teil des Bildschirms befindet sich ein Fenster mit sehr vielen Reitern. Jeder Reiter zeigt Informationen über Ihr Programmierprojekt an. Der Reiter, den Sie am häufigsten verwenden, heißt Buil d Log.
Das Menü View kontrolliert die Sichtbarkeit eines jeden in dem Fenster angezeigten Posten. Wählen Sie das dazugehörige Kommando sowie Manager aus dem Menü View, um diesen Posten zu zeigen oder zu verstecken. Kontrollieren Sie die Symbolleisten, indem Sie das Untermenü View|Tool bar s verwenden.
Das Wichtigste, was Sie bei der Benutzeroberfläche von Code::Blocks beachten müssen: Lassen Sie sich nicht von ihr verwirren. Eine IDE wie Code::Blocks kann höchst einschüchternd sein, auch wenn Sie sich als einen erfahrenen Programmierer betrachten. Keine Angst: Sie werden sich schnell zu Hause fühlen.
Vergrößern Sie das Code::Blocks–Fenster, so dass es den gesamten Bildschirm füllt. Sie benötigen all diesen Platz.
Jeder der verschiedenen Bereiche auf dem Bildschirm – Verwaltung, Editor, Protokolldateien – kann in seiner Größe verändert werden: Setzen Sie den Mauszeiger zwischen zwei Bereiche. Wenn sich der Mauszeiger in ein doppelpfeilartiges Etwas verwandelt, können Sie die Maus so ziehen, dass sich die Größe eines Bereichs ändert.
Der Editor und die Protokolldateien weisen gekennzeichnete Benutzeroberflächen auf. Jedes Fenster zeigt viele »Blätter« mit Informationen. Wechseln Sie zwischen den Blättern, indem Sie einen anderen Reiter wählen.
Ihr erstes Projekt
Bei der herkömmlichen Computerprogrammierung verwendete man, voneinander getrennt, einen Texteditor, einen Compiler und einen Linker. Die Eingabeaufforderungszeile (engl. command prompt) wurde benutzt, um die Kommandos zum Editieren, Kompilieren und Linken einzugeben. Es war ein linearer Prozess, und war für kleine Projekte sehr gut geeignet. Mit dem Aufkommen neuer Betriebssysteme und der Programmierung von mobilen Geräten und Spielkonsolen wird diese lineare Methode jedoch höchst ineffizient.
Die moderne IDE besitzt immer noch die Elemente eines Editors, Compilers, Linkers, Debugger und anderer Programmiertools. Sie verfügt über Eigenschaften, die zum Erzeugen von grafischen Programmen und komplexen Projekten erforderlich sind. Daher ist die IDE darauf ausgerichtet, nicht nur mit einzelnen Programmen, sondern mit Projekten zu arbeiten.
In diesem Abschnitt wird der Prozess des Erstellens eines Projekts mit der IDE Code::Blocks erläutert.
Ein neues Projekt erstellen
Die in diesem Buch vorgestellten Beispiele sind ausschließlich Tastaturanwendungen; das bedeutet, dass sie im Textmodus in einem Computerfenster laufen. Meiner Meinung nach ist das der beste Weg zum Lehren von grundlegenden Programmierkonzepten, ohne Sie mit einem großen, komplexen, grafischen Scheusal von Programm zu erschlagen. Auch wenn eine IDE viel leistungsfähiger ist, verwenden sie Sie in diesem Buch, um einfache, tastaturbasierte Programme zu erzeugen. Sie arbeitet folgendermaßen:
1. Starten Sie Code::Blocks.
Sie sehen den Start–Here–Bildschirm, der das Logo von Code::Blocks und einige Links anzeigt. Wenn Sie den Start–Here–Bildschirm nicht sehen, dann wählen Sie File|Close Wor kspace.
2. Klicken Sie auf den Link Create a New Project.
Die in Abbildung 1.2 gezeigte Dialogbox New f r om Templ at e erscheint.
3. Wählen Sie Console Application aus und klicken Sie auf das Feld Go.
Der Tastaturanwendungs-Wizard erscheint.
Sie können eine Markierung bei Skip This Page Next Time machen, um den ersten Schirm des Wizards zu überspringen.
4. Klicken Sie auf das Feld Next.
5. Wählen Sie C als die Sprache aus, die Sie verwenden wollen und klicken Sie dann auf das Feld Next.
C unterscheidet sich stark von C++ – Sie können in der einen Sprache Sachen machen, die in der anderen nicht erlaubt sind.
6. Geben Sie ex0101 als Projekttitel ein.
Wenn Sie den Projekttitel festlegen, wird der Dateiname des Projekts automatisch ausgefüllt.
7. Klicken Sie auf das Browse–Feld rechts in der Textbox mit dem Namen Folder to Create Project In.
Ich empfehle, dass Sie einen gesonderten Ordner für alle Projekte in diesem Buch anlegen.
8. Verwenden Sie das Feld Make New Folder in der Dialogbox Browse for Folder, um einen neuen Projektordner zu erzeugen.
Wenn Sie bereits einen Ordner für Programmierprojekte haben, erzeugen Sie einen neuen Unterordner mit dem Namen BegC4D für die Projekte in diesem Buch. Der Name des Ordners beruht auf dem Titel der amerikanischen Ausgabe dieses Buches Beginning Programming with C For Dummies.
Wenn Sie keinen Ordner für Programmierprojekte im Hauptordner Ihres Benutzerkontos haben, erzeugen Sie einen Unterordner namens prog und dann einen weiteren Ordner namens c. Zum Schluss erzeugen Sie einen Unterordner namens BegC4D und wählen ihn zum Speichern des Projekts.
In meinem Computer, der mit Windows 7 arbeitet, sind die Projekte aus diesem Buch in folgendem Ordner gespeichert:
C:\Users\Dan\prog\c\BegC4D\
9. Klicken Sie auf das Feld OK, um den Ordner auszuwählen, und schließen Sie die Dialogbox.
10. Klicken Sie auf das Feld Next.
Der nächste Bildschirm (der letzte) ermöglicht Ihnen, einen Compiler auszuwählen und zu entscheiden, ob Sie eine Debug– oder eine Veröffentlichungsversion oder beides anlegen wollen.
Die Auswahl des Compilers ist in Ordnung; der Compiler GNU GCC (oder was auch immer in dem Fenster angezeigt wird) ist genau der, den Sie haben wollen.
11. Entfernen Sie das Häkchen an der Zeile Create Debug Configuration.
Sie benötigen diese Konfiguration nur, wenn Sie ein Programmierdilemma beheben müssen (engl. debug), das Ihnen Kopfzerbrechen bereitet. In Kapitel 25 wird diese Situation behandelt.
12. Klicken Sie auf das Feld Finish.
Abbildung 1.2 Hier starten neue Projekte.
Code::Blocks erzeugt ein Gerüst Ihres Projekts, das Sie möglicherweise dennoch nicht im Fenster des Programms sehen. Bei einem einfachen Kommandozeilenprojekt ist das Gerüst eine Quelltextdatei – eine Klartextdatei, die den C–Programmiercode enthält, um Ihnen zu helfen, Ihr Projekt zu starten.
Lesen Sie im folgenden Abschnitt weiter.
Eine Tastaturanwendung ist eine der einfachsten Programme, die Sie erstellen können. Wenn Sie ein Windowsprogramm erstellen, dann erzeugt Code::Blocks andere Elemente für Sie und zeigt Tools zum Entwerfen des Fensters, zum Erstellen eines Icons und zum Arbeiten mit anderem erforderlichen Krimskrams an. Die IDE macht es leicht, mit all diesen Dingen zu arbeiten.
Den Quelltext überprüfen
Wenn Code::Blocks ein neues Projekt hervorzaubert, erzeugt es eine Handvoll grundlegender Elemente, damit Sie anfangen können. Bei einer Tastaturanwendung beinhaltet dies nur ein Element: Die Quelltextdatei main.c.
Eine Quelltextdatei ist eine Klartextdatei, die den Programmiercode enthält. In Kapitel 2 werden die Einzelheiten erläutert, doch im Moment reicht es aus zu wissen, dass Code::Blocks diese Datei jedes Mal automatisch erzeugt, wenn Sie ein neues Projekt starten. Es gibt Ihnen sogar einen Mustercode vor, mit dem Sie starten können, obwohl Sie meistens das Gerüst löschen und von vorn anfangen, indem Sie Ihren eigenen Code schreiben.
Projekte in der IDE werden in dem Kasten Management auf der linken Seite des Bildschirms (siehe Abbildung 1.1) aufgelistet. Wenn Sie diesen Kasten nicht sehen, drücken Sie + auf der Tastatur oder wählen Sie View|Manager aus dem Menü aus.
Abbildung 1.3 zeigt den Managementkasten mit dem ausgewählten Projektreiter. Das derzeitige Projekt ist geöffnet, aber Sie können auch andere Projekte sehen.
Abbildung 1.3 Projekte in der IDE
Bei einem neuen Tastaturanwendungsprojekt wird die Quelltextdatei main.c genannt. Sie wird in dem Quellordner des Projekts gespeichert. Wenn Sie die Quelltextdatei nicht sehen (siehe Abbildung 1.3), dann öffnen Sie den Quellordner, um ihn anzuzeigen.
Machen Sie einen Doppelklick auf das Element main.c im Quellordner, um die Datei im Editorfenster zu öffnen. Das vorgeschriebene Codegerüst wird in Listing 1.1 angezeigt. Es handelt sich um einen richtigen Code für ein reales Programm in C, welches Sie erstellen können, wie im nächsten Abschnitt erläutert wird.
Listing 1.1: Das Code::Blocks–Gerüst
#include <stdio.h> #include <stdilib.h> int main() { printf("Hello world!\n"); return 0; }
In Kapitel 2 werden die Einzelheiten zu Listing 1.1 erläutert. Im Moment können Sie den farbenprächtigen Text und die schöne Formatierung bewundern.
Das Editorfenster zeigt Zeilennummern an. Wenn Sie sie nicht sehen, wählen Sie Edit|Edit or T weaks|Show Line Number s. In diesem Buch wird davon ausgegangen, dass Sie die Zeilennummern sehen können, um Bezug darauf nehmen zu können.
Die Zeilennummern sind kein Teil des C–Codes. Sie werden zum Bearbeiten benutzt; aber auch wenn Fehler auftreten, beziehen sich die Angaben auf die Zeilennummern in dem Code.
Sie können den Einzug des Tabulators festlegen, indem Sie Edit |Edit or T weaks|Tab Size auswählen und dann die Größe wählen. Ich bevorzuge vier Leerzeichen pro Einzug.
Der Farbton des Textes wird mithilfe von Edit |Highl ight Mode|C/C++ festgelegt. Um die Hervorhebungen zu entfernen, wählen Sie das Element Pl ain Text aus dem Untermenü Highl ight Mode aus. (Es ist dort das erste Element.)
Das Projekt erstellen und laufen lassen
Um ein Programm in Code::Blocks zu erzeugen, müssen Sie das Projekt erstellen. Dieser einzelne Schritt bedingt verschiedene Dinge; ich vermeide es allerdings, die Einzelheiten vor Kapitel 2 zu diskutieren. Wenn Sie bereits Ihr erstes Projekt ex0101 begonnen haben, es geöffnet ist und in Code::Blocks angezeigt wird, sind Sie so weit, dass Sie es erstellen können. Beachten Sie folgende Schritte:
1. Stellen Sie sicher, dass das Projekt, das Sie erstellen wollen, im Managementfenster aktiviert ist.
Aktivierte Projekte erscheinen in Fettdruck. Wenn mehr als ein Projekt im Projektfenster angezeigt wird, aktivieren Sie dasjenige, mit dem Sie arbeiten wollen, indem Sie mit der rechten Maustaste den Projektnamen anklicken (über den Code::Blocks–Icon) und das Kommando Act ivat e Pr oject wählen.
2. Wählen Sie Build|Build aus dem Menü.
Der Reiter Buil d Log in der Protokolldatei zeigt die Ergebnisse des Erstellen eines Projektes an. Sie sehen dort einige Zeilen Text; die Einzelheiten dazu werden in Kapitel 2 erläutert.
Da Sie sich nicht in das Quelltextgerüst eingemischt haben, wird das Projekt ohne Fehler übersetzt; Sie sehen den Text im Überblick, der null Fehler und null Warnungen anzeigt. Gut. Wenn Fehler auftreten, was häufig genug passiert, machen Sie sich daran, sie zu beheben. Die Fehlermeldungen helfen in dieser Hinsicht; dieses Thema wird in Kapitel 3 erläutert.
Das Erstellen eines Projekts ist aber nur die halbe Arbeit. Die andere Hälfte besteht im Laufenlassen des Projekts, also das Ausführen des fertiggestellten Programms innerhalb der IDE.
Um das aktuelle Projekt laufen zu lassen. wählen Sie Build|Run aus dem Menü. Sie sehen, dass das Bildschirmfenster erscheint und die Ausgaben des Programms sowie etwas überflüssiger Text aufgelistet sind, wie in Abbildung 1.4 gezeigt.
Abbildung 1.4 Laufenlassen eines Programms
Drücken Sie , um das Eingabeaufforderungsfenster zu schließen.
Und nun der Clue: Sie können ein Projekt erstellen und laufen lassen mithilfe eines einzigen Befehls: Wählen Sie Buil d|Buil d and Run.
Die Tastenkombinationen für Buil d, Run und Buil d and Run sind + , + und . Es ist aber nicht nötig, sich diese Abkürzungen zu merken – sie sind im Menü aufgelistet.
Befehlsfelder zum Erstellen und Ausführen eines Projekts befinden sich in der Symbolleiste des Compilers. Sie finden ein gelbes Getriebe–Icon für Buil d, einen grünen Pfeil für Run und eine Kombination aus beiden für den Befehl Buil d and Run.
Die Ausgabe des Programms erscheint im oberen Teil des Eingabeaufforderungsfensters (siehe Abbildung 1.4). Die letzten beiden Zeilen werden von der IDE erzeugt, wenn das Programm läuft. Der Text enthält einen Wert, der vom Programm an das Betriebssystem zurückgegeben wird, eine null und die Angabe, wie lange das Programm läuft (9 Milli-sekunden). Die Anzeige Press any key to continue besagt, dass Sie mit das Fenster schließen können.
Speichern und schließen
Wenn Sie ein Projekt erstellt haben oder eine kleine Änderung vorgenommen haben, sollten Sie speichern. In einer IDE müssen Sie allerdings verschiedene Dinge speichern, etwa die Quelltextdatei, den Arbeitsbereich und das Projekt. Befehle zum Speichern dieser verschiedenen Punkte finden Sie in dem Menü Fil e.
Ein praktischer Weg, um alles auf einmal zu speichern, ist die Verwendung des Befehls Save Ever yt hing. Diesen Befehl finden Sie in dem Menü Fil e, die praktische Abkürzung auf der Tastatur ist + + (oder + + bei einem Macintosh).
Wenn Sie das Projekt bisher noch nicht gespeichert haben, machen Sie es jetzt.
Sie können das aktuelle Projekt auch schließen, wenn Sie Fil e|Cl ose Pr oject wählen.
Verlassen Sie Code::Blocks, wenn Sie eine Pause einlegen möchten.
Keine Sorge! Code::Blocks ermahnt Sie, wenn Dateien oder Projekte noch ungespeichert sind. Speichern, dann schließen.
Wenn der Befehl Save Ever yt hing nicht verfügbar ist, gehen Sie davon aus, dass alles in Ordnung und bereits gespeichert ist.
Der Standardbefehl zum Speichern in Code::Blocks – entweder Fil e|Save oder + – wird verwendet, um Dateien wie Ihre Quelltextdatei in der Sprache C zu speichern. Ich empfehle Ihnen dringend, Ihre Quelltextdateien zu speichern, wenn Sie sie bearbeitet haben.
Verwendung der Man–Seiten
Ein Fenster des Arbeitsbereichs von Code::Blocks trägt den Namen Man/Html Pages Viewer. Es ist der Link zur Dokumentation der Bibliothek von C. Man ist die Kurzform von Manual. Das Fenster können Sie ansehen, indem Sie View|Man Pages Viewer auswählen.
Um den Man Pages Viewer zu verwenden, geben Sie ein Schlüs-selwort oder eine Funktion der Sprache C in das Textfeld ein. Klicken Sie in das Feld Sear ch oder drücken Sie , um die gegebenen Elemente anzuschauen. Haben Sie Geduld; manchmal dauert es etwas, bis die Information zugänglich ist.
Wenn Man Pages Viewer die Man–Seiten nicht finden kann, können Sie im Internet nach der C–Funktionsdokumentation suchen. Ich empfehle folgende Seiten:
http://man7.org/linux/man-pages/dir_section_2.html http://man7.org/linux/man-pages/dir_section_3.htmlDie Funktionen in C, auf die in diesem Buch verwiesen wird, findet man auf der Man–Seite 2 oder der Man–Seite 3; sie sind mit den beiden Seiten verlinkt, die gerade angegeben wurden.
Wenn Sie ein Betriebssystem des Typs Unix haben, können Sie ein Bildschirmfenster aufrufen und den Befehl man verwenden, um Funktionsdokumente durchzusehen; zum Beispiel:
man rand
Dieser Befehl zeigt Informationen über die Funktion rand ( ) an.
Kapitel 2
Die Sache mit dem Programmieren
IN DIESEM KAPITEL
Die Geschichte des Programmierens verstehen
Quelltext erzeugen und in Objektcode verwandeln
Mithilfe des Linkers ein Programm erzeugen
Das endgültige Programm testen
Es wird Programmieren genannt, auch wenn es die echten Programmierer unter dem Wort Codieren kennen – der Prozess, bei dem ein Mensch Informationen schreibt, die manchmal einem kryptischen Englisch ähneln, die dann irgendwie in Anweisungen für ein elektronisches Dingsbums übersetzt werden. Am Ende verleiht diese stille und einsame Kunst Personen die Macht, die Elektronik zu kontrollieren. Das ist eine großartige Sache. Das ist das Programmieren.
Die Geschichte des Programmierens
Es gibt nur wenige Bücher über das Programmieren, in denen die aufregende, dramatische Geschichte des Programmierens nicht beschrieben wird. Für mich als Programmierer ist es schwierig, nicht darüber zu schreiben; meiner Begeisterung lasse ich auch auf Cocktailpartys immer freien Lauf. Betrachten Sie diesen Abschnitt also als freiwilligen Lesestoff, obwohl ein Überblick darüber, was das Programmieren früher war und was es heute ist, Ihnen helfen kann, diese Kunstform besser zu verstehen.
Kurz gesagt ist Programmieren der Prozess, einem Ding zu sagen, was es machen soll. Dieses Dingsbums ist die Hardware; das Programm ist die Software.
Ein Überblick über die frühe Geschichte des Programmierens
Das erste zu programmierende Dingsbums war die analytische Maschine (engl. Analytical Engine) von Charles Babbage im Jahr 1822. Die Programmierung erfolgte durch die physische Änderung der Werte, die durch eine Säule aus Zahnrädern dargestellt wurden. Die Maschine sollte dann das Ergebnis irgendeiner langweiligen, komplexen, mathematischen Gleichung berechnen.
In den Jahren nach 1940 wurden frühe elektronische Computer auf ähnliche Weise wie die analytische Maschine von Babbage programmiert. Ein wesentlicher Unterschied war, dass statt dem Umordnen von Zahnrädern eher Anweisungen festverdrahtet in den elektronischen Schaltkreis eingegeben wurden. »Programmierung« bedeutete größtenteils »Neuverdrahtung«.
Mit der Zeit wurde die Arbeit des Neuverdrahtens durch Reihen von Schaltern ersetzt. Die Anweisungen für den Computer wurden durch das Umlegen der Schalter in einer bestimmten Weise eingegeben.
Professor John von Neumann bereitete in den Jahren nach 1950 der modernen Programmierung von Computern den Weg. Er führte das Fällen von Entscheidungen in den Prozess ein, sodass Computer eine wenn–dann–Wahl treffen können. Professor von Neumann entwickelte auch das Konzept der Wiederholungsschleife und des Unterprogramms.
Es war Admiral Grace Hopper, die den ersten Compiler entwickelte, also ein Programm, das andere Programme erzeugt. Ihr Compiler nahm Wörter und Redewendungen in Englisch auf und wandelte sie in einen Code um. Somit war die Programmiersprache geboren.
Die erste bedeutende Programmiersprache in den 50er Jahren des letzten Jahrhunderts war FORTRAN. Der Name stammt von Formula Translator. Andere Programmiersprachen aus dieser Zeit sind unter anderen COBOL, Algol, Pascal und BASIC.
Unabhängig davon, ob man Schaltkreise neuverdrahtet, Schalter kippt oder in einer Programmiersprache schreibt, das Ergebnis ist das gleiche: Man sagt der Hardware, dass sie etwas machen soll.
Die Einführung der Programmiersprache C
Die Programmiersprache C wurde 1972 in den AT&T Bell Labs von Dennis Ritchie entwickelt. Sie kombiniert Elemente der Sprachen B und BCPL, aber auch etwas Pascal steckt darin. Mr. Ritchie verwendete zusammen mit Brian Kernighan C, um das Betriebssystem Unix zu entwickeln. Ein C–Compiler war seither ein Teil dieses Betriebssystems.
In den frühen 80er Jahren des letzten Jahrhunderts verwendete Bjarne Stoustroup C als Grundlage der objektorientierten Programmiersprache C++. Der ++ (plus–plus)–Teil des Namens ist gewissermaßen ein Insiderwitz, den Sie besser verstehen werden, wenn Sie Kapitel 11 gelesen haben.Das Ziel von Mr. Stoustroup war, dass C++ der Nachfolger von C wird. In mancher Hinsicht ist das der Fall, auch wenn C weiterhin beliebt ist.
Die Programmiersprache D wurde im Jahr 2000 eingeführt. Sie ist nicht so bekannt wie C++ und hat nur optisch Ähnlichkeit mit C. Trotzdem deutet der Name D darauf hin, dass es die nächste Sprache nach C ist. Oder in diesem Fall nach C++.
Die Programmiersprache B, auf der C basiert, wurde nach dem B in dem Wort Bell Labs benannt.
BCPL steht für Basic Combined Programming Language.
Die Programmiersprache C++ hat ziemlich viel Ähnlichkeit mit C, aber sie ist nicht bloß eine Erweiterung oder ein Zusatz. Es ist einfacher, C++ zu lernen, wenn man C kennt, aber es ist nicht einfach, zwischen beiden Sprachen hin und her zu wechseln.
Unglücklicherweise habe ich keine Idee, wie man »Bjarne Stoustroup« ausspricht.
Der Prozess des Programmierens
Unabhängig davon, was Sie programmieren oder welche Sprache Sie verwenden: Bestimmte Schritte in dem Prozess sind stets die gleichen. Dieser Abschnitt bietet Ihnen einen Überblick darüber.
Das Programmieren verstehen
Der Zweck des Programmierens ist, eine Sprache zu wählen und verschiedene Instrumente zu nutzen, um ein Programm zu erstellen. Die Sprache ist C, die Instrumente sind Editor, Compiler und Linker – oder eine IDE, die alle drei verknüpft. Das Endergebnis ist ein Programm, das die Hardware so steuert, dass sie etwas macht. Bei dieser Hardware kann es sich um einen Computer, ein Tablet, ein Telefon, einen Mikrocontroller oder was auch immer handeln.
Beim Prozess des Programmierens geht man Schritt für Schritt vor:
1. Man schreibt den Quellcode.
2. Man übersetzt (kompiliert) den Quellcode in Objektcode.
3. Man verbindet den Objektcode mit Bibliotheken, um ein Programm zu erstellen.
4. Man lässt das Programm laufen und testet es.
Nehmen Sie sich einen Moment Zeit, um diesen Prozess zu verinnerlichen: schreiben, übersetzen, verbinden, laufen lassen. Der Mensch schreibt einen Quellcode. Der Quellcode wird in Objektcode übersetzt. Der Objektcode wird mit einer C–Bibliothek verknüpft, um ein Programm zu erzeugen. Dann, endlich, läuft das Programm.
In der Realität läuft es eher folgendermaßen ab:
1. Man schreibt den Quellcode.
2. Man übersetzt den Quellcode in Objektcode.
3. Man behebt Fehler und wiederholt die Schritte 1 und 2.
4. Man verknüpft den Objektcode mit Bibliotheken, um das Programm zu erzeugen.
5. Man behebt Fehler und wiederholt die Schritte 1 bis 4.
6. Man lässt das Programm laufen und testet es.
7. Man behebt Programmfehler (engl. Bug Fixing), indem man den gesamten Prozess wiederholt.
Oder, was häufiger vorkommt: Das Programm läuft gut, doch Sie möchten eine Funktion hinzufügen oder ein Element weiterentwickeln. Dann wiederholt man alles.
Hoffentlich sind die Schritte 3, 5 und 7 nicht allzu häufig notwendig. Trotzdem müssen Sie in einem Programmierkreislauf häufig Fehler beheben.
Die guten Neuigkeiten bestehen darin, dass der Computer brav die Fehler meldet und Ihnen sogar zeigt, wo sie sind. Das ist besser als einen Fehler in kilometerlangen Drähten, wie zur Zeit des ENIAC (Electronic Numerical Integrator and Computer), aufzuspüren.
Wenn Sie eine IDE verwenden, werden die Schritte des Übersetzens und Verbindens durch den Befehl Buil d ausgeführt. Die Schritte Übersetzen, Verbinden und Laufen lassen werden durch den Befehl Buil d and Run ausgelöst. Ungeachtet des Ausdrucks Build übersetzt die IDE Objektcode, verbindet Bibliotheken und erstellt ein endgültiges Programm.
Einer meiner Freunde, der professionell programmiert, schlug vor, dass diese Kunstform Debugging (engl. für Fehlerbehebung) statt Programmierung heißen sollte.
Die Legende besagt, dass der erste Computerfehler (engl. Computer Bug) buchstäblich ein Insekt war, das Grace Hopper in der Verdrahtung eines frühen Computers fand. Es gibt aber einige Zweifel an dieser Legende, vor allem, wenn man bedenkt, dass das englische Wort bug (dt. Insekt) schon seit Shakespeares Zeiten verwendet wird, um etwas Skurriles oder Seltsames zu beschreiben.
Quellcode schreiben
Der Quellcode (oder Quelltext) verkörpert den Teil des Prozesses, der die Programmiersprache selber enthält. Sie verwenden einen Texteditor zum Schreiben einer Quelltextdatei.
In diesem Buch wird der Quellcode in Listings angegeben, wie das Beispiel in Listing 2.1 zeigt.
Listing 2.1: Das Standardprogramm »Hello World«
#include <stdio.h> int main() { puts("Sei gegrüßt, Mensch."); return 0; }
Zeilenzahlen werden in den Listings nicht angezeigt, da es Sie verwirren könnte. Außerdem werden Zeilennummern im Editor angegeben, wenn Sie es eingeben.
Jetzt sollten Sie den Quelltext aus einem Listing als Teil einer Aufgabe eingeben, zum Beispiel:
Übung 2.1: Starten Sie ein neues Projekt in Code::Blocks. Nennen Sie das Projekt ex0201.
Führen Sie es aus: Erfüllen Sie Übung 2.1 und starten Sie gemäß der folgenden Schritte ein neues Projekt namens ex0201 in Code::Blocks:
1.Erzeugen Sie in Code::Blocks eine neue Tastaturanwendung, ein C–Projekt namensex0201.
Lesen Sie in Kapitel 1 nach, wenn Sie diesen Schritt absolut nicht verstehen.
2.Geben Sie den Code aus Listing 2.1 in den Editor ein.
Sie können das von Code::Blocks gegebene Gerüst löschen oder es einfach so bearbeiten, dass das Ergebnis mit Listing 2.1 übereinstimmt.
3. Speichern Sie die Quelltextdatei, indem Sie den Befehl File|Save File auswählen.
Da haben Sie es. Sie haben gerade den ersten Schritt im Prozess des Programmierens beendet – das Schreiben des Quellcodes. Im nächsten Abschnitt setzen Sie Ihre Reise mithilfe des Compilers fort.
Alle C–Quelltextdateien enden mit der Dateinamenserweiterung (Extension) .c (»dot–see«).
Wenn Sie Windows verwenden, empfehle ich, dass Sie die Einstellungen des Ordners so wählen, dass die Dateinamenserweiterung angezeigt wird.
In C++ haben die Quelltextdateien die Erweiterung .cpp (»dot–see–pee–pee«). Ich sollte es unterlassen, hier einen kindischen Witz zu bringen.
Quelltextdateien werden genauso benannt wie alle anderen Dateien auf einem Computer auch. Gewöhnlich hat ein kleines Programm den gleichen Quelltextdateinamen wie das endgültige Programm. Wenn Ihr Programm puzzle heißt, dann heißt der Quelltext puzzle.c. Der Dateiname main.c wird von Code::Blocks verwendet, doch er muss nicht unbedingt main.c lauten.
In Code::Blocks ist der endgültige Dateiname der gleiche wie der Name des Projekts, so dass eine Änderung des Quelltextdateinamens nicht wichtig ist.
In Objektcode verwandeln
Ein Compiler ist ein Programm, das Text aus einer Quelltextdatei liest und diesen Text – eine Programmiersprache – in etwas übersetzt, das Objektcode genannt wird. In C bearbeitet der Compiler auch spezielle Instruktionen, die Präprozessordirektiven genannt werden.
Listing 2.1 enthält beispielsweise folgende Präprozessordirektive:
#include <stdio.h>
Die Direktive include weist den Compiler an, die Header–Datei stdio.h ausfindig zu machen. Die Inhalte dieser Datei werden dem Quelltext hinzugefügt; anschließend werden beide durch den Compiler in eine Objektcodedatei verwandelt. Die Objektcodedatei hat den gleichen Namen wie die Quelltextdatei, aber mit der Dateinamenerweiterung .o (»dot–oh«).
Wenn der Compiler Ihren C–Code in Objektcode übersetzt, überprüft er ihn auf gängige Fehler, fehlende Elemente und andere Aspekte. Wenn etwas falsch ist, zeigt der Compiler eine Fehlerliste an. Um die Fehler zu beheben, überarbeiten Sie den Quellcode und probieren Sie erneut, den Text zu übersetzen.
Fahren Sie mit Übung 2.1 fort: In Code::Blocks erfolgt das Übersetzen durch folgenden Schritt:
4.Choose Build|Compile Current File.
Das Fenster Buil d Log zeigt die Ergebnisse an, die keine Fehler und keine Warnungen enthalten. Gut, aber wenn Sie sich vertippt haben, dann überprüfen Sie Ihren Quelltext anhand von Listing 2.1 im vorangegangenem Abschnitt.
Normalerweise würden Sie an dieser Stelle, wie in Kapitel 1 erläutert, den Befehl Buil d wählen. Aber wenn Sie nur umwandeln wollen, verwenden Sie den Befehl Compil e Cur r ent Fil e.
Bei Erfolg erzeugt der Compiler eine Objektcodedatei. Da die Quellcodedatei main.c heißt, heißt die Objektcodedatei main.o.
In Code::Blocks findet man die Objektcodedatei im Projektordner innerhalb der Unterordner obj/Release oder obj/Debug.
Mit der Bibliothek von C verknüpfen
Der Linker ist das Werkzeug, das das endgültige Programm erzeugt. Er macht das, indem er die Objektcodedatei mit den Bibliotheken der Programmiersprache C verbindet. Die Bibliotheken enthalten die aktuellen Instruktionen, die dem Computer (oder einem anderen Gerät) sagen, was zu machen ist. Diese Instruktionen werden auf der Grundlage der Kurzschriftanweisungen ausgewählt und ausgeführt, die im Objektcode enthalten sind.
In Listing 2.1 steht beispielsweise das Wort puts. Dieses Wort ist in C eine Funktion, die in diesem Text in der Form puts() geschrieben wird. Sie steht für put string.
Der Compiler übersetzt puts() in ein Token (eine bestimmte Zeichenkette) und speichert dieses Token in der Objektcodedatei main.o.
Der Linker verbindet die Objektdatei mit der Standardbibliotheksdatei der Sprache, um das endgültige Programm zu erzeugen. Wenn Fehler ermittelt werden (an dieser Stelle hauptsächlich unbekannte Token) stoppt der Prozess, genau wie beim Compiler und Sie werden vor dem möglichen Unruhestifter gewarnt. Andernfalls wird ein vollständig funktionierendes Programm erzeugt.
In Code::Blocks wird der Befehl Build zum Verwandeln und Verknüpfen verwendet: Der IDE fehlt ein eigener Befehl zum Verknüpfen.
Fahren Sie mit Übung 2.1 fort: Erstellen Sie das Projekt ex0201. Dieser Schritt sieht wie folgt aus:
5.Wählen Sie den Befehl Build|Build.
Code::Blocks verknüpft die Objektdatei mit der Standardbibliotheksdatei von C, um eine Programmdatei zu erzeugen.
Der nächste und letzte Schritt in dem Prozess besteht darin, dass Programm laufen zu lassen.
Der Text, den ein Programm handhabt, wird als String bezeichnet; dies betrifft jeden Text, der länger als ein einzelner Buchstabe ist. In C wird ein String in Gänsefüßchen eingeschlossen:
"Hallo! Ich bin ein String."
Das endgültige Programm enthält die Bibliothek der Programmiersprache C zusammen mit dem Objektcode. Dies erklärt, warum eine Programmdatei größer als die sie erzeugende Quelltextdatei ist.
Einige C–Programme verbinden sich mit verschiedenen Bibliotheken, je nachdem, was das Programm erfordert. Zusätzlich zu den Standardbibliotheken von C können Sie weitere Bibliotheken verlinken, um mit Grafiken, Vernetzung, Ton und so weiter zu arbeiten. Wenn Sie mehr über das Programmieren lernen, werden Sie entdecken, wie man verschiedene Bibliotheken wählt und verknüpft. In Kapitel 24 werden die Einzelheiten erläutert.
Durchlaufen und testen
Der ganze Sinn des Programmierens besteht darin, ein Programm zu erzeugen, sodass der erste Punkt nach dem Verknüpfen das Laufen lassen des Programms ist. Das Durchlaufen ist hauptsächlich notwendig, um zu beweisen, dass das Programm das macht, was Sie beabsichtigen, und zwar in der Weise, wie Sie es wünschen.
Wenn das Programm nicht läuft, müssen Sie einen Schritt zurückgehen und den Code reparieren. Ja, es ist absolut möglich, ein Programm zu erstellen und keine Fehlermeldung zu sehen und dann festzustellen, dass es nicht funktioniert. Das passiert ständig.
Fahren Sie mit Übung 2.1 fort: Vollenden Sie den Prozess aus dem vorangegangenen Abschnitt und führen Sie diesen letzten Schritten in Code::Blocks aus:
6.Wählen Sie Build|Run.
Das Programm läuft durch. Als Textmodusprogramm erscheint es in einem Bildschirmfenster, wo Sie sich die Ergebnisse ansehen können.
7.Schließen Sie das Bildschirmfenster, indem Sieauf der Tastatur drücken.
Wenn Sie ein einfaches Programm wie ex0201 laufen lassen, werden lediglich die Ergebnisse gezeigt. Bei komplexeren Projekten testet man das Programm. Dazu starten Sie das Programm und geben verschiedene Werte ein. Versuchen Sie es abzubrechen! Wenn das Programm das übersteht, haben Sie Ihren Job gemacht. Andernfalls müssen Sie den Quelltext überarbeiten, um das Problem zu beheben, und dann wieder das Programm bauen.
Das Durchlaufen eines Programms ist eine Aufgabe für den Prozessor und das Betriebssystem des Geräts. Das Betriebssystem lädt das Programm in den Speicher, wo der Prozessor den Code durchlaufen lässt. Dies ist eine ziemlich gute freie Beschreibung der Wirkung eines Programms.
In Code::Blocks wird die Programmdatei nach dem Projekt benannt. In Windows lautet der Name ex0201.exe. In Mac Os X, Linux und Unix lautet der Name ex0201 ohne Anhang. Außerdem werden in diesen Betriebssystemen die Berechtigungen der Dateien so festgelegt, dass die Datei lauffähig wird.
Die Buchführung in Code::Blocks
Code::Blocks verwaltet seine Projekte in Ordnern. Der Hauptordner trägt den Namen des Projekts, wie etwa ex0201. Innerhalb dieses Ordners werden Sie alle Dateien finden, die mit dem Projekt verbunden sind, einschließlich des Quelltextes, des Objektcodes und des lauffähigen Programms. Hier folgt eine Aufschlüsselung der verschiedenen Namen unter der Annahme, dass das Projekt ex0201
