Michael Schmitt wrote: > Since quite a long time I have noticed that the vertical distance between the > lines in paragraphs of format "lyx code" varies even though you can't see any > difference on screen. The reason for the different amount of space is related to \newline statements in the lyx document. I have attached a file that includes several places with lyx code that are printed with varying spaces. I don't have the faintest idea what I did to get the different results (and I really didn't want to get them; I always prefer the compact presentation). Any comments are welcome. Michael -- ====================================================================== Michael Schmitt phone: +49 451 500 3725 Institute for Telematics secretary: +49 451 500 3721 Medical University of Luebeck fax: +49 451 500 3722 Ratzeburger Allee 160 eMail: [EMAIL PROTECTED] D-23538 Luebeck, Germany WWW: http://www.itm.mu-luebeck.de ======================================================================
#LyX 1.1 created this file. For more info see http://www.lyx.org/ \lyxformat 218 \textclass foils \options dvips,footrule \language german \inputencoding latin1 \fontscheme default \graphics default \paperfontsize 17 \spacing single \papersize a4paper \paperpackage a4 \use_geometry 0 \use_amsmath 0 \paperorientation portrait \secnumdepth 3 \tocdepth 3 \paragraph_separation skip \defskip medskip \quotes_language english \quotes_times 2 \papercolumns 1 \papersides 1 \paperpagestyle foilheadings \layout Standard \latex latex \backslash MyLogo{Institut für Telematik} \layout Foilhead Zeiger und Referenzen \layout Standard C++-Datentypen: \layout Itemize Einfache Datentypen \layout Itemize Zusammengesetzte Datentypen \layout Itemize \series bold Zeiger (engl.: Pointer) \layout Itemize \series bold Referenzen \layout Itemize Klassen \layout Itemize Template-Klassen \layout Standard Kontext: \layout Itemize Variablendeklaration/-definition \layout Itemize Zuweisungen, Referenzierung, Dereferenzierung \layout Itemize Funktionsaufrufe (formale und aktuelle Parameter) \layout Foilhead Zeiger (1) \layout Itemize \added_space_bottom bigskip Zeiger enthalten die \emph on Adresse \emph default eines Objekts/Datentyps; \newline sie \emph on verweisen \emph default auf ein Objekt, sind also nicht das Objekt selbst! \layout Itemize Variablendeklaration/-definition \begin_deeper \layout LyX-Code \size small \newline int *ip1, *ip2, i3; \newline Rational *objp; \newline \layout Standard Achtung: \lang american \family typewriter \size small \lang german i3 \family default \size default ist \emph on kein \emph default Zeiger, sondern ein Integer-Wert! \end_deeper \layout Itemize Referenzierung (Operator \family typewriter & \family default ) \begin_deeper \layout LyX-Code \size small \newline ip1 = &i3; // Adressoperator \newline ip2 = ip1; \newline \end_deeper \layout Itemize Dereferenzierung (Operatoren \family typewriter * \family default und \family typewriter -> \family default ) \begin_deeper \layout LyX-Code \size small \newline int i = 42, *ip = &i; \newline Rational obj, *objp = &obj; \newline \newline *ip = *ip + 1; // inkrementiert i \newline cout << *ip << endl; \newline ( *objp ).read(); \newline objp -> write(); \end_deeper \layout ShortFoilhead Zeiger (2) \layout Itemize Funktionsaufrufe: \begin_deeper \layout LyX-Code \size small \newline void foo( Rational *obj ) \newline { \newline obj -> read(); \newline } \newline \newline int main() \newline { \newline Rational obj, *objp = &obj; \newline \newline foo( &obj ); \newline foo( objp ); \newline } \newline \layout Standard Funktionen mit Zeiger-Parametern sind in der Regel nicht nebeneffekt-frei; ihr Aufruf entspricht einem \emph on call-by-reference \end_deeper \layout Itemize Jede (nicht-statische) Methode einer Klasse definiert implizit einen Zeiger namens \emph on this \emph default auf das zu behandelnde Objekt \layout Standard Achtung: \layout Itemize Zeiger, die momentan auf kein Objekt verweisen, sollten den Wert \begin_inset Formula \( 0 \) \end_inset erhalten! \layout Itemize Zeiger werden nicht automatisch initialisiert, sondern haben als Wert eine zufällige Adresse im Speicher! \layout Foilhead Speicherverwaltung \layout Itemize Dynamisches Erzeugen von Variablen und Objekten mit \emph on new \emph default : \begin_deeper \layout Enumerate \added_space_top bigskip Reservierung von Speicher \layout Enumerate \added_space_bottom bigskip Aufruf des Konstruktors \layout Standard Beispiele: \layout LyX-Code \size small \newline int *i = new int; \newline int *iFeld = new int[ 10 ]; \newline Rational *obj = new Rational( 2, 4 ); \newline Rational *objFeld = new Rational[ 10 ]; \newline \size default \end_deeper \layout Itemize Freigeben von Variablen und Objekten mit \emph on delete \emph default : \begin_deeper \layout Enumerate \added_space_top bigskip Aufruf des Destruktors \layout Enumerate \added_space_bottom bigskip Freigeben von alloziiertem Speicher \layout Standard Beispiele: \layout LyX-Code \size small \newline delete i; \newline delete [] iFeld; \newline delete obj; \newline delete [] objFeld; \newline \layout Standard Der \emph on delete \emph default -Operator darf nur auf dynamisch kreierte Objekte angewendet werden! \end_deeper \layout Foilhead Referenzen (1) \layout Itemize Eine Referenz dient als alternativer Name ( \emph on Alias \emph default ) für ein Objekt \layout Itemize Referenzen werden normalerweise aus Effizienzgründen verwendet, wenn komplexe Klassenobjekte an eine Funktion übergeben werden sollen \layout Itemize Referenzen entsprechen \begin_deeper \layout Itemize \emph on technisch \emph default Zeigern \layout Itemize \added_space_bottom bigskip \emph on syntaktisch \emph default \begin_inset Quotes eld \end_inset normalen \begin_inset Quotes erd \end_inset Datentypen \end_deeper \layout Itemize Variablendeklaration/-definition \begin_deeper \layout LyX-Code \size small \newline Rational obj1; \newline Rational &obj2 = obj1; // Referenz auf 'obj1' \newline \layout Standard Referenzen müssen bei ihrer Definition initialisiert werden! \layout Standard Referenzen können nicht verändert werden; sie verweisen nach der Initialisierung immer auf das gleiche Objekt! \end_deeper \layout Itemize Objektzugriff (Operator \family typewriter . \family default ) \begin_deeper \layout LyX-Code \size small \newline Rational obj1, &obj2 = obj1, *objp3 = 0; \newline \newline objp3 = new Rational(); \newline obj1.read(); \newline obj2.write(); \newline *objp3 = obj2; \layout LyX-Code \end_deeper \layout Foilhead Referenzen (2) \layout Itemize Funktionsaufrufe: \begin_deeper \layout LyX-Code \size small \newline void foo( const Rational &obj ) \newline { \newline obj.write(); // 'read' is not allowed \newline } \newline \newline int main() \newline { \newline Rational obj1( 5, 3 ), &obj2 = obj1, \newline *obj3 = new Rational( 2, 4 ); \newline \newline foo( obj1 ); \newline foo( obj2 ); \newline foo( *obj3 ); \newline } \newline \layout Standard Referenzen als Parameter suggerieren aufgrund ihrer Syntax im Methoden-Rumpf einen \emph on call-by-value \emph default , realisieren aber wie Zeiger ein \emph on call-by-reference \emph default \layout Standard \begin_inset Formula \( \rightarrow \) \end_inset Referenz-Objekte stets als konstant definieren! \end_deeper \layout Foilhead Knifflige Fälle \layout Standard \size tiny \begin_inset Include \verbatiminput{Programme/mixed_ptrs_refs.cc} \end_inset \layout ShortFoilhead Tödliche Sünden \layout Itemize Rückgabe eines temporären Objekts als Referenz oder Zeiger \begin_deeper \layout LyX-Code \size small \newline Rational &foo( ... ) \newline { \newline Rational result( 3, 4 ); \newline return result; \newline } \newline \newline Rational *foo( ... ) \newline { \newline Rational result( 3, 4 ); \newline return &result; \newline } \newline \end_deeper \layout Itemize Rückgabe eines dynamisch angelegten Objekts \begin_deeper \layout LyX-Code \size small \newline Rational foo( ... ) \newline { \newline Rational *result = new Rational( 3, 4 ); \newline return *result; \newline } \newline \newline Rational &foo( ... ) \newline { \newline Rational *result = new Rational( 3, 4 ); \newline return *result; \newline } \end_deeper \layout Foilhead Klasse 'Stack' - Erster Ansatz (1) \layout Standard \size tiny \begin_inset Include \verbatiminput{Programme/RationalStack.h} \end_inset \layout ShortFoilhead Klasse 'Stack' - Erster Ansatz (2) \layout Standard \size tiny \begin_inset Include \verbatiminput{Programme/RationalStack.cc} \end_inset \layout Foilhead Klassen mit dynamischen Datenstrukturen \layout Itemize Beim Kopieren von Objekten werden standardmässig alle Komponenten flach 1:1 kopiert \newline \begin_inset Formula \( \rightarrow \) \end_inset Das Duplizieren von Objekten mit dynamisch angelegten Datenstrukturen ist problematisch \layout Itemize \added_space_bottom 13cm Beispiel: Stack \layout Itemize Definition von Copy-Konstruktor und Zuweisungsoperator (=) ist absolut unerlässl ich!!! \layout Foilhead Kopieren und Löschen von Objekten \layout LyX-Code \size tiny \begin_inset Include \verbatiminput{Programme/copy_destroy.cc} \end_inset \layout Foilhead Klasse 'Stack' - Zweiter Ansatz (1) \layout Standard \size tiny \begin_inset Include \verbatiminput{Programme/RationalStack-2.h} \end_inset \layout Foilhead Klasse 'Stack' - Zweiter Ansatz (2) \layout Standard \size tiny \begin_inset Include \verbatiminput{Programme/RationalStack-2.cc} \end_inset \layout Foilhead Templates \layout Itemize Templates stellen parametrisierte Klassen dar \layout Itemize Templates sind oftmals sog. \emph on Container \emph default -Klassen, in denen Objekte beliebiger anderer Klassen abgelegt werden können \layout Itemize Standard Template Library (STL) \begin_deeper \layout Itemize Container-Klassen \begin_deeper \layout Itemize basic_string \layout Itemize vector \layout Itemize map \layout Itemize set \layout Itemize ... \layout Standard Alle Container-Klassen bieten eine Reihe von gemeinsamen Methoden, z.B. um die Anzahl der Elemente zu ermitteln \end_deeper \layout Itemize Iteratoren \begin_deeper \layout Itemize Zugriff auf einzelne Elemente oder Bereiche eines Containers \layout Itemize Ermöglichen das systematische Durchsuchen von Container-Klassen \end_deeper \layout Itemize Algorithmen \begin_deeper \layout Itemize Manipulation von Containern \end_deeper \end_deeper \layout Foilhead STL - Map & Iteratoren \layout Standard \size tiny \begin_inset Include \verbatiminput{Programme/mapbeispiel.cc} \end_inset \layout Foilhead Generische Stackimplementierung \layout Standard \size tiny \begin_inset Include \verbatiminput{Programme/GenericStack.h} \end_inset \layout Foilhead Instanziierung von Templates (1) \layout Standard \added_space_bottom bigskip Aus einer Template-Klasse und einem (oder mehreren) Template-Argument(en) generiert der Compiler eine Klassendefinition \layout Standard Implizit: \layout Itemize Die Template-Klasse wird vollständig in der Headerdatei definiert \layout Itemize Für jede cc-Datei, die ein Template verwendet, wird entsprechender Objektcode erzeugt \layout Itemize Der Linker verwirft später in verschiedenen Objektdateien doppelt definierte Klassenmethoden \layout Itemize Beispiel: \begin_deeper \layout LyX-Code \size tiny \newline /* Main.cc */ \newline \newline #include <vector> \newline #include \begin_inset Quotes eld \end_inset GenericStack.h \begin_inset Quotes erd \end_inset \newline \newline using std::vector; \newline \newline GenericStack< int > stack1; \newline GenericStack< Rational > stack2; \newline vector< vector< int > > matrix; \newline \size default \end_deeper \layout Foilhead Instanziierung von Templates (2) \layout Standard Explizit: \layout Itemize Die Definition der Template-Klasse wird wie üblich in Schnittstellenbeschreibung und Implementation aufgeteilt \layout Itemize Benötigte Klassendefinitionen werden mit einer \emph on template \emph default -Anweisung explizit angegeben \begin_deeper \layout Standard Beispiel: \layout LyX-Code \size tiny \newline /* Stack.cc */ \newline \newline template <class C> \newline Stack::Stack() \newline { \newline ... \newline } \newline \newline template class Stack<int>; \newline template class Stack<Rational>; \newline \size default \newline \end_deeper \layout Foilhead Ein- und Ausgabe mit \emph on iostreams \layout Standard \added_space_top 0.3cm \added_space_bottom 0.3cm \align center \begin_inset Figure size 416 313 file streamhierarchie.eps width 3 70 angle 270 flags 9 \end_inset \layout Itemize \emph on cin \emph default ist ein (globales) Objekt der Klasse \emph on istream \layout Itemize \emph on cout \emph default ist ein (globales) Objekt der Klasse \emph on ostream \layout Foilhead \emph on iostreams \emph default - Beispiel (1) \layout Standard Rational.h \layout Standard \added_space_bottom bigskip \size tiny \begin_inset Include \verbatiminput{Programme/Number/folien_rational_h.txt} \end_inset \layout Standard Rational.cc \layout Standard \size tiny \begin_inset Include \verbatiminput{Programme/Number/folien_rational_cc.txt} \end_inset \layout Foilhead \emph on iostreams \emph default - Beispiel (2) \layout Standard Main.cc \layout Standard \size tiny \begin_inset Include \verbatiminput{Programme/Number/Main-4.cc} \end_inset \layout Standard \added_space_top bigskip Das Testen auf Ende eines Eingabestroms (z.B. Dateiende) kann mit \family typewriter \SpecialChar ~ eof() \family default \SpecialChar ~ erfolgen \layout Standard Alternative Formulierung der do-while-Schleife aus Main.cc: \layout LyX-Code \size footnotesize while( !inputstream.eof() ) \layout LyX-Code \size footnotesize { \layout LyX-Code \size footnotesize inputstream >> rat; \layout LyX-Code \size footnotesize rat = rat * Rational( -1, 1 ); \layout LyX-Code \size footnotesize outputstream << rat << endl; \layout LyX-Code \size footnotesize } \layout Foilhead Umwandeln von Zahlen in Strings \layout Standard Problemstellung: \layout Itemize \align left Aus den Zahlen i\SpecialChar ~ =\SpecialChar ~ 42 und f\SpecialChar ~ = 3.14 soll der String s\SpecialChar ~ =\SpecialChar ~ \begin_inset Quotes eld \end_inset \family typewriter i\SpecialChar ~ =\SpecialChar ~ 42\SpecialChar ~ /\SpecialChar ~ f\SpecialChar ~ =\SpecialChar ~ 3.14 \family default \begin_inset Quotes erd \end_inset erzeugt werden \layout Standard Lösung mit String-Streams: \layout LyX-Code \size footnotesize #include <string> \layout LyX-Code \size footnotesize #include <iostream> \layout LyX-Code \size footnotesize #include <sstream> \layout LyX-Code \size footnotesize ... \layout LyX-Code \size footnotesize using namespace std; \layout LyX-Code \size footnotesize ... \layout LyX-Code \size footnotesize int main( void ) \layout LyX-Code \size footnotesize { \layout LyX-Code \size footnotesize int i = 42; string s; \layout LyX-Code \size footnotesize float f = 3.14; ostringstream ss; \layout LyX-Code \size footnotesize \SpecialChar ~ \layout LyX-Code \size footnotesize ss << "i = " << i << " / f = " << f; \layout LyX-Code \size footnotesize s = ss.str();\SpecialChar ~ // convert string stream to string \layout LyX-Code \size footnotesize cout << s << endl; \layout LyX-Code \size footnotesize } \layout Standard \align left \series bold Achtung \series default : Die Implementierung der String-Streams ist in den Bibliotheken vieler C++-Compiler (z.B. gcc 2.95) fehlerhaft! \layout Standard Abhilfe: Verwendung der C-Funktion \family typewriter sprintf \family default ( \begin_inset Formula \( \Rightarrow \) \end_inset \family typewriter man sprintf \family default ) \layout LyX-Code \size footnotesize #include <stdio.h> \layout LyX-Code \size footnotesize ... \layout LyX-Code \size footnotesize string s; \layout LyX-Code \size footnotesize char c[ 100 ]; \layout LyX-Code \size footnotesize ... \layout LyX-Code \size footnotesize sprintf( c, "i = %i / f = %f", i, f ); \layout LyX-Code \size footnotesize s = c; \layout LyX-Code \the_end
