Klassische Mechanik mit C++: Basics und Anwendungen 9783662609040, 9783662609057, 3662609045

Citation preview

Elias Posoukidis

Klassische Mechanik mit C++ Basics und Anwendungen

Klassische Mechanik mit C++

Elias Posoukidis

Klassische Mechanik mit C++ Basics und Anwendungen

Elias Posoukidis Essen, Deutschland

Ergänzendes Material zu diesem Buch finden Sie auf http://www.springer.com/978-3-662-60904-0. ISBN 978-3-662-60904-0 ISBN 978-3-662-60905-7  (eBook) https://doi.org/10.1007/978-3-662-60905-7 Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar. © Springer-Verlag GmbH Deutschland, ein Teil von Springer Nature 2020 Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung, die nicht ausdrücklich vom Urheberrechtsgesetz zugelassen ist, bedarf der vorherigen Zustimmung des Verlags. Das gilt insbesondere für Vervielfältigungen, Bearbeitungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung und Verarbeitung in elektronischen Systemen. Die Wiedergabe von allgemein beschreibenden Bezeichnungen, Marken, Unternehmensnamen etc. in diesem Werk bedeutet nicht, dass diese frei durch jedermann benutzt werden dürfen. Die Berechtigung zur Benutzung unterliegt, auch ohne gesonderten Hinweis hierzu, den Regeln des Markenrechts. Die Rechte des jeweiligen Zeicheninhabers sind zu beachten. Der Verlag, die Autoren und die Herausgeber gehen davon aus, dass die Angaben und Informationen in diesem Werk zum Zeitpunkt der Veröffentlichung vollständig und korrekt sind. Weder der Verlag, noch die Autoren oder die Herausgeber übernehmen, ausdrücklich oder implizit, Gewähr für den Inhalt des Werkes, etwaige Fehler oder Äußerungen. Der Verlag bleibt im Hinblick auf geografische Zuordnungen und Gebietsbezeichnungen in veröffentlichten Karten und Institutionsadressen neutral. Planung/Lektorat: Lisa Edelhäuser Springer Spektrum ist ein Imprint der eingetragenen Gesellschaft Springer-Verlag GmbH, DE und ist ein Teil von Springer Nature. Die Anschrift der Gesellschaft ist: Heidelberger Platz 3, 14197 Berlin, Germany

Vorwort Möchte man ein physikalisches Problem quantitativ beschreiben, bedeutet dies, seine charakteristischen Eigenschaften zu identifizieren und diese als Parameter von Gleichungen in einem mathematischen Modell darzustellen. Ist eine analytische Lösung der Gleichungen nicht möglich, werden numerische Methoden eingesetzt und Näherungslösungen berechnet. Wie gut diese Lösungen bzw. das Modell sind, hängt davon ab, wie gut die Vorhersagen des Modells mit den experimentellen Ergebnissen übereinstimmen. Ein Computermodell ist die Abbildung des mathematischen Modells mithilfe von Computerprogrammen. Betrachtet man Physikaufgaben als Beschreibungen von stark idealisierten physikalischen Prozessen, tragen sie dazu bei, ein Gespür dafür zu entwickeln, welche Parameter für die Modellierung eines Prozesses relevant sind, was Voraussetzung für die Lösung eines Problems ist. Sie bilden deshalb eine ideale Basis, um die Konstruktion von Modellen zu üben. Ein Lehrbuch über Computerphysik muss Methoden vorstellen, die zeigen, wie Computeralgorithmen zur Lösung physikalischer Probleme entworfen werden. Hier gibt es zwei Alternativen bezüglich der Themenauswahl: Eine ist, aus dem Spektrum der Aufgaben diejenigen herauszusuchen, für die keine analytische Lösung existiert oder bekannt ist und diese dann mittels numerischer Methoden zu lösen. Eine andere ist, Aufgaben, so wie sie in den meisten Lehrbüchern zu finden sind, zu nehmen und diese neben den analytischen auch mit numerischen Methoden zu untersuchen. An dieser Stelle setzt dieses Buch an. Es zeigt, wie aus analytisch hergeleiteten Formeln ein Computermodell entworfen wird und wie neben den analytischen Lösungen der Gleichungen auch mittels numerischer Verfahren Daten generiert werden. Jede der behandelten Aufgaben wird detailliert gelöst. Dies soll Zeit und Nerven sparen und, was noch wichtiger ist, den Übergang zum Computermodell durch die Gegenüberstellung von Lösung und Quelltext verständlich machen. Die Auswahl der Aufgaben wurde so getroffen, dass ein gewisser Grad an Komplexität vorhanden ist, sodass die dazugehörigen Algorithmen nicht mit wenigen Zeilen umzusetzen sind. Am Ende soll der Leser in der Lage sein, das Erlernte in eigene Arbeiten einfließen zu lassen. Der vorliegende erste Band ist in drei Teile gegliedert und beginnt mit einer Tour durch C++. Auf eine allgemeine Einführung in C++ wurde wegen des Umfangs der Sprache verzichtet. Stattdessen werden anhand von Beispielen ausgewählte Elemente der Sprache vorgestellt, welche für das Verständnis der Programme im weiteren Verlauf des Buches wichtig sind. Jedes Kapitel wird mit Beispielen aus der Mathematik oder Physik begleitet. Der zweite Teil des Buches befasst sich mit numerischen Algorithmen. Hier wurde der Versuchung widerstanden, die Algorithmen selbst zu programmieren, denn dies hätte eine weitere Hürde für den Leser bedeutet und die Einarbeitungszeit verlängert. Statt dessen wird die GNU Scientific Library (in diesem Buch auch gsl abgekürzt) eingesetzt. Es handelt sich hierbei um eine in C geschriebene Bibliothek numerischer Algorithmen, die fast alles auf diesem Gebiet abdeckt. Die Verwandtschaft von C++ und C wird genutzt und gezeigt, wie durch das Kapseln der C-Funktionen in C++-Klassen das Programmieren mit

vi

Vorwort

der Bibliothek vereinfacht wird. Nicht die ganze Funktionalität der gsl wird abgedeckt, sondern nur die Teile, die für das Lösen der Aufgaben des Buches notwendig sind. Der Aufbau der Klassen orientiert sich an Beispielen, die auf der Webseite der GNU Scientific Library zu finden sind. Am Anfang von jedem Kapitel wird gezeigt, wie der Übergang von einem solchen Beispiel zu einer C++-Klasse durchgeführt wird. Am Ende sind Beispiele aus der Physik zu finden. Der dritte und letzte Teil baut auf das Wissen der beiden ersten Teile auf und zeigt, wie Computermodelle auf Basis von Physikaufgaben konstruiert werden, was im zweiten Band mit weiteren Beispielen fortgesetzt wird. Die Entscheidung modernes C++ einzusetzen folgt nicht dem derzeitigen Trend, Programme mit Skript-Sprachen zu erstellen. C++ wurde und wird immer noch als schwer zu erlernen betrachtet. Die Sprache hat sich in den letzten Jahren jedoch gewandelt. Ideen aus anderen Programmiersprachen sind in die neuen Versionen eingeflossen und das Programmieren mit C++ ist einfacher geworden. Die Länge der Quelltexte ist deutlich kürzer geworden und unterscheidet sich nicht wesentlich vom Umfang der Quelltexte anderer Sprachen, wenn diese nicht nur zur Demonstration eines Konzepts gedacht sind. Besonderer Wert wurde darauf gelegt, dass die Programme in diesem Buch nicht monolithisch aufgebaut sind, sondern aus wiederverwendbaren Komponenten bestehen. Gleichzeitig wurde auf tiefe Vererbungshierarchien verzichtet, um das Verständnis der Quelltexte zu vereinfachen. Die Quelltexte sind ausführlich kommentiert und werden in kleinen Abschnitten im Text eingebunden. Sie sollen genau wie mathematische Formeln als Fortsetzung des Textes gesehen werden. Die Kommentare in den Quelltexten ergänzen den laufenden Text. Das Buch richtet sich an Studierende der Physik und verwandter naturwissenschaftlicher Fächer, die bereits einen Grundkurs in klassischer Mechanik absolviert haben und mit der Differenzial- und Integralrechnung vertraut sind. Der Leser sollte über Grundkenntnisse in C++ verfügen oder bereit sein, sich diese anzueignen. Für die Übersetzung der Quelltexte ist ein C++-Compiler erforderlich, der den Standard C++17 unterstützt. Als IDE wurde der Qt Creator und als Compiler clang in der Version 6.0 unter Linux Mint 19 eingesetzt. Alle Quelltexte stehen unter www.springer.com/978-3-662-60904-0 zum Download bereit. Dieser Text wurde mit LATEX und dem TeXstudio-Editor erstellt. Obwohl dieses Buch mit höchster Sorgfalt geschrieben wurde, kann es trotzdem Fehler enthalten. Verbesserungsvorschläge, Bemerkungen und Hinweise sind stets willkommen. Dem Springer Verlag und insbesondere Frau Dr. Lisa Edelhäuser und Frau Anja Dochnal möchte ich für die freundliche Unterstützung danken. Mein besonderer Dank gilt meiner Familie, die während der Entstehung dieses Buches große Geduld bewiesen hat. Dezember 2019, Elias Posoukidis

Inhaltsverzeichnis Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

v

I

C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1

1 Eine Tour durch C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Standardein- und -ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Fehlerbehandlung durch Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . 1.4 STL-Container und Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5 Teilaufgaben mit Funktionen lösen . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6 λ-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7 Rechnen mit komplexen Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.8 Benutzerdefinierte Literale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.9 Statische Variablen und Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . 1.10 Präprozessor-Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.11 Schreiben und Lesen von Daten in Dateien . . . . . . . . . . . . . . . . . . 1.12 Aufzählungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.13 Zeichenketten in C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.14 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3 3 4 7 10 14 19 30 32 34 44 47 51 51 60

2 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8

Klassen in C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einfache Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Klassentemplates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Programmieren mit Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . Schnittstellen für Klassen mithilfe von Templates definieren . . . . Eigene Werkzeuge bauen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

61 61 62 87 102 111 119 128 143

3 3.1 3.2 3.3 3.4 3.5 3.6 3.7

Tabellen und Views . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Klasse für Zahlentabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Klasse für Sichten auf Tabellen . . . . . . . . . . . . . . . . . . . . . . . . Erstellen von Views auf Zahlentabellen . . . . . . . . . . . . . . . . . . . . . . Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Beispiele aus der Physik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

145 145 145 152 157 159 166 176

viii

Inhaltsverzeichnis

4 4.1 4.2 4.3 4.4 4.5

Klassen zur Modellierung von physikalischen Systemen . Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Basisklasse für Computermodelle . . . . . . . . . . . . . . . . . . . . . . Eine Komponente zur Speicherung von Rechenergebnissen . . . . . Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

177 177 178 180 183 193

II

Schnittstellen zur GNU Scientific Library . . . . . . . . . . . . . . 195

5 Die Vektor-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Vom gsl-Programm zur Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3 Entwurf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.4 Kommunikation zwischen gsl und Komponenten . . . . . . . . . . . . . . 5.5 Komponente zum Lesen und Schreiben von Vektoren . . . . . . . . . . 5.6 Komponente zum Rechnen mit Vektoren . . . . . . . . . . . . . . . . . . . . 5.7 Schnittstellen zur stl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.8 Minima und Maxima . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.9 Eigenschaften von Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.10 BLAS-Schnittstelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.11 Sicht auf einen Vektor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.12 Die Vektor-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.13 Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.14 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

197 197 198 200 201 204 206 211 212 213 214 216 217 222 240

6 Die Matrix-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2 Ein C-ähnliches Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.3 Basisfunktionalität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4 Rechnen mit Matrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5 Minimales und maximales Element einer Matrix . . . . . . . . . . . . . . 6.6 Austausch von Reihen und Spalten . . . . . . . . . . . . . . . . . . . . . . . . . 6.7 Sichten und Kopien von Reihen und Spalten . . . . . . . . . . . . . . . . . 6.8 Schnittstelle zur BLAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.9 Eigenschaften von Matrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.10 Die Matrix-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.11 Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.12 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

243 243 244 246 249 252 254 255 258 262 263 268 283

Inhaltsverzeichnis

ix

7 7.1 7.2 7.3 7.4 7.5 7.6

Lösung von linearen Gleichungssystemen . . . . . . . . . . . . . . . Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LU-Zerlegung mit der GNU Scientific Library . . . . . . . . . . . . . . . . Entwurf einer C++-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Beispielanwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Beispiele aus der Physik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

285 285 287 289 295 300 319

8 8.1 8.2 8.3 8.4 8.5 8.6

Nullstellenberechnung reeller Funktionen . . . . . . . . . . . . . . . Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zwei Beispielprogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Klasse für das Bisektionsverfahren . . . . . . . . . . . . . . . . . . . . . Eine Klasse für das Newton-Verfahren . . . . . . . . . . . . . . . . . . . . . . Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

321 321 322 327 331 335 340

9 9.1 9.2 9.3 9.4 9.5 9.6

Numerische Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Numerische Integration mit der GNU Scientific Library . . . . . . . . Klassen als Schnittstellen zur GNU Scientific Library . . . . . . . . . Berechnung von Beispielintegralen . . . . . . . . . . . . . . . . . . . . . . . . . . Beispiele aus der Physik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

341 341 342 346 353 358 375

10 Anfangswertprobleme für gewöhnliche Differenzialgleichungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.2 Ein gsl-Programm zur numerischen Lösung einer Differenzialgleichung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.3 Die Schnittstelle zur GNU Scientific Library . . . . . . . . . . . . . . . . . 10.4 Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.5 Beispiele aus der Physik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.6 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Interpolation mit der GNU Scientific Library . . . . . . . . . . . . . . . . . 11.3 Die Schnittstelle zur GNU Scientific Library . . . . . . . . . . . . . . . . . 11.4 Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.5 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

377 377 379 382 386 389 411 413 413 414 416 420 423

x

Inhaltsverzeichnis

III Klassische Mechanik mit C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 425 12 Eindimensionale Bewegungen . . . . . . . . . . . . . . . . . . . . . . . . . . 12.1 Geradlinige Bewegung mit konstanter äußerer Kraft und Gleitreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.2 Teilchen bewegt sich unter dem Einfluss einer ortsabhängigen Kraft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.3 Teilchen bewegt sich unter dem Einfluss einer zeitabhängigen Kraft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

427

440 446

13 Bewegung in einem Medium mit Reibung . . . . . . . . . . . . . . 13.1 Bewegung mit Reibung nach Stokes . . . . . . . . . . . . . . . . . . . . . . . . . 13.2 Bewegung mit Reibung nach Newton . . . . . . . . . . . . . . . . . . . . . . . 13.3 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

449 449 456 464

427 434

14 Schwingungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467 14.1 Harmonische Schwingung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467 14.2 Schwingung in vertikaler Richtung eines Systems aus zwei Massen475 14.3 Harmonische Schwingungen mit Dämpfung . . . . . . . . . . . . . . . . . . 482 14.4 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496 Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501

Teil I C++

1 Eine Tour durch C++

Übersicht 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 1.10 1.11 1.12 1.13 1.14

1.1

Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Standardein- und -ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fehlerbehandlung durch Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . STL-Container und Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Teilaufgaben mit Funktionen lösen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . λ-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rechnen mit komplexen Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Benutzerdefinierte Literale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Statische Variablen und Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Präprozessor-Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Schreiben und Lesen von Daten in Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Aufzählungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zeichenketten in C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3 4 7 10 14 19 30 32 34 44 47 51 51 60

Einleitung

Eine so mächtige Programmiersprache wie C++ in wenigen Seiten vorzustellen, ist unmöglich. Das Angebot an Funktionen und Programmiermethoden ist so groß, dass zwangsläufig eine Auswahl stattfinden muss. Doch welche Teile der Sprache sind wichtig und welche nicht? Eine eindeutige Antwort auf diese Frage gibt es nicht, denn die Sprache wird von einem Systemprogrammierer anders als von einem Naturwissenschaftler und nochmal anders von einem Spielentwickler genutzt. Es macht deswegen Sinn, sich auf Themen zu konzentrieren, die für eigene Projekte nützlich sind, was Gegenstand dieses Kapitels ist. Ziel des Buchs ist, mithilfe von C++ eine Sammlung von Komponenten zu programmieren, welche die Erstellung von physikalischen Modellen vereinfacht. Dies ist dann erreicht, wenn z.B. die Lösung eines linearen Gleichungssystems mit 3-4 Programmzeilen implementiert ist. Idealerweise entsteht am Ende keine lose Sammlung von Komponenten, sondern nur solche die Wiederholungen von Quelltexten minimieren. Wir wollen dabei nicht das Rad neu erfinden, sondern nur die eigene Kreativität in den Aufbau von Programmen einfließen lassen. (Seit C++17 können Funktionen, Klassen usw.

© Springer-Verlag GmbH Deutschland, ein Teil von Springer Nature 2020 E. Posoukidis, Klassische Mechanik mit C++, https://doi.org/10.1007/978-3-662-60905-7_1

4

1 Eine Tour durch C++

direkt in Header-Dateien geschrieben werden, ohne die One Definition Rule zu verletzen, wovon wir Gebrauch machen werden. Der Begriff Programm wird oft als Synonym für eine Funktion gebraucht, wenn diese durch Kompilierung eine ausführbare Datei erzeugen kann. Die Verwendung von englischen Begriffen in der Computerliteratur hat sich so durchgesetzt, das es sich teilweise nicht vermeiden lässt, bestimmte Wörter im Text einfließen zu lassen, wie z.B. Compiler an Stelle von Übersetzer oder View für Sicht usw.)

1.2

Standardein- und -ausgabe

Eine typische Aufgabe von Computerprogrammen ist, Daten über die Tastatur einzulesen, diese zu verarbeiten und anschließend auf dem Bildschirm anzuzeigen. Die Ein- und Ausgabe der Daten basiert auf der Idee, eine Folge von Bytes von einem Eingabemedium, hier die Tastatur, in einem Ausgabemedium wie den Bildschirm «fließen» zu lassen. In C++ wird dies mit Elementen der iostream-Bibliothek umgesetzt. Die Kombination aus std::cout, einem globalen Objekt dieser Bibliothek, und des überladenen Operators Daten an Variablen weiterleitet.

1.2.1

Beispielanwendungen

Ausgabe von Zahlen auf dem Bildschirm Wir wollen in diesem Abschnitt mit einem Programm beginnen, welches statt eines Hello World Zahlen und ihre Quadrate in die Standardausgabe schreibt. Wir durchlaufen in einer Schleife die Werte von -2 bis 2 und geben diese und ihre Quadrate in jeweils einer neuen Zeile aus. Die Breite jeder Ausgabe wird über std::setw festgelegt. /** * @brief ex1 Zahlen und ihre Quadrate werden in die Standardausgabe * geschrieben */ inline void ex1 () { for ( double x = -2; x