Permalink
Browse files

added code of "Der C++ Programmierer" (Breymann) in cppbuch

Signed-off-by: Stefan Naewe <stefan.naewe@atlas-elektronik.com>
  • Loading branch information...
1 parent 3921afb commit 5b31490512c938f50e62cdd9e8e9bc97ed5869c1 Stefan Naewe committed Jun 9, 2009
Showing 802 changed files with 27,940 additions and 0 deletions.
View
@@ -0,0 +1,29 @@
+/* cppbuch/include/Random.h
+ Beispiel zum Buch von Ulrich Breymann: Der C++ Programmierer; Hanser Verlag
+ Diese Software ist freie Software. Website zum Buch: http://www.cppbuch.de/
+*/
+#ifndef RANDOM_H
+#define RANDOM_H
+#include<cstdlib>
+
+class Random {
+ public:
+ Random(size_t g = 100)
+ : grenze(g) {
+ }
+ void setSeed(size_t seed) {
+ srand(seed);
+ }
+ // gibt eine size_t-Pseudo-Zufallszahl zwischen 0 und range-1 zurück
+ size_t operator()(size_t range) {
+ return (size_t)((double)rand()*range/(RAND_MAX+1.0));
+ }
+ // gibt eine size_t-Pseudo-Zufallszahl zwischen 0 und grenze-1 zurück
+ size_t operator()() {
+ return (size_t)((double)rand()*grenze/(RAND_MAX+1.0));
+ }
+ private:
+ size_t grenze;
+};
+
+#endif
View
@@ -0,0 +1,87 @@
+/* cppbuch/include/ansi_esc.h
+ Beispiel zum Buch von Ulrich Breymann: Der C++ Programmierer; Hanser Verlag
+ Diese Software ist freie Software. Website zum Buch: http://www.cppbuch.de/
+*/
+/* Headerdatei fuer ANSI-ESC-Steuersequencen zur Bildschirm-
+ und Cursorsteuerung für Unix-Workstations und PCs.
+ ACHTUNG: Nicht alle Betriebssysteme unterstützen diese
+ Steuersequencen!
+
+ Die Sequenzen gehen auf zurück auf die VT100-Terminalreihe von DEC.
+ Viele andere Terminals sind konform dazu. Einzelheiten siehe
+ http://www.vt100.net/ Eine vollstänige Liste der Steuersequenzen
+ findet man in
+ http://vt100.net/docs/vt100-ug/ bzw.
+ http://vt100.net/docs/vt102-ug/
+
+ PC-MSDOS: Voraussetzung: ANSI-Treiber in der config.sys einbinden.
+
+ Win 95/98/NT: Ins Windows-Verzeichnis, z.B. C:\Windows oder
+ C:\winnt gehen, dort im Verzeichnis system32 in der Datei
+ autoexec.nt oder config.nt die Zeile
+ device=%SystemRoot%\system32\ansi.sys
+ eintragen.
+ ANSI.SYS stimmt nur in Teilen mit den VT100/VT102-Codes überein.
+
+ Windows XP: ansi.sys wird NICHT unterstützt!
+
+ Linux: fast alle Codes werden unterstützt.
+
+ Bei Problemen mit Betriebssystemen wenden Sie sich bitte an
+ den Hersteller, nicht an mich, oder suchen Sie auf deren
+ Hilfe-Seiten im internet (MS-Knowledge Base u.a.) (danke! U.B.).
+
+ Aufruf der Bildschirm- und Cursorsteuerung wie Funktionsaufruf,
+ z.B.: cls(); gotoxy(10, 50);
+
+ Farbsteuerung durch Ausgabe, z.B.:
+ cout << vrot << hgruen << "Roter Text auf grünem Hintergrund!";
+ // weitere Ausgaben ....
+ normal(); // zurück zur normalen Bildschirmdarstellung
+
+ Die folgenden Makros enthalten die wichtigsten Steuersequenzen.
+*/
+#ifndef ansi_esc_h
+#define ansi_esc_h
+#include<iostream>
+
+// Bildschirmsteuerung
+#define cls() std::cout << "\033[2J" // Bildschirm loeschen
+#define cll() std::cout << "\033[K" // Zeile loeschen
+#define hhell() std::cout << "\033[7m" // heller Hintergrund
+#define blink() std::cout << "\033[5m" // Blinken ein
+#define normal() std::cout << "\033[0m" // Normaldarstellung
+
+// Cursorsteuerung
+#define cauf(x) std::cout << "\033[" << (x) << "A" // Cursor um x nach oben
+#define cab(x) std::cout << "\033[" << (x) << "B" // Cursor um x nach unten
+#define cli(x) std::cout << "\033[" << (x) << "D" // Cursor um x nach links
+#define cre(x) std::cout << "\033[" << (x) << "C" // Cursor um x nach rechts
+#define home() std::cout << "\033[H" // Cursor gohome
+#define pos() std::cout << "\033[s" // Cursor Position speichern
+#define zurpos() std::cout << "\033[u" // Cursor zur gesp. Position
+// Cursor positionieren (Zeile,Spalte):
+#define gotoxy(x,y) std::cout << "\033["<<(x)<<";"<<(y)<<"H"
+
+// Farben der Zeichen (v=Vordergrund)
+#define vrot "\033[1;31m" // Rote Zeichen
+#define vgruen "\033[1;32m" // Gruene Zeichen
+#define vgelb "\033[1;33m" // Gelbe Zeichen
+#define vblau "\033[34m" // Blaue Zeichen
+#define vviolett "\033[1;35m" // Violette Zeichen
+#define vcyan "\033[36m" // Cyanblaue Zeichen
+#define vweiss "\033[1;37m" // Weisse Zeichen
+#define vschwarz "\033[0;30m" // Schwarze Zeichen
+
+//Farben des Hintergrundes
+#define hrot "\033[41m" // Roter Hintergrund
+#define hgruen "\033[42m" // Gruener Hintergrund
+#define hgelb "\033[1;43m" // Gelber Hintergrund
+#define hblau "\033[44m" // Blauer Hintergrund
+#define hviolett "\033[1;45m" // Violetter Hintergrund
+#define hcyan "\033[46m" // Cyanblauer Hintergrund
+#define hweiss "\033[1;47m" // Weisser Hintergrund
+#define hschwarz "\033[0;40m" // Schwarzer Hintergrund
+
+#endif
+
View
@@ -0,0 +1,218 @@
+/* cppbuch/include/array2d.h
+ Beispiel zum Buch von Ulrich Breymann: Der C++ Programmierer; Hanser Verlag
+ Diese Software ist freie Software. Website zum Buch: http://www.cppbuch.de/
+*/
+#ifndef ARRAY2D_H
+#define ARRAY2D_H
+// 2-dim. Array-Klasse mit zusammenhängendem (contiguous) Memory-Bereich
+#include<stdexcept>
+#include<utility>
+#include<algorithm>
+#include<iostream>
+// ggf auskommentieren
+//#define TEST
+
+#ifdef TEST
+#define TESTAUSGABE(x) std::cout << #x << std::endl
+#else
+#define TESTAUSGABE(x) /* nichts */
+#endif
+
+// Indexprüfung:
+// Wie bei der Standard-Vector-Klasse ist der Zugriff über [][] ungeprüft,
+// der Zugriff über at(i, j) geprüft.
+// Ansonsten ist die Klasse teilweise STL-kompatibel
+
+template<typename T>
+class Array2d {
+ public:
+ // Typedefs wegen STL-Konformität
+ typedef T value_typ;
+ typedef T& reference;
+ typedef T* iterator;
+ typedef const T* const_iterator;
+ typedef T* pointer;
+ typedef const T* const_pointer;
+ typedef int difference_type;
+ typedef unsigned int size_type;
+
+ Array2d(int zeilen, int spalten);
+ Array2d(int zeilen, int spalten, const T& init);
+ Array2d(const Array2d& a);
+ Array2d(Array2d&& a);
+ ~Array2d();
+ Array2d& operator=(const Array2d& a);
+ Array2d& operator=(Array2d&& a);
+ int getZeilen() const;
+ int getSpalten() const;
+ void init(const T& wert); // Alle Elemente mit wert initialisieren
+ const T& at(int z, int s) const;
+ T& at(int z, int s);
+ const T* operator[](int z) const;
+ T* operator[](int z);
+ const T* data() const;
+ // STL-entsprechende Funktionen
+ size_t size() const { return zeilen*spalten;}
+ iterator begin() { return arr;}
+ iterator end() { return arr + zeilen*spalten;}
+ const_iterator begin() const { return arr;}
+ const_iterator end() const { return arr + size();}
+ const_iterator cbegin() const { return arr;}
+ const_iterator cend() const { return arr + size();}
+ void swap(Array2d& a);
+ private:
+ void checkIndizes(int z, int s) const;
+ void checkDimension(const Array2d<T>& a) const;
+ int zeilen;
+ int spalten;
+ T* arr;
+};
+
+
+// relationale Operatoren
+template<typename T>
+bool operator==(const Array2d<T>& a, const Array2d<T>& b) {
+ if(a.getZeilen() != b.getZeilen()) return false;
+ if(a.getSpalten() != b.getSpalten()) return false;
+ return std::equal(a.begin(), a.end(), b.begin());
+}
+
+template<typename T>
+bool operator<(const Array2d<T>& a, const Array2d<T>& b) {
+ return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
+}
+// um aus == und < alle anderen relationalen Operatoren bei Bedarf
+// automatisch zu bilden:
+using namespace std::rel_ops;
+
+// Konstruktoren
+template<typename T>
+Array2d<T>::Array2d(int z, int s)
+ : zeilen(z), spalten (s),
+ arr(new T[z*s]) {
+}
+
+template<typename T>
+Array2d<T>::Array2d(int z, int s, const T& wert)
+ : zeilen(z), spalten (s), arr(new T[z*s]) {
+ init(wert);
+}
+
+template<typename T>
+Array2d<T>::Array2d(const Array2d<T>& a)
+ : zeilen(a.getZeilen()), spalten (a.getSpalten()),
+ arr(new T[zeilen*spalten]) {
+ for(size_t i = 0; i < size(); ++i) {
+ arr[i] = a.arr[i];
+ }
+ TESTAUSGABE(Array2d(const Array2d<T>& a));
+}
+
+template<typename T>
+Array2d<T>::Array2d(Array2d<T>&& a) // moving Kopierkonstruktor
+ : zeilen(0), spalten(0), arr(0) {
+ swap(a);
+ TESTAUSGABE(Array2d(const Array2d<T>&& a) (move));
+}
+
+template<typename T>
+void Array2d<T>::swap(Array2d<T>& a) {
+ int tmpzeilen = zeilen;
+ int tmpspalten = spalten;
+ T* tmparr = arr;
+ zeilen = a.zeilen;
+ spalten = a.spalten;
+ arr = a.arr;
+ a.zeilen = tmpzeilen;
+ a.spalten = tmpspalten;
+ a.arr = tmparr;
+}
+
+template<typename T>
+Array2d<T>::~Array2d() {
+ delete [] arr;
+}
+
+template<typename T>
+Array2d<T>& Array2d<T>::operator=(const Array2d<T>& a) {
+ checkDimension(a);
+ for(size_t i = 0; i < size(); ++i) {
+ arr[i] = a.arr[i];
+ }
+ TESTAUSGABE(operator=(const Array2d<T>& a));
+ return *this;
+}
+
+template<typename T>
+Array2d<T>& Array2d<T>::operator=(Array2d<T>&& a) {
+ swap(a);
+ TESTAUSGABE(operator=(const Array2d<T>&& a) (move));
+ return *this;
+}
+
+template<typename T>
+inline int Array2d<T>::getZeilen() const { return zeilen; }
+
+template<typename T>
+inline int Array2d<T>::getSpalten() const { return spalten; }
+
+template<typename T>
+void Array2d<T>::init(const T& wert) {
+ for(size_t i = 0; i < size(); ++i) {
+ arr[i] = wert;
+ }
+}
+
+template<typename T>
+inline const T* Array2d<T>::operator[](int z) const {
+ return &arr[z*spalten];
+}
+
+template<typename T>
+inline T* Array2d<T>::operator[](int z) {
+ return &arr[z*spalten];
+}
+
+template<typename T>
+inline void Array2d<T>::checkIndizes(int z, int s) const {
+ if(z < 0 || z >= zeilen)
+ throw std::range_error("Array2d: Zeile ausserhalb des erlaubten Bereichs");
+ if(s < 0 || s >= spalten)
+ throw std::range_error("Array2d: Spalte ausserhalb des erlaubten Bereichs");
+}
+
+template<typename T>
+inline void Array2d<T>::checkDimension(const Array2d<T>& a) const {
+ if(zeilen != a.getZeilen() || spalten != a.getSpalten())
+ throw std::range_error("Array2d: ungleiche Zeilen-/Spaltenanzahl");
+}
+
+template<typename T>
+inline const T& Array2d<T>::at(int z, int s) const {
+ checkIndizes(z, s);
+ return arr[z*spalten + s];
+}
+
+template<typename T>
+inline T& Array2d<T>::at(int z, int s) {
+ checkIndizes(z, s);
+ return arr[z*spalten + s];
+}
+
+template<typename T>
+inline const T* Array2d<T>::data() const {
+ return arr;
+}
+
+
+// Globale Funktion zur Ausgabe
+template<typename T>
+void printArray(const Array2d<T>& a) {
+ for(int z=0; z < a.getZeilen(); ++z) {
+ for(int s=0; s < a.getSpalten(); ++s) {
+ std::cout << a[z][s] << " ";
+ }
+ std::cout << std::endl;
+ }
+}
+#endif
@@ -0,0 +1,17 @@
+/* cppbuch/include/ersatziota.h
+ Beispiel zum Buch von Ulrich Breymann: Der C++ Programmierer; Hanser Verlag
+ Diese Software ist freie Software. Website zum Buch: http://www.cppbuch.de/
+*/
+#ifndef IOTA_H
+#define IOTA_H
+
+// Diese Datei stellt iota() zur Verfügung, falls es der Compiler
+// nicht tut (Header <numeric>. Dies gilt für
+// GNU C++ Version 4.3 und kleiner.
+template <class ForwardIterator, class T>
+void iota(ForwardIterator first, ForwardIterator last, T value) {
+ while (first != last) {
+ *first++ = value++;
+ }
+}
+#endif
Oops, something went wrong.

0 comments on commit 5b31490

Please sign in to comment.