Fachgebiet Regelungstheorie und Robotik · Einführung 17:30:21] rtr Startseite Einführung Inhalt

Einführung

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/einfuehrung/?L=0[01.02.2011 17:30:21]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

II. C

III. C++

C/C++-Crashkurs

Eva Brucherseifer, Martin Schneider, Lisa SchrammRegelungstheorie & Robotik TU Darmstadt

August 2006 Hinweis: Dieser Online-Kurs wird nicht weiter gepflegt, bleibt aber für Interessenten weiter zugänglich. Wir verweisen auf die Veranstaltung "Programmierung in der Automatisierungstechnik", in deren Rahmen auch neueKursmaterialien zur Verfügung gestellt werden.. Dieser Kurs geht auf das Programmieren von Anwendungen unter Linux ein. Dazu wird dem Kursteilnehmerzunächst das Betriebssystem Linux mit den Tools nähergebracht, die man zum Programmieren benötigt. Teil I beschäftigt sich weiterhin mit den Grundlagen des Compilierens, d.h. des Umwandelns von Programmcode inausführbare Programme. In Teil II wird die Programmiersprache C vorgestellt. Am Ende des Kapitels befinden sich Aufgaben. DemKursteilnehmer wird empfohlen sich im Rahmen der Aufgaben mit der Sprache auseinanderzusetzten. Teil III beschäftigt sich mit der Programmiersprache C++, die auf C aufbaut. Es werden die Basistechnikenobjektorientierter Programmierung und deren Anwendung in C++ angesprochen.

Wir hoffen, daß sie in diesem Kurs viel lernen. Das wichtigste ist jedoch, daß Sie sich selber bei den Aufgaben unddarüber hinaus mit der Programmierung auseinandersetzten. Wie jede Sprache, lernt man auchProgrammiersprachen allein durch Übung. Bei Fragen, Problemen oder Anregungen melden Sie sich bitte bei lschramm(at)rtr.tu-darmstadt.de. Viel Spaß!

Fachgebiet Regelungstheorie und Robotik

Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > Einführung

Impressum | Druckversion

http://www1.rtr.tu-darmstadt.de/startseite/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/?L=0javascript:linkTo_UnCryptMailto('ocknvq,nuejtcooBtvt0vw/fctouvcfv0fg');http://www.tu-darmstadt.de/http://www.tu-darmstadt.de/etit/http://www.iat.tu-darmstadt.de/http://www1.rtr.tu-darmstadt.de/startseite/?L=0http://www1.rtr.tu-darmstadt.de/lehre/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/?L=0http://www1.rtr.tu-darmstadt.de/?id=459&L=|http://www1.rtr.tu-darmstadt.de/index.php?id=474&L=0&type=98http://www1.rtr.tu-darmstadt.de/index.php?id=474&L=0http://www1.rtr.tu-darmstadt.de/index.php?id=474&L=1http://www1.rtr.tu-darmstadt.de/index.php?id=474&L=2http://www1.rtr.tu-darmstadt.de/index.php?id=474&L=3http://www.tu-darmstadt.de/

Inhalt

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/inhalt/?L=0[01.02.2011 17:30:24]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

II. C

III. C++

Alles aus-/einklappen

rtr Startseite

Einführung

Inhalt

1. VORBEMERKUNGEN

1.1 Aufbau des Kurses

I. LINUX

2. ÜBERSICHT

3. DATEISYSTEM

4. SHELL

5. PROGRAMMIEREN UNTER LINUX

6. Literaturhinweise

7. AUFGABEN

II. C

8. Ein C-Programm

9. Variablen / Datentypen

10. WICHTIGE SPRACHELEMENTE

11. FUNKTIONEN

12. Benutzerdefinierte Typen

13. ÜBERSETZEN VON C-PROGRAMMEN

14. ARRAYS

15. ZEIGER

16. AUFGABEN

III. C++

17. DAS KLASSENKONZEPT

18. BASISTECHNIKEN

19. Templates

20. DIE STANDARDBIBLIOTHEK STL

21. KLASSEN II

22. FORTGESCHRITTENE TECHNIKEN

23. VERERBUNG

24. POLYMORPHIE

25. AUFGABEN


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > Inhalt


http://www1.rtr.tu-darmstadt.de/startseite/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/?L=0javascript:tx_dropdownsitemap_pi1_expAll();javascript:tx_dropdownsitemap_pi1_expAll();http://www1.rtr.tu-darmstadt.de/startseite/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(478);javascript:tx_dropdownsitemap_pi1_swapClasses(507);javascript:tx_dropdownsitemap_pi1_swapClasses(508);javascript:tx_dropdownsitemap_pi1_swapClasses(510);javascript:tx_dropdownsitemap_pi1_swapClasses(514);javascript:tx_dropdownsitemap_pi1_swapClasses(517);javascript:tx_dropdownsitemap_pi1_swapClasses(525);javascript:tx_dropdownsitemap_pi1_swapClasses(531);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/8-ein-c-programm/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/9-variablen-datentypen/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(534);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/10-wichtige-sprachelemente/101-ein-ausgabe-mit-printf-scanf/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(539);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/11-funktionen/111-funktionsprototypen/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/12-benutzerdefinierte-typen/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(545);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/13-uebersetzen-von-c-programmen/131-zerlegung-in-module/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(549);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/14-arrays/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(550);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/15-zeiger/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(558);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/16-aufgaben/161-ein-signalgenerator-in-c/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(563);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(564);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/17-das-klassenkonzept/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(572);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/18-basistechniken/181-kommentare/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/19-templates/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(582);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/20-die-standardbibliothek-stl/201-stl-existierende-wiederverwendbare-klassen/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(587);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/21-klassen-ii/211-alternative-konstruktoren/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(592);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/22-fortgeschrittene-techniken/221-konstanten/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(600);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/23-vererbung/231-objektorientierte-konzepte-zur-code-wiederverwendung/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(608);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/24-polymorphie/241-dynamisches-binden/?L=0javascript:tx_dropdownsitemap_pi1_swapClasses(653);http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/25-aufgaben/251-aufgabe-1-stl/?L=0http://www.tu-darmstadt.de/http://www.tu-darmstadt.de/etit/http://www.iat.tu-darmstadt.de/http://www1.rtr.tu-darmstadt.de/startseite/?L=0http://www1.rtr.tu-darmstadt.de/lehre/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/?L=0http://www1.rtr.tu-darmstadt.de/?id=459&L=|http://www1.rtr.tu-darmstadt.de/index.php?id=464&L=0&type=98http://www1.rtr.tu-darmstadt.de/index.php?id=464&L=0http://www1.rtr.tu-darmstadt.de/index.php?id=464&L=1http://www1.rtr.tu-darmstadt.de/index.php?id=464&L=2http://www1.rtr.tu-darmstadt.de/index.php?id=464&L=3http://www.tu-darmstadt.de/

1. Vorbemerkungen

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/1-vorbemerkungen/?L=0[01.02.2011 17:30:26]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen


I. Linux

II. C

III. C++

An wen wendet sich diese Einführung?

Die vorliegende Einführung richtet sich vorrangig an Studenten, die Interesse an einer Studien- oder Diplomarbeitam Fachgebiet Regelungstheorie und Robotik haben und an die Teilnehmer des alljährlich stattfindenden Robotik-Seminars. Darüberhinaus sind natürlich auch alle aus anderen Gründen Interessierten herzlich willkommen.

Was ist der Sinn dieser Einführung?

Die Studenten sollen auf ihre Arbeit an unserem Fachgebiet vorbereitet werden. Am Fachgebiet Regelungstheorieund Robotik besteht die Arbeitsumgebung im wesentlichen aus Solaris-Servern und Linux-Arbeitsplatzrechnern.Programmiert wird fast durchgängig in den Sprachen C und C++. Die Einführung möchte folgendes erreichen:

Die Grundlagen der Programmiersprachen C und C++ sollen vermittelt werden.Der Einsatz der Sprachen C und C++ in einer UNIX-Programmierumgebung soll vorbereitet werden.Ein Überblick über die Möglichkeiten zur Programmierung graphischer Oberflächen soll gegeben werden.

Grundlegende Voraussetzungen an die Kursteilnehmer, etwa in C oder einer anderen Programmiersprachebestehen nicht, vereinfachen jedoch den Einstieg.


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > 1. Vorbemerkungen


http://www1.rtr.tu-darmstadt.de/startseite/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/?L=0http://www.tu-darmstadt.de/http://www.tu-darmstadt.de/etit/http://www.iat.tu-darmstadt.de/http://www1.rtr.tu-darmstadt.de/startseite/?L=0http://www1.rtr.tu-darmstadt.de/lehre/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/?L=0http://www1.rtr.tu-darmstadt.de/?id=459&L=|http://www1.rtr.tu-darmstadt.de/index.php?id=478&L=0&type=98http://www1.rtr.tu-darmstadt.de/index.php?id=478&L=0http://www1.rtr.tu-darmstadt.de/index.php?id=478&L=1http://www1.rtr.tu-darmstadt.de/index.php?id=478&L=2http://www1.rtr.tu-darmstadt.de/index.php?id=478&L=3http://www.tu-darmstadt.de/


http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/1-vorbemerkungen/11-aufbau-des-kurses/?L=0[01.02.2011 17:30:32]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen


I. Linux

II. C

III. C++


Der Kurs besteht aus 4 Teilen:

Einführung in die Programmierung unter Linux mit einer Compiler-Sprache.Programmiersprache CProgrammiersprache C++ und Überblick über Software EngineeringGraphische Programmierung

Jeder Teil ist begleitet von praktischen Übungen. Die Teilnehmer sollten sich jedoch auch darüber hinausgehend mitden Programmiersprachen beschäftigen. Eine Literaturliste mit einführenden Büchern, aber auch mit Standardwerken für den erfahrenen Progarmmierer, istam Ende jeden Teils zu finden.


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > 1. Vorbemerkungen > 1.1 Aufbau des Kurses



2. Übersicht

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/2-uebersicht/?L=0[01.02.2011 17:30:28]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht2.1 Graphische Oberflächenin Linux

3. Dateisystem

4. Shell

5. Programmieren unterLinux


7. Aufgaben

II. C

III. C++

2. Übersicht

Linux ist ein echtes Mehrbenutzersystem (multi-user). Das heißt, daß mehrere Benutzer völlig getrennt und ungestört gleichzeitig am selben Rechner arbeiten können. DieRechenleistung und die Ressourcen des Systems werden dann von Linux zwischen den verschiedenen Benutzernverteilt. Jeder Benutzer hat immer ein eigenes Homeverzeichnis, in dem seine Einstellungen und persönliche Dateiengespeichert werden. Unix-Rechner können in ein lokales Netzwerk (local area network, LAN) mit einheitlicherBenutzerverwaltung und zentralem Fileserver integriert sein.

Zugang zum System

Um auf einem Linux-Rechner arbeiten zu können, muß man sich erst darauf einloggen, indem man seinen Login-Namen und sein Passwort angibt. Jeder Benutzer hat nur beschränkten Zugriff auf das System. Die Dateien habenverschiedene Rechte, um nur bestimmten Benutzern zu erlauben, sie zu lesen, schreiben, oder auszuführen. Nur ein Benutzer besitzt die Rechte auf alle Dateien. Dieser Benutzer heißt ``root''. Er ist der Verwalter des Systems,und kann alle Einstellungen ändern, Programme installieren, neue Benutzer einrichten, usw.

Verlassen des Systems

Nach dem Arbeiten verläßt man das System, indem man sich ``ausloggt'', um seine Daten zu schützen.

Prozesse:

Wenn Programme ausgeführt werden, sind sie dem System als Prozesse bekannt.

Jeder Prozess hat eine eindeutige Nummer: Die PID (Process Identification Number)Die Prozesse sind baumartig strukturiert. Wurzel ist PID 0.Jeder Prozess ist einem Benutzer zugeordnet.

Shells (Kommandointerpreter):

Eine Shell interpretiert die Befehlseingabe auf der KommandozeileAufbau eines Befehls: Beispiel: man lsEs gibt interne (in die Shell eingebaute) und externe Befehle (Programme) sowie selbstgeschriebene Skripte(sog. Shellskripte, die Aufrufe von internen und externen Befehlen enthalten)Die Shell speichert ihre Umgebung in Umgebungsvariablen. Diese können mit dem Befehl exportangesehen und verändert werden. Die Umgebungsvariablen können in den Dateien .profile und.bashrc im Homeverzeichnis verändert werden.Der Suchpfad für Programme befindet sich in der Umgebungsvariablen PATH.


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 2. Übersicht



2.1 Graphische Oberflächen in Linux

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/2-uebersicht/21-graphische-oberflaechen-in-linux/?L=0[01.02.2011 17:31:10]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht2.1 Graphische Oberflächenin Linux

3. Dateisystem

4. Shell



7. Aufgaben

II. C

III. C++

2.1 Graphische Oberflächen in Linux

Der X-Server ermöglicht die graphische Darstellung unter Linux und bildet die Schnittstelle zur Graphikkarte. Um eineinfaches Programmieren von Fensterprogrammen zu ermöglichen, gibt es verschiedene Toolkits - auch fürSkriptsprachen:

Tcl/Tk, Perl oder Python als KleberMotifGtkQT/KDE

Zum Teil sind diese Toolkits auch auf anderer Betriebssysteme (Windows, Mac OS) portabel. Aufgabe der Toolkits istes, graphische Elemente (Widgets) wie Buttons, Dialoge, Texteingabe etc. und eine zentrale Event-Loop für dieBenutzeraktion zur Verfügung zu stellen.

2.2 Windowmanager, Desktops

Aufbauend auf diesen Toolkits und dem X-Server gibt es für Linux verschiedene Windowmanager bzw. Desktops:

fvwmKDEGnome

Ein Windowmanager sorgt dafür, dass graphische Programme einen Rahmen haben, deren Fenster groß und kleingemacht werden können, daß sie sich überlappen können, etc. Ein Desktop Environment bietet zudem Start- undTaskleisten, Desktop-Icons, ein Clipboard, Drag&Drop-Funktionen für einen guten Workflow. Zudem gibt es eine Vielzahl von graphischen Programmen.


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 2. Übersicht > 2.1 Graphische Oberflächen in Linux



3. Dateisystem

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/3-dateisystem/?L=0[01.02.2011 17:30:34]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem3.1 Bedeutung derDirectoryeinträge3.2 Der Befehl "chmod"3.3 Besondere Pfade

4. Shell



7. Aufgaben

II. C

III. C++

3. Dateisystem

Um effektiv mit der Shell zu arbeiten, braucht man Kenntnisse über die Datei- und Verzeichnis-Struktur unter Linux. Verzeichnisse sind Ordner, in denen Dateien, Programme oder auch Unterverzeichnisse abgelegt werden können.Alle Verzeichnisse des Systems sind baumartig angeordnet. Das Wurzelverzeichnis ist in der Hierarchie ganz obenund wird mit ``/'' angesprochen. Von hier aus gelangt man zu allen anderen Verzeichnissen.

Die Partitionen einer Festplatte können in diesen Verzeichnisbaum integriert werden, indem sie gemountet werden.Dies gilt auch für Wechselmedien wie Floppys oder CDs. Bevor sie wieder entnommen werden, müssen die Medienmit umount wieder aus dem Verzeichnisbaum entfernt werden, dieser Befehl bewirkt auch, daß ausPerformancegründen gecachte Schreibzugriffe zuvor ausgeführt werden. Mit dem Befehl cd (change directory) kann das Verzeichnis gewechselt werden. Die Eingabe von cdbzw. cd ~ führt den Benutzer stets in sein eigenes Heimatverzeichnis (meistens /home/). Um sich den Inhalt eines Verzeichnisses anzuschauen, geben Sie den Befehl ls ein. Wenn Sie keinVerzeichnis hinter ls angeben, wird das aktuelle Arbeitsverzeichnis angezeigt. Hier ein typisches Home-Verzeichnis:

Desktop bild.svg public_html

Um mehr Informationen zu erhalten, empfiehlt sich die Option ls -l. Normalerweise gibt es für diesen Befehl den``Alias'' ll.

total 20drwx------ 3 eva users 4096 2002-06-07 20:38 Desktop-rw-r--r-- 1 eva users 6202 2002-06-09 11:35 bild.svgdrwxr-xr-x 2 eva users 4096 2002-06-02 20:26 public_html

Und um alle versteckten Dateien zu sehen (z.B. alle Dateien, die mit einem . beginnen), sollten Sie ls -la eingeben.Diese versteckten Dateien enthalten die User-Konfiguration.

total 1680drwxr-xr-t 16 hacking users 4096 2002-10-20 11:06 .drwxr-xr-x 5 matze users 4096 2002-10-04 08:46 ..-rw-r--r-- 1 hacking users 5742 2002-10-04 08:44 .Xdefaults-rw-r--r-- 1 hacking users 1305 2002-10-04 08:44 .Xmodmaplrwxrwxrwx 1 root root 10 2002-10-04 01:45 .Xresources -> .Xdefaults-rw------- 1 hacking users 2668 2002-10-20 11:07 .bash_history-rw-r--r-- 1 hacking users 1286 2002-10-04 08:44 .bashrc-rw-r--r-- 1 hacking users 208 2002-10-04 08:44 .dvipsrc-rw-r--r-- 1 hacking users 1637 2002-10-04 08:44 .emacsdrwxr-xr-x 4 hacking users 4096 2002-06-07 11:26 .kde-rw-r--r-- 1 hacking users 934 2002-10-04 08:44 .profiledrwxr-xr-x 2 hacking users 4096 2002-09-21 12:57 .qt-rwxr-xr-x 1 hacking users 2432 2002-10-04 08:44 .xinitrc-rw-r--r-- 1 hacking users 1101 2002-10-04 08:44 .xserverrc.secure-rwxr-xr-x 1 hacking users 2794 2002-10-04 08:44 .xsession-rw------- 1 hacking users 1395772 2002-06-07 20:38 .xsession-errorsdrwx------ 3 hacking users 4096 2002-06-07 20:38 Desktop-rw-r--r-- 1 hacking users 6202 2002-06-09 11:35 bild.svgdrwxr-xr-x 2 hacking users 4096 2002-06-02 20:26 public_html


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 3. Dateisystem



3.1 Bedeutung der Directoryeinträge

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/3-dateisystem/31-bedeutung-der-directoryeintraege/?L=0[01.02.2011 17:31:11]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht


4. Shell



7. Aufgaben

II. C

III. C++

3.1 Bedeutung der Directoryeinträge

Wenn Sie die ersten 10 Zeichen einer Zeile der Ausgabe von ''ls -l'' betrachten, werden Sie recht schnell eineinfaches Muster erkennen. Das erste Zeichen überhaupt gibt den Typ der Datei an. Dabei steht

d für Directory,l für Link und ein- für eine normale Datei.

Danach folgen drei Dreierblöcke, welche die Zugriffsrechte regeln. Der erste Dreierblock steht dabei für

den Benutzer (User = u) selbst (also Sie),der zweite Block beschreibt die Gruppenrechte (Group = g) undder dritte Block regelt den Zugriff der übrigen Welt (Others = o).

Jeder Block besteht aus drei Flags, welche gesetzt sein können. Das sind im Einzelnen

r (read = lesen),w (write = schreiben) undx (execute = ausführen).

Der User sollte in seinem Homeverzeichnis normalerweise alles dürfen, weswegen oft die ersten drei rwx gesetztsind. Zumindest Schreiben sollte man allen anderen verbieten. Bei Verzeichnissen muß das x-Flag gesetzt sein,damit der entsprechende Benutzer in das Verzeichnis wechseln darf. Wenn Sie also nicht wollen, daß irgendjemandihre Dateien liest oder ausführt (von Schreiben ganz zu Schweigen), sollten die Berechtigungen einer Datei etwa soaussehen wie für die Datei .bash_history im oberen Beispiel (rw- --- ---). Der nächste Eintrag ist weniger wichtig, danach kommt der Name des Besitzers der Datei (hier immer root) und danndie Gruppe (auch root). Der nächste Eintrag ist eine Zahl, welche die Größe der Datei in Bytes angibt. Dann folgt dasDatum der letzten Änderung und anschließend der Name der Datei.


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 3. Dateisystem > 3.1 Bedeutung der Directoryeinträge



3.2 Der Befehl "chmod"

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/3-dateisystem/32-der-befehl-chmod/?L=0[01.02.2011 17:31:13]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht


4. Shell



7. Aufgaben

II. C

III. C++

3.2 Der Befehl "chmod"

Mit diesem Befehl ändert man die Zugriffsrechte auf eine Datei oder ein Verzeichnis. Format: chmod Der Dateiname kann eine Datei oder ein Verzeichnis sein. Die Maske regelt die neuen Zugriffsrechte nach einem einfachen Prinzip: Für die drei Gruppen gibt es die Kürzel ugo(user, group, others), dann + (erlauben) oder - (verbieten) und zuletzt rwx (wie bisher). Möchten Sie ihre Datei für die Welt lesbar machen, müssen Sie chmod o+r test eingeben. Wollen Sie alle Zugriffeverbieten, geben Sie einfach chmod ugo-rwx test ein. Keine Angst! Als Besitzer der Datei können Sie die Rechteimmer noch ändern, auch wenn Sie die Datei jetzt weder lesen noch beschreiben können. Geben Sie jetzt chmodu+rwx test und anschließend chmod g+rx test ein, dann können wenigstens Ihre Gruppenmitglieder die Datei lesenund ausführen.


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 3. Dateisystem > 3.2 Der Befehl "chmod"



3.3 Besondere Pfade

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/3-dateisystem/33-besondere-pfade/?L=0[01.02.2011 17:31:15]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht


4. Shell



7. Aufgaben

II. C

III. C++

3.3 Besondere Pfade

Auf jedem Linux System befinden sich besondere Pfade, die eine bestimmte Funktion haben.

/home : Heimatverzeichnis der einzelnen Benutzer. Hier liegen alle Daten, Einstellungen und all das, worauf nur derBenutzer Zugriff haben soll. Im Allgemeinem können diese Daten von allen gelesen, aber von niemandanderem als der Eigentümer verändert werden./root: Heimatverzeichnis des Administrators root./usr (Unix System Ressourcen): Aus diesem Verzeichnis holen sich viele Programme Dokumente, Informationen, Hilfstexte und anderewichtige Daten./bin und /sbin (Ausführbare Programme): in diesem Verzeichnissen sind viele systemnahe Programme zu finden, welche schon zum Systemstartbenötigt werden./opt (optionale Software): Kommerzielle Software oder sehr große Programmpakete wie etwa KDE, Netscape, Mozilla usw. finden hierihren Platz./etc (Konfigurationsordner): Hier sind Dateien zusammengefasst, die die Konfigurationsinformationen für den Rechner enthalten. Siebeinhalten z.B. Informationen zur Internetverbindung, zum Startmodus des Rechners oder einzelnenProgrammen wie Backup (Datensicherung)./boot (Ordner für den Systemstart): Dateien und Programme, die zum Systemstart benötigt werden, z.B. der Kernel./var (Protokoll-Dateien): Log-Dateien und Verzeichnisse für temporäre Daten (caches)Sonstige: Daneben gibt es noch weitere Ordner, die Informationen zum System und den angeschlossenen Gerätenenthalten: /lib und /usr/lib (Bibliotheken), /var (variable Daten), /proc (Prozesse), /media (auswechselbareGeräte wie Floppy, CD etc.) /dev (alle angeschlossene Geräte wie Drucker, Festplatten, Tastaturen etc.)


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 3. Dateisystem > 3.3 Besondere Pfade



4. Shell

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/4-shell/?L=0[01.02.2011 17:30:35]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell4.1 Befehle4.2 Shellskripte



7. Aufgaben

II. C

III. C++

4. Shell

Auf der Taskleiste finden Sie ein Icon, das einen Monitor mit einer Muschel (engl. shell) darstellt. Wenn Sie mit derMaus auf dieses Symbol klicken, Öffnet sich das ``Konsole''-Fenster, in dem Sie Befehle eingeben können.DiesesTerminal stellt einen Kommandointerpreter in einer graphischen Oberfläche zur Verfügung. Kommandointerpreterstellen die einfachste Schnittstelle zum Betriebssystem dar, indem Befehle per Texteingabe entgegennehmen. Daskomplette System lässt sich auf diese Weise steuern. Auf UNIX/Linux-Betriebssystemen befinden sich standardmäßig eine Reihe von Kommandointerpretern, diegrundsätzlich jeweils unterschiedliche Kommandosprachen bereitstellen. Glücklicherweise sind viele dieser Sprachensehr ähnlich und überschneiden sich stark, da die verschiedenen Interpreter oft Erweiterungen von anderenInterpretern bereitstellen. Die wichtigsten Kommandointerpreter sind die Bash ('bash'), C-Shell ('csh','tcsh') sowiedie Korn-Shell ('ksh'), von denen hier lediglich auf die Basheingegangen wird. Den Shellinterpreter kann man mit dem Befehl 'echo $SHELL' auf der Kommandozeile abfragen. Sie sehen in derersten Zeile den sogenannten Prompt ''benutzer@computer:~> ''


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 4. Shell



4.1 Befehle

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/4-shell/41-befehle/?L=0[01.02.2011 17:31:16]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem




7. Aufgaben

II. C

III. C++

4.1 Befehle

Befehle bestehen aus verschiedenen Bestandteilen. Zuerst kommt immer das Befehlswort und dann die Parameteroder Optionen. Jeder Befehl wird erst ausgeführt, wenn Sie die Eingabetaste drücken. Als Beispiel wird der Befehl ls angenommen. Geben Sie in der Konsole nur ls ein, wird Ihnen der Inhalt desVerzeichnisses angezeigt, in dem Sie sich gerade befinden. Wenn Sie die Option ``l'' benutzen, und ls -l angeben,werden die Details angezeigt. Wenn sie danach ein Verzeichnissname angeben, z.B. ls /usr/, wird der Inhalt diesesVerzeichniss angezeigt. Mit der option --help (z.B. ls --help) kann man alle möglischen Optionen eines Befehls abrufen.

man [ - ] [ -adFlrt ] [ -M path ] [ -T macro-package ] [ -s section ] name ...

Befehlsname [Flags] [-Options] Parameter

Eine genauere Beschreibung eines Befehls mit seinen Optionen enthält die man-page. Diese erhält man mit Hilfedes Befehls man. Mit dem Zeichen & am Ende eines Befehls bewirkt man, daß ein Programm als eigenständiger Prozess gestartetwird und die Kommandozeile wieder zur Verfügung steht.

4.1.1 Einige wichtige Befehle

Dateien

ls: Anzeige der Dateien im aktuellen Verzeichnisls -l bzw. -ll: zusätzliche Angabe der Zugriffsrechte, des Besitzers, der Größe und desErstellungsdatumls -a bzw. -la: mit einem Punkt beginnende Konfigurationsdateien werden auch angezeigtmkdir : Erstellt ein Unterverzeichnis Namermdir : Löscht das leere Verzeichnis Namerm : Löscht die Datei Namecd: Wechsel in das Home-Verzeichniscd : Wechsel in das Verzeichnis Namecd ..: Wechsel in das übergeordnete Verzeichnispwd: Zeigt das aktuelle Verzeichnis ancp : Kopiert Quelle nach Zielmv : Verschiebt Quelle nach Ziel bzw. kopiert Quelle in das Unterverzeichnis Ziel

Hilfe

man : Online-Hilfe zum Befehl Name --help: Ausgabe der Befehlssyntax von Name

Textdateien

more :Anzeige der Textdatei Namecat :Anzeige der Textdatei Name

Archive

tar -cf : Erstellt das Archiv archive.tar rekursiv mit den Dateien oderVerzeichnissen foo und bartar -tf : Gibt die Liste der Dateien, die sich in der Archive archive.tar befindentar -xf : Extrahiert alle Dateien aus der Archive archive.tar.gzip : Komprimieren einer Dateigunzip : Entpacken einer Datei

Rechtevergabe

chmod : Ändert die Zugriffsrechte auf eine Dateichown : Ändert den Besitzer einer Datei

Programmhandling

ps: Zeigt die laufenden Prozessekill: Beendet einen laufenden Prozess (mit Hilfe eines Interrupts)nice: Gibt einem Prozess eine andere Priorität

Suchfunktionen

find: Finden von Dateiengrep: Durchsucht Text-Dateien


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 4. Shell > 4.1 Befehle



4.2 Shellskripte

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/4-shell/42-shellskripte/?L=0[01.02.2011 17:31:18]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem




7. Aufgaben

II. C

III. C++

4.2 Shellskripte

Shellskripte sind Programme, die direkt von dem Shell interpretiert werden. Sie beinhalten Shell-Befehle, die im Shellausgefüht werden können. Sie fangen immer mit der Zeile

#!/bin/bash

Damit wird festgelegt, dass die Bash dieses Skript abarbeiten soll. Dann kann ein Programm in Skriptsprachegeschrieben werden. Namensexpandierung:

*,? (Wildcards)0123456789, abc

Quoting: Man unterscheidet 3 Formen:

'command $var' Alles was zwischen '' steht, wird als ein String behandelt."command $var"

Alle Variablen die zwischen "" stehen, werden zunächst durch ihren Wert ersetzt und daraufhin wird dergesamte Ausdruck als String zurückgegeben.`command $var` Alle Variablen die zwischen `` stehen, werden zunächst durch ihren Wert ersetzt und daraufhin wird dergesamte Command-String zwischen den Quotes als Kommando interpretiert und ausgeführt.

Beispiel 1> echo $$=pwd > welt> cat welt28850=pwd

Beispiel 2> echo "$$=pwd > welt"28850=pwd > welt

Beispiel 3> echo '$$=pwd > welt'$$=pwd > welt

Beispiel 4> echo "$$=`pwd` > welt"Directory: /home/petbec28850= > welt


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 4. Shell > 4.2 Shellskripte



5. Programmieren unter Linux

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/5-programmieren-unter-linux/?L=0[01.02.2011 17:30:36]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell


5.1 Aufbau eines C/C++-Programm5.2 Programme erstellen5.3 Schritte derProgrammübersetzung5.4 Der GNU-C-Compiler5.5 Buildsysteme5.6 Testen und Debuggen5.7 CVS


7. Aufgaben

II. C

III. C++

5. Programmieren unter Linux

Programmiersprachen kann man unterteilen in Skriptsprachen und Compilersprachen. Skriptsprachen wie Javascript, Perl oder Python werden nicht compiliert, sondern können von einem Interpreterdirekt ausgeführt werden. C und C++ sind Compiliersprachen. Der Code muß vor dem Ausführen zunächst in Objectcode umgewandelt(compiliert werden), bevor er ausgeführt werden kann. Dieser Objectcode (Maschinencode) ist plattformabhängig,aber schneller ausführbar als Code, der zur Laufzeit erst interpretiert werden muss.


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 5. Programmieren unter Linux



5.1 Aufbau eines C/C++-Programm

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/5-programmieren-unter-linux/51-aufbau-eines-cc-programm/?L=0[01.02.2011 17:31:19]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell




7. Aufgaben

II. C

III. C++

5.1.1 Eigenschaften von C

C ist eine funktionale Spracheintegrierte Variablentypen (int, char, void, ...), strikte TypprüfungErweiterbare Sprache: Einbinden von Bibliotheken

Aufbau eines Programms:

mindestens die Funktion int main()VariablendefinitionenFunktionsaufrufe

Codebeispiel in C:

/* filename: hello_world.c */ #include ; int main() { printf("Hello world \n"); return(0); }

Vorteile von C

schnelle Programmehöhere Programmiersprachegroße Vielfalt von Bibliotheken verfügbar

Nachteile von C

viele Fehlertypen sind nicht vom Compiler erkennbarzur Lesbarkeit sind eigene Stilkonventionen erforderlichviel Funktionalität ist nicht in der Sprache integriert

5.1.2 Eigenschaften von C++:

enthält C (C89)objektorientierte Spracheenthält viele moderne Sprachelemente und Datenstrukturen

Codebeispiel in C++:

/* filename: hello_world.cpp */ #include ; int main() { cout ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 5. Programmieren unter Linux > 5.1 Aufbau eines C/C++-Programm



5.2 Programme erstellen

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/5-programmieren-unter-linux/52-programme-erstellen/?L=0[01.02.2011 17:31:21]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell




7. Aufgaben

II. C

III. C++

5.2 Programme erstellen

Editieren von Programmen:

Programmcode erstellenDokumentierenDebug-Code

Der Programmcode besteht aus Header- und Source-Dateien. Source-Dateien:

Endung: *.c (in C) oder *.cpp/*.cc (in C++)Definition der Funktionen, Implementierung

Header-Dateien:

Endung: *.h (in C) oder *.h/*.hpp (in C++)Deklaration der Funktionen, also Spezifikation der SchnittstellenCode, den mehrere Sourcefiles benötigen, das ,,Inhaltsverzeichnis`` der Source-Files

Beispiel

/******************************************************* c-Datei: *******************************************************/ #include "myfunc.h" #include

float add(float a, float b) // Implementierung der Funktion add(){ return (a+b); }

int main(){ float a,b,c; a = 10; b = 1.7; c = add(a,b); printf("Result: %f\n", c); return 0;}

/*******************************************************h-Datei: myfunc.h*******************************************************/#ifndef MYFUNC_H#define MYFUNC_H

float add(float a, float b); // Prototyp der Funktion add()

#endif


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 5. Programmieren unter Linux > 5.2 Programme erstellen



5.3 Schritte der Programmübersetzung

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/5-programmieren-unter-linux/53-schritte-der-programmuebersetzung/?L=0[01.02.2011 17:31:23]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell




7. Aufgaben

II. C

III. C++


Zunächst werden die .c und .h-Dateien, die das Programm bilden sollen, editiert. Hierzu kann ein beliebigerTexteditor verwendet werden.

In jedem Linux-Betriebssystem kann der C-Compiler über den Befehl cc aufgerufen werden. Dies ist in der Regeleine Art Frontend, das den eigentlichen Compiler aufruft. Oft ist cc auch lediglich ein symbolischer Link auf denCompiler (siehe ls -ll /usr/bin | grep cc).

Unter Linux ist das meist verwendete Übersetzungstool der gcc (GNU-C-Compiler). Der gcc selber ruft beimÜbersetzen zahlreiche weitere Programme auf und verarbeitet deren Ausgaben. Oft wird der Begriff gcc auchsynonym für diese Programmsammlung (GNU-Buildsystem) verwendet.

Das Übersetzen läuft dann am Beispiel des GNU-Buildsystems wie folgt ab:

Phase 1: Präprozessor cppJede einzelne .c-Datei wird zunächst vom Präprozessor verarbeitet. Dieser lädt zuerst alle durch#include-Anweisungen angegebenen Dateien zur .c-Datei hinzu und ersetzt anschließend allevorkommenden Makros im Code durch die in den Makrodefinitionen (#define-Anweisungen) angegebenenAusdrücke. Weiterhin werden alle Kommentare durch Leerzeichen ersetzt. In der so entstandenAnsammlung von Programmcode sind nun alle Informationen akkumuliert, die zum Übersetzen benötigtwerden und aus reinem C-Code bestehen.Mit Hilfe des Präprozessors kann auch eine Anpassung an verschiedene Arbeitsumgebungen(Betriebssystem, Compiler) erfolgen.Phase 2: Compiler cc / gcc bzw. g++ für C++Der vom Präprozessor ausgegebene C-Code kann nun vom eigentlichen Compiler in Assembler-Codeübersetzt werden. Dies ist bei modernen Compiler ein sehr komplexer Prozess, da oftmals eine Optimierunghinsichtlich Laufzeit oder Größe unter sehr unterschiedlichen Nebenbedingungen undarchitekturspezifischen Besonderheiten (RICS, CISC, Befehlssätze, etc.) erwünscht ist.In der Regel ist der Assembler-Code für den Maschinentyp bestimmt, auf dem auch die Übersetzungstattfindet. Dies muss nicht so sein (Cross-Compiler).Phase 3: Assembler asDer GNU-Assembler as ersetzt schließlich den optimierten Code des Compilers mit dem eigentlichenMaschinen-Hex-Code der spezifischen Prozessor-Architektur. Dieser sogenannte Objekt-Code wird ineiner Datei mit der Endung .o gespeichert. Diese Datei ist noch nicht ausführbar, da noch externeAbhängigkeiten aufgelöst werden müssen.Phase 4: Linker ldDer Linker bindet mehrere Objektdateien oder Archive zu einer ausführbaren Datei zusammen, indem er diebestehenden Symbol-Referenzen (Abhängigkeiten) auflöst und die relativen Adressen der Datenblöcke neuberechnet. Meist wird der selbst geschriebene Code gegen Standardbibliotheken gelinkt, in denen derMaschinencode der aufzurufenden Standard-C-Funktionen abgelegt ist.Im Gegensatz zu Windows-Programmen haben ausführbare Dateien unter Linux in der Regel keineDateiendung.

Die einzelnen Schritte müssen glücklicherweise nicht per Handausgeführt werden, sondern werden weitestgehend selbständig vom gcc organisiert.

Phase 1 - Phase 3


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 5. Programmieren unter Linux > 5.3 Schritte derProgrammübersetzung




http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/5-programmieren-unter-linux/53-schritte-der-programmuebersetzung/?L=0[01.02.2011 17:31:23]

Phase 4

5.4 Der GNU-C-Compiler

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/5-programmieren-unter-linux/54-der-gnu-c-compiler/?L=0[01.02.2011 17:31:24]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell




7. Aufgaben

II. C

III. C++

5.4 Der GNU-C-Compiler

Der gcc führt beim Übersetzen einer einzigen Quelldatei mit einer main()-Funktion die obigen Schritte vollkommenautomatisch durch, so dass direkt die ausführbare Programmdatei ausgegeben wird. Über sogenannte Flags kanndas Verhalten des Compiler den eigenen Wünschen entsprechend angepasst werden. Zum Beispiel erzeugt der gccstandardmäßig die ausführbare Datei a.out , was mit der Option '-o Outputfilename' auf den gewünschtenNamen Outputfilename geändert wird.

Weitere Optionen legen die Sprache und Sprachdialekte wie z.B. ANSI C, C89, C99, etc. fest, andere wiederum dieCodeoptimierung, den Prozessortyp oder weitere Suchpfade für Header-Dateien und Bibliotheken. Siehe hierzu dieMan-Page zu gcc.

Benutzung:

gcc [OPTIONEN] [FILES]

Hauptoptionen:

-o outfile erzeugt ein Executable namens "outfile" -ansi schaltet in den ANSI-C-Modus -std=c99 prüft auf Kompatibilität zum Sprachstandard C99 -pedantic besonders genaues Prüfen des C-Programmes -I/usr/local/include sucht Headerfiles zusaetzlich in dem Verzeichnis "/usr/local/include" -L/usr/local/lib sucht Objektfiles und Libraries zusätzlich in dem Verzeichnis "/usr/local/lib" -lmylib linkt die Objektdateien gegen die Bibliotheksdatei libmylib.so -g Übersetzung mit Debug-Informationen für späteres Debuggen -O / -O1 / -O2 verschiedene Optimierungsmöglichkeiten -v zeigt Zusatzinformationen an -Wall berichtet alle möglichen Warnungen --version zeigt die Version des gcc an

Falls das Projekt mehrere Quelldateien besitzt, die alle zu einem Programm gebunden werden sollen, ist dasschrittweise übersetzen der einzelnen Quelldateien mit einem anschließenden Linkprozess der entsprechendenObjektmodule notwendig. Der gcc kann dafür veranlaßt werden, bei einem bestimmten Schritt derProgrammübersetzung abzubrechen und statt dem fertigen Programm z.B. den Assembler-Code oder Objekt-Codeauszugeben.

Optionen zur Ausgabe:

-E stoppt nach der Präprozessor-Phase, das Ergebnis ist reiner C-Code -S stoppt nach dem Kompilieren, das Ergebnis ist Assembler-Code -c stoppt nach dem Assemblieren, das Ergebnis ist Objekt-Code

Normalerweise werden diese Einstellungen in einem sog. Makefile vorgenommen, das von dem im nächstenAbschnitt behandelten make-Programm verarbeitet wird.


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 5. Programmieren unter Linux > 5.4 Der GNU-C-Compiler



5.5 Buildsysteme

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/5-programmieren-unter-linux/55-buildsysteme/?L=0[01.02.2011 17:31:26]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell




7. Aufgaben

II. C

III. C++

5.5 Buildsystem: make

Es gibt verschiedene Ansätze um den oben beschriebenen Ablauf zum Bauen von Programmen zu automatisieren.Dazu verwendet man in der Regel sog. Makefiles, die von dem Programm make interpretiert werden. make ist somiteine Art Interpretersprache. Arbeitsweise von make:

inkrementelles Bauen: Regeln basieren auf ÄnderungsdatumZiel: Übersetzungszeit verkürzenDarstellung: AbhängigkeitsgraphZiele, Abhängigkeiten, RegelnVariablen (Bsp.: CC = cc, $(CC), make CC=gcc)Tücken: Tabulator, datumsbasiert, mehrfache Abhängigkeiten

für Fortgeschrittene:

implizite Regeln (Bsp.: .c.o:)Musterregeln Bsp.: (%.o: %.c)Makefiles für andere Befehle (Bsp.: make install)

Beispiel für ein Makefile

example1_2:example1_2.o libEx.a gcc example1_2.o -L. -lEx -o example1_2

example1_2.o: gcc -g -c example1_2.c

libEx.a: gcc -g -c head.c ar -rv libEx.a head.o

5.5.1 Komplexere Buildsysteme

Da das Schreiben aufwendigerer Makefiles recht aufwendig ist, kann man diesen Prozess ebenfalls automatisieren.Dazu werden meist die Tools autoconf, automake und libtool verwendet. autoconf:

autoconf erzeugt das Konfigurationsskript configure automatisch aus Systemtestsconfigure führt Systemstests aus und erstellt auf der Basis von Vorlagen in jedem Unterverzeichnis(Makefile.in) Makefiles (ebenfalls für jedes Unterverzeichnis)autoconf ist durch eigene Tests erweiterbar

automake:

automake erstellt die Vorlagen für autoconf (Makefile.in) aus einfach editierbaren Files: Makefile.am

libtool:

libtool ist ein Frontend für den Compilerlibtool weiß von welchen Programmen und mit welchen Optionen auf verscheidenen Systemen mitverschiedenen Compilern Programme compiliert und gelinkt werden.

Inzwischen verwenden fast alle OpenSource-Projekte ein Buildsystem aus autoconf/automake/libtool/make. DieSoftware, die man frei aus dem Internet herunterladen kann, läßt sich dann mit folgender Befehlssequenzcompilieren und installieren:

./configure make make install

Mit dem Aufruf von ./configure --help bekommt man eine Übersicht über die Optionen des jeweiligen configure-Skripts. Zum Erstellen des Buildvorgangs sind die Tools autoconf, automake und libtool notwendig. Sind einmal dasconfigure-Skript und die Makefile.in-Files vorhanden, benötigt man sie nicht mehr.


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 5. Programmieren unter Linux > 5.5 Buildsysteme



5.6 Testen und Debuggen

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/5-programmieren-unter-linux/56-testen-und-debuggen/?L=0[01.02.2011 17:31:28]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell




7. Aufgaben

II. C

III. C++

5.6 Testen und Debuggen

Debuggen (gdb, ddd):

Anwendung: Fehlersuche (systematisches Aufstellen und Prüfen von Hypothesen)schrittweise kontrollierte Ausführung des ProgrammsÜberwachung von Variablenbedingte Programmablaufsteuerunggraphische Darstellung von Speicherinhalten

Testen:

eigene TestprogrammeUnit-Tests mit Unterstützung durch Bibliotheken: cppunit, boostz. B.: Memory Leak Checks: valgrind (OpenSource), libefence, purify, Insure, splint

5.6.1 graphische Programmierumgebungen

KDevelop, Sniff+integrierter Zugriff auf die Programmierwerkzeuge und Source-Editoren


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 5. Programmieren unter Linux > 5.6 Testen und Debuggen



5.7 CVS

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/5-programmieren-unter-linux/57-cvs/?L=0[01.02.2011 17:31:29]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell




7. Aufgaben

II. C

III. C++

5.7 CVS

CVS = Concurrent Version System

Versionierung von ganzen DateibäumenParalleles Arbeiten möglicharbeitet auf Textfiles und vergleicht zeilenweiseKonflikte bei Änderung an gleicher Stelle: Files werden mit merge vereinigt. Wenn 2 Zeilen gleich sind,bleiben beide Versionen erhalten und werden markiert. Der Konflikt muß dann von Hand gelöst werden.

Vorteile:

Kontrolle über verschiedene VersionenWiederherstellen von ganzen Konfigurationenkeine Blockadencvs ist ein weitverbreitetes System

Nachteile:

hoher Plattenplatzbedarf (vor allem bei binären Dateien)Konflikte möglich (von Hand aufzulösen)

cvs import, cvs add: Daten unter CVS-Kontrolle stellencvs checkout: Lokale Kopiecvs commit: Einchecken, Log-Eintrag wird abgefragt und ist später einsehbarcvs update: Lokales Verzeichnis auf neuesten Stand bringencvs log: Ansehen der Logscvs annotate: Anzeige einer Datei mit Angabe, von wem und aus welchem Version jede Zeile stammtcvs tag: Vergabe eines Namens für ein Set von Dateien, evtl. Starten einer neuen, parallelenEntwicklungslinie (branch)cvs add: Hinzufügen einer Datei aus dem Repositorycvs remove: Entfernen einer Datei aus dem Repository, Geschichte der Datei bleibt erhalten


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 5. Programmieren unter Linux > 5.7 CVS




http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/6-literaturhinweise/?L=0[01.02.2011 17:30:38]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell



7. Aufgaben

II. C

III. C++


1. Unix, eine Einführung in die Benutzung. Vom RRZN der Universität Hannover. 12. Auflage, 1998.2. Zeller und Krinke: Programmierwerkzeuge. dpunkt-verlag, ISBN 3-932588-70-33. Der UNIX-Werkzeugkasten - Programmieren mit UNIX, von B. Kernighan und R. Pike. Carl Hanser Verlag,

1984.4. Unix, eine Einführung in die Benutzung. Vom RRZN der Universität Hannover. 12. Auflage, 1998.5. UNIX System V - Professionelles Programmieren von R. Thomas, L. Rogers und J. Yates.

OsborneMcGrawHill Verlag, 1987.6. Die Programmiersprache C: Ein Nachschlagewerk. Vom RRZN der Universität Hannover. 12. Auflage, 1996.7. Numerical Recipes in C - The Art of Scientific Computing. Von W. Press, B. Flannery, S. Teukolsky und W.

Vetterling. Cambridge University Press, 1984.8. C - the Complete Reference. Von H. Schildt. OsborneMcGrawHill Verlag, 1990.9. Advanced Programming in the UNIX Environment. Von W. Stevens. Addison-Wesley, 1993.

10. Wieland, Thomas: C++ Entwicklung mit Linux. dpunkt-verlag, ISBN 3-932588-74-611. Stroustroup, Bjarne: Die C++ Programmiersprache. 4. aktualisierte und erweiterte Auflage,

Studentenausgabe. Addison-Wesley, 2000, Boston. ISBN 3-8273-1756-8 DM 69,90 (paperback) Originalausgabe: Stroustroup, Bjarne: The C++ Programming Language, Special Edition. Addison-Wesley,2000, Boston. ISBN 0-201-70073-5

12. Schildt, Herbert: C++: The Complete Reference, Third Edition. Que Corp., 1999. ISBN 0-7897-2022-1.$39.99, ca. 80 DM (paperback)

13. Meyers, Scott: Effektiv C++ programmieren. 50 Wege zur Verbesserung Ihrer Programme und Entürfe.Addison-Wesley, 1998. ISBN 3-8273-1305-8 Originalausgabe: Meyers, Scott: Effective C++ ISBN 0-201-92488-9

14. Meyers, Scott: Mehr Effektiv C++ programmieren. 35 neue Wege zur Verbesserung Ihrer Programme undEntwürfe. Addison-Wesley, 1999. ISBN 3-8273-1275-2 Originalausgabe: Meyers, Scott: More Effective C++ ISBN 0-201-63371-x

15. Kalev, Danny: The ANSI/ISO C++ Professional Programmer's Handbook. McGraw-Hill, 1998. ISBN 0-07-882476-1. $39.99, ca. 90 DM (paperback)

16. Dalheimer, M.K., Programming with Qt. O'Reilly, 2002, 2. Auflage. ISBN 0596000642, 48,49 EUR17. Sweet, David: KDE-2-Programmierung. komponentenbasierte Anwendungen mit Qt, kparts und DCOP.

Markt-und-Technik-Verl., 2001, 576 S. ISBN 3-8272-5980-0 erhähltlich bei www.terrashop.de für 13 EUR. Originalausgabe: David Sweet, Ph.D., et. al.: KDE 2.0 Development. Guide to KDE development.Macmillan/SAMS, ISBN: 0672318911


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 6. Literaturhinweise



7.1 Example 1

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/i-linux/7-aufgaben/71-example-1/?L=0[01.02.2011 17:30:39]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell



7. Aufgaben7.1 Example 17.2 Example 27.3 Example 37.4 Example 47.5 Example 5

II. C

III. C++

7.1 Example 1

In our first example we want to use the editor (kate) and do these steps:

1. change the working directory to ~/example1_1 (You may have to mkdir ~/example1_1 first!)2. start kate (type kate) at the terminal prompt3. type the following lines:

/* filename: hello_world.c */#include int main(void){ printf("Hello world \n"); return(0);}

4. save file by typing ctrl-s and specify the filename hello_world.c. Quit kate with ctrl-q; (You simplycan use the menu file on top of kate instead, of course).

5. type: gcc -o hello_world hello_world.c;6. type ls to list the directory structure you will see the files hello_world.c (Source file) and hello_world (which

should be the executable file)7. if necessary, type chmod +x hello_world to make the file hello_world executable8. type hello_world and hit return to start the programm. On the screen you see the result.


Sie befinden sich: > TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > I. Linux > 7. Aufgaben > 7.1 Example 1



7.2 Example 2


rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell




II. C

III. C++

7.2 Example 2

In the next example we want to compile 2 files together

1. mkdir ~/example1_2; cd example1_2 then start kate at the terminal prompt2. type the following lines:

/* filename: head.c */#include int head(){ printf("in procedure head \n"); return(0);}

3. save the file by typing ctrl-s and specify the filename head.c and quit kate.4. start kate again at the terminal prompt (Instead of quitting and restarting, you can simply open a new file by

ctrl-o or just use the menu.)5. type the following lines:

/* filename: example1_2.c */#include int main(void){ printf("in procedure main before calling procedure head \n"); head(); printf("in procedure main after calling procedure head \n"); return(0);}

6. type gcc -o example1_2 head.c example1_2.c7. type ls and you will see the files: head.c, example1_2.c, and the file example1_2, the executable If you

type ls -alrt, you get a detailed list of all files, with the newest files at the end).8. type chmod +x example1_29. type ./example1_2 and hit the return -key to start the executable. You will see 3 lines of text which show

the chain in which the 2 procedures are called.





7.3 Example 3


rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell




II. C

III. C++

7.3 Example 3

In this example we will create a library and insert the function head which is defined in the object-file head.o (seeexample 1_2 (step6) ).

1. remain in ~/example1_2. Type gcc -c head.c. Then look at the files created (ls -alrt). What arethese *.o files?

2. Create a library typing ar rv libEx.a head.o. The library contains the object-file Ex now.3. now list the contents of the library by typing ar tv libEx.a.4. now delete the file example1_2 by typing rm example1_2 . If you are asked, if you really want to remove

the file type y to confirm the remove5. now delete the file head.o by typing rm head.o. If you are asked, if you really want to remove the file type

y to confirm the remove6. check with ls what happend to the files.7. it is time to compile the file again. at this time use: gcc -o example1_3 example1_2.c libEx.a (You

can also use the more sophisticated version gcc example1_2.c -L. -lEx -o example1_3).8. see with ls which files are created





7.4 Example 4


rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell




II. C

III. C++

7.4 Example 4

In this example we will create a mechanism for automation, which is a file called Makefile.

1. start kate2. type:

example1_4:example1_2.o head.o gcc example1_2.o head.o -o example1_4

example1_2.o: example1_2.c

head.o: head.c

Remember to use tabs instead of spaces!

3. save file by typing ctrl-s and specify the filename Makefile. Then quit kate.4. now delete the file example1_3 by typing rm example1_3. If you are asked, if you really want to remove the

file type y to confirm the remove.5. check the result by typing ls6. type make7. check the result by typing ls





7.5 Example 5


rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

2. Übersicht

3. Dateisystem

4. Shell




II. C

III. C++

7.5 Example 5

In this example we will use a debugger to search for possible bugs.

1. start kate and open the Makefile2. replace the rules to build example1_2.o and head.o by the following lines to write debuggerinformation in

your executables and rename example1_3 to example1_4:

example1_4:example1_2.o head.o gcc example1_2.o head.o -o example1_4

example1_2.o: gcc -g -c example1_2.c

head.o: gcc -g -c head.c

3. save file by typing ctrl-s and quit kate.4. now delete the files example1_4, example1_2.o and head.o by typing rm example1_4 example1_2.o

head.o. If you are asked, if you really want to remove the file type y to confirm the remove.5. check the result by typing ls.6. type make.7. check the result by typing ls.8. start the debugger DDD by typing ddd at the terminal prompt.9. Choose option open program in the menu file on top of ddd. Choose example1_4 on the list.

10. Add a breakpoint in line 5 choosing option breakpoints... ; add break in the menu source orsimply clicking right mouse button on line 5 and choose set breakpoint .

11. Run the program choosing option run in the menu program and see what happens.





II. C

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/[01.02.2011 17:31:46]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

II. C

8. Ein C-Programm


10. WichtigeSprachelemente

11. Funktionen

12. BenutzerdefinierteTypen

13. Übersetzen von C-Programmen

14. Arrays

15. Zeiger

16. Aufgaben

III. C++

Vorbemerkungen

Aufbau

Kapitel 8 bis 13 beschäftigt sich mit den Grundlagen der Sprache C wie Variablendeklarationen, Schleifen,Funktionsdeklarationen und -aufrufen. Es wird auch kurz auf den Übersetzungsprozeß eines Programmes mit Hilfedes make-Utilities eingegangen, der für eine modulare Programmierung wesentlich ist. In den Kapiteln 14 und 15werden weiterführende Merkmale der Sprache behandelt; u. a. wird die Verwendung und Verwaltung von Zeigern andieser Stelle angesprochen. Im Anhang finden sich die zwei Übungsbeispiele

,,Signalgenerator`` und,,Matrizenverwaltung mit Doppelzeigern``.

Sie sind charakteristisch für viele Problemstellungen, denen sich ein Programmierer an unserem Fachgebietgegenübersieht.

Literatur

Die Programmiersprache C ist sehr eng mit dem Betriebssystem UNIX und dessen Derivate wie etwas dem freienNachfolger Linux verbunden*. Die Literaturhinweise umfassen aus diesem Grund generelle Werke zumProgrammieren unter UNIX , Einführungsmaterial in die C-Programmierung sowie ein Werk zum wissenschaftlichenProgrammieren

*) Der Linux-Kernel und die Geräte-Treiber sind bis auf kleine Ausnahmen in C programmiert. Der Assembler-Anteilliegt bei TU Darmstadt > ETIT > IAT > RTR > Lehre > E-Learning > C/C++-Onlinekurs > II. C


http://www1.rtr.tu-darmstadt.de/startseite/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/8-ein-c-programm/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/9-variablen-datentypen/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/10-wichtige-sprachelemente/101-ein-ausgabe-mit-printf-scanf/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/10-wichtige-sprachelemente/101-ein-ausgabe-mit-printf-scanf/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/11-funktionen/111-funktionsprototypen/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/12-benutzerdefinierte-typen/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/12-benutzerdefinierte-typen/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/13-uebersetzen-von-c-programmen/131-zerlegung-in-module/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/13-uebersetzen-von-c-programmen/131-zerlegung-in-module/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/14-arrays/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/15-zeiger/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/16-aufgaben/161-ein-signalgenerator-in-c/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/iii-c/?L=0http://tasha.rt.e-technik.tu-darmstadt.de/fileadmin/cppkurs/footnode.html#foot1477http://www.tu-darmstadt.de/http://www.tu-darmstadt.de/etit/http://www.iat.tu-darmstadt.de/http://www1.rtr.tu-darmstadt.de/startseite/?L=0http://www1.rtr.tu-darmstadt.de/lehre/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/?L=0http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/?L=0http://www1.rtr.tu-darmstadt.de/?id=459&L=|http://www1.rtr.tu-darmstadt.de/index.php?id=531&L=0&type=98http://www1.rtr.tu-darmstadt.de/index.php?id=531&L=0http://www1.rtr.tu-darmstadt.de/index.php?id=531&L=1http://www1.rtr.tu-darmstadt.de/index.php?id=531&L=2http://www1.rtr.tu-darmstadt.de/index.php?id=531&L=3http://www.tu-darmstadt.de/

8. Ein C-Programm

http://www1.rtr.tu-darmstadt.de/lehre/e-learning/cc-onlinekurs/ii-c/8-ein-c-programm/[01.02.2011 17:31:47]

rtr Startseite

Einführung

Inhalt

1. Vorbemerkungen

I. Linux

II. C

8. Ein C-Programm


10. WichtigeSprachelemente

11. Funktionen

12. BenutzerdefinierteTypen

13. Übersetzen von C-Programmen

14. Arrays

15. Z

Fachgebiet Regelungstheorie und Robotik · Einführung 17:30:21] rtr Startseite Einführung Inhalt

Documents

Transcript of Fachgebiet Regelungstheorie und Robotik · Einführung 17:30:21] rtr Startseite Einführung Inhalt