Mikroeinführung in C/C+
Werbung
Mikroeinführung in C/C+
C++ - ein Beispielprogramm
Typen, Variablen, Operatoren
Eingabe und Ausgabe
C++
Bedingte Anweisungen und Schleifen
Arrays und Pointer
Funktionen und Klassen
C++ - Informationen und Beispiele
Mehr Details und Programme auf der home page des Kurses im WS 2016/17
„Einführung in die Datenanalyse mit dem C++ Toolkit ROOT“
http://www.physi.uni-heidelberg.de/~marks/root_einfuehrung/
Wiki Book C++ Programmierung
http://www.cplusplus.com/
http://www.tutorialspoint.com/cplusplus/index.htm
Einführung in die Programmierung mit C++ , Bjarne Stroustrup, ISBN 978-3-86894-005
C++ Einleitung
• Mitte der sechziger Jahr wurde bei AT&T an Mehrbenutzer Betriebssytemen
gearbeitet.
• Nach dem Rückzug von AT&T aus dem Großprojekt Multics entwickelten
Thompsen und Ritchie Ende der sechziger Jahre eine erste in Assembler
geschriebene Version, UNIX, auf einer PDP 7.
• Die Implementierung von UNIX in der von Ritchie entwickelten prozeduralen
Programmiersprache C stellt einen Schlüsselbaustein unserer heutigen
Computing Technologie dar.
• C++ wurde von Bjarne Stroustrup (Bell Laboratories) ab 1979 entwickelt
um objektorientiertes Programmieren zu erleichtern.
• C++ ist eine Erweiterung der Sprache C.
• 1985 wurde aus „C with classes“ C++.
• GNU Compiler collection (gcc), ISO C++ standard von 1998,
see http://www.open-std.org/jtc1/sc22/wg21/
• Der letzte offizielle Standard wurde 2011 festgelegt, ISO/IEC 14882:2011
C++ Einleitung
• Computerprogramm
Computer prozessieren Daten, führen Berechnungen durch, fällen Entscheidungen mit Hilfe eines Satzes von Anweisungen.
Eine Aktion wird mit Hilfe von Schlüsselwörtern beschrieben, die durch eine
Programmiersprache, z. B. C++, charakterisiert werden.
Die Schlüsselwörter werden im Klartext in einer Datei gespeichert und von
einem Übersetzungsprogramm (Compiler) in Maschinensprache umgewandelt
• Wir benutzen als C++ Compiler die öffentlich verfügbare GNU Compiler
Collection (gcc)
• Im Rahmen dieses Kurses wird keine Entwicklungsumgebung verwendet.
Wir arbeiten auf der shell in der Linux Umgebung des CIP pools.
• Arbeiten Sie zu zweit, dadurch werden Fehler beim Implementieren der
Programme reduziert.
Es ist ok Programme oder Programmteile zu kopieren, aber
- Verwenden Sie nur code, den Sie auch verstehen
- Urheberrechte beachten ( GNU General Public License )
Ein Beispiel
myFirst.cc
Ein Beispiel
//
oder
#
/*
*/
Kommentare
Preprozessoranweisungen
include < >
File suchen und einfügen
<iostream >
Input/Output Definitionen
Ein Beispiel
using namespace std ;
Programm namen kommen aus Standard C und
C++ Bibliotheken
Ein Beispiel
main() {C ++ Anweisungen}
Haupt programm Block, Anweisungen werden
sequentiell ausgeführt
Ein Beispiel
Definition von Variablen
werden angegeben
Typ und Name
Variablen und Konstanten
• Syntax
Datentyp Name ;
• Typ Definitionen
Datentyp
Speicherbedarf
Datentyp
Ganze Zahlen
int
16/32
short int
16
long int
32
unsigned int
16/32
unsigned short int
16
unsigned long int
32
unsinged longlong int
64
Reelle Zahlen
float
double
long double
• Wertebereich ist durch Speichergrösse
gegeben und betriebssystemabhängig.
Logische Zeichen
bool
short int ≤ int ≤ long int
Speicherbedarf
32
64
64
Buchstaben und Zeichen
char
unsigned char
16/32
16/32
Variablen und Konstanten
Wertebereich einer durch n bit dargestellten Integer Variablen:
das Vorzeichen ist im Bit am linken Rand kodiert
Bei Operationen mit Überschreitung des Wertebereiches kommt es zu
falschen Ergebnissen (undefiniertem Verhalten) ohne Fehlermeldung.
Zum Wertebereich der Variablen erhält man Zugang mit Hilfe von Funktionen,
deren Definitionen wir hinzufügen müssen.
#include <limits> ; http://www.cplusplus.com/reference/limits/numeric_limits/
…..
cout << numeric_limits <int>::min() << endl;
oder wie in C üblich
#include <climits> ;
…..
cout << MIN_INT << endl;
http://www.cplusplus.com/reference/climits/
Variablen und Konstanten
double und float werden als 64 und 32bit Gleitkommazahlen dargestellt.
Vorzeichen
Exponent
Mantisse
Darstellung der Zahlen:
Zum Wertebereich, den Limits der Exponenten und weiteren Infos erhält man
Zugang mit Hilfe von Funktionen, deren Definitionen wir hinzufügen müssen.
#include <limits> ;http://www.cplusplus.com/reference/limits/numeric_limits/
…..
cout << numeric_limits <double>::epsilon() << endl;
cout << numeric_limits <double>::round_error() << endl;
……..
Abweichung zwischen 1 und
dem nächst grösseren Wert
Maximaler Rundungsfehler
Variablen und Konstanten
Ermittlung des Speicherbedarfs von Variablen oder Typen
• Syntax
sizeof ( Variable ) ;
sizeof ( Datentyp ) ;
Mit dem Zeichen
= werden Variablen Werte zugewiesen
• Syntax
Datentyp Name = Wert ;
Notwendig, sonst ist der Speicherinhalt
zufällig !
Mit dem Schlüsselwort const werden konstante Variable definiert. Der Wert
wird zur Compile Zeit zugewiesen und darf nicht mehr geändert werden.
• Syntax
const Datentyp Name = Wert ;
Für Zeichenketten werden weitere Definitionen gebraucht, string
• Syntax
#include <string> ;
const string ZeichenKette = ”Strings bestehen aus char“;
Variablen und Konstanten
Umwandlung von Typen während der Ausführung des Programms erfolgt
automatisch oder mit Anweisungen.
Die automatische Konversion ist
Compiler spezifisch und sollte
vermieden werden !
• Syntax
int myInteger ;
float myFloat ;
myFloat = (float) myInteger ;
static_cast<type> expression ;
Automatische Konversion – Beispiele :
double / float zu int
char zu int
Nachkommastellen werden abgeschnitten ohne zu
runden
Character werden mit einer Integer Zahl entsprechend des Ascii Zeichensatzes dargestellt. Bei
einer Konversion werden diese Zeichen dargestellt
Ein Beispiel
cout / cin
Ausgabe und
Eingabe von Variablen oder strings
Input / Output
cout
cerr
Input / Output
an Konsole
oder Tastatur
cin
#include <iostream>;
• Daten werden in einen output
stream geschrieben, gepuffert
und an die Konsole gesendet.
C++
22 4
• Funktionsdefinitionen in
oder file handle
- Output stream: cout
- Input stream: cin
- Output stream für Fehler: cerr
• Syntax
cout << output string << Variable << endl;
cin >> Variable1 >> Variable2 ;
Viele Optionen für
• Beispiel:
const double Pi = 3.14, d = 12.0 ;
double myResult;
myResult = Pi * d ;
cout << “Umfang = “ << myResult << endl;
Formatierungen
und Steuerzeichen:
#include <iomanip>
Input / Output
• Mit Hilfe von Manipulatoren lässt sich die Ausgabe formatieren. Die Manipulatoren werden in den Ausgabeströmen zwischen die Umleitungsoperatoren eingefügt.
#include <iomanip>;
using namespace std ;
main(){
……
cout << setw(8) << i << endl;
cout << setfill('-');
cout << left << setw(8) << i << endl;
Details sind unter diesem link gut erklärt
http://www.willemer.de/informatik/cpp/iostream.htm
• Eine alternative und weitreichendere Formatierung lässt sich mit Hilfe von
C print Befehlen erreichen.
http://www2.informatik.uni-halle.de/lehre/c/c_printf.html
printf(format_string,ausgabe_liste);
sprintf(zeichenkette,format_string,ausgabe_liste);
fprintf(dateizeiger,format_string,ausgabe_liste);
Ein Beispiel
sum = a + b Zuweisung von Ausdrücken
return 0
Rückgabewert des Programms
Operatoren
Operatoren verknüpfen Variable zu neuen Ausdrücken, wir unterscheiden
• Arithmetische Operatoren
Berechnung von Werten
• Vergleichsoperatoren
Überprüfung von Aussagen
• Bit Operatoren
Manipulation einzelner Bits
• Logische Operatoren
Verknüpfung von Aussagen
Operatoren
*
/
%
+
N++
m- -
Berechnungen
Multiplikation
Division
Division mit Rest
Summe
Differenz
N um 1 erhöhen
m um 1 verkleinern
Operatoren Berechnungen
*=
Multiplikation
/=
Division
%=
Division mit Rest
+=
Summe
-=
Differenz
Berechnung wird mit den linken Operatoren
durchgeführt und verändern dann den links
stehenden Wert. P += 7; → P=P+7
P += 7+2; → P=P+7+2
• Benutzung von Klammern wie in der Mathematik
Operatoren
Operatoren verknüpfen Variable zu neuen Ausdrücken, wir unterscheiden
Arithmetische Operatoren
Berechnung von Werten
• Vergleichsoperatoren
Überprüfung von Aussagen
• Bit Operatoren
Manipulation einzelner Bits
• Logische Operatoren
Verknüpfung von Aussagen
●
Operatoren
~
&
|
^
>>
<<
Bit Operationen
nicht
und
oder
entweder oder
nach rechts verschieben
nach links verschieben
Ein ausführbares C++ Programm
Die Erzeugung eines ausführbaren C++ Programmes erfolgt in 3 Schritten:
a0.h
a1.h
a2.h
my.cc
Headerdatei
Daten zur Struktur und
Definitionen des Programms
Quelldatei
Enthält Anweisungen zum
Ablauf und Verhalten des
Programms
Präprozessor
Compiler
library.a
library.so
my.o
Objektdatei
Linker
a.out
Executable
Aus dem C++ Quellcode
übersetzter Maschinencode
Alle vom Linker zusammengebundenen Objektdateien
bilden das ausführbare
Programm
GNU Compiler Collection gcc
• Übernimmt folgende Aufgaben: preprocessing, compilation, assembly
and linking
• Verhalten wird durch Optionen in Form von Flags und File-Namen
gesteuert
- optionen haben „multi letter names“, daher nicht wie in Unix Befehlen: -dv
-d -v
- File-Name Endungen bestimmen welcher compiler aktiviert wird
- Details auf der shell mit dem Befehl man gcc oder ausührlicher info gcc
(falls die Hilfen installiert sind)
• Sprachoptionen:
- c c-header cpp-output
- c++ c++-header c++-cpp-output
→ g++
- objective-c objective-c-header objective-c-cpp-output
- objective-c++ objective-c++-header objective-c++-cpp-output
- assembler assembler-with-cpp
- ada
- f77 f77-cpp-input f95 f95-cpp-input
- go
- java
• Verwendung von g++ setzt Standard Library Pfade für den Linker
GNU Compiler Collection gcc
• Übersetzen eines C++ Programmes
g++ myFirst.cc
→
a.out
• Nützliche Optionen von g++
- Programm Namen vergeben
g++ myFirst.cc -o MyProgramm
→
MyProgramm
- Compiler Warnungen einschalten
g++ -Wall -Wextra myFirst.cc -o MyProgramm
- Nur Compiler verwenden ohne Linker
g++ -c myFirst.cc -o myfirst.o
→
myFirst.o
- Abschalten der nicht standard-conformen Compiler Optionen von g++
g++ -ansi myFirst.cc
- Warnungen bei nicht standard-conformen Erweiterungen von g++
g++ -pedantic myFirst.cc
- Automatische Optimierungen des Programms
g++ -Ox myFirst.cc
x [1,2,3]
Arbeitsanweisungen:
Ein Beispiel
- loggen Sie sich mit Ihrem userid ein.
- erzeugen Sie ein Arbeits – Directory.
- starten Sie eine Editor, z.B. emacs
- schreiben Sie unserem Beispiel entsprechend ein C++ Programm und
speichern sie es als myFirst.cc
- Übersetzen Sie Ihr File und erzeugen Sie ein ausführbares Programm
mit g++ myFirst.cc -o myFirst
- Probieren Sie es mit
./myFirst
- Bauen Sie C++ Syntaxfehler in
myFirst.cc ein, übersetzen Sie das
File und suchen Sie nach Hinweisen
auf den Fehler.
Vergleiche gcc und g++:
- Probieren Sie g++ myFirst.cc -o myFirst und gcc myFirst.cc -o myFirst
- fügen Sie link Pfade in gcc hinzu um die Fehlermeldungen zu entfernen
gcc myFirst.cc -L/usr/lib64/ -lstdc++ -o myFirst
-L setze Pfadnamen
Pfad ist installationsabhängig!
-l setze Bibliotheksnamen (dabei wird das beginnende lib weggelassen)
- Sprache wird durch die Endungen festgelegt
mv myFirst.cc myFirst.kk
gcc myFirst.kk -L/usr/lib64/ -lstdc++ -o myFirst
→ Compiler Fehler
Hinzufügen von -x c++
gcc -x c++ myFirst.kk -L/usr/lib64/ -lstdc++
-o myFirst
aktiviert den c++ Teil von gcc
→ kein Compiler Fehler
- Weitere Optionen mit der Online Hilfe auf der shell
man gcc
if ( Logischer Operator ) {
Anweisungen
true
}
else {
Anweisungen
false
}
Bedingte Anweisungen
Operatoren verknüpfen Variable zu neuen Ausdrücken, wir unterscheiden
• Arithmetische Operatoren
Berechnung von Werten
• Vergleichsoperatoren
Überprüfung von Aussagen
• Bit Operatoren
Manipulation einzelner Bits
• Logische Operatoren
Verknüpfung von Aussagen
Operatoren
==
!=
>
<
>=
<=
Bedeutung
Nicht mit
ist gleich
ungleich
groesser als
kleiner als
groesser gleich
kleiner gleich
= verwechseln
Es kann innerhalb der if Anweisung eine bool Variable verwendet werden
• Syntax
bool IFeelGood = true ;
if ( IFeelGood ) cout << ”Yeah” << endl ;
Bedingte Anweisungen
Operatoren verknüpfen Variable zu neuen Ausdrücken, wir unterscheiden
• Arithmetische Operatoren
Berechnung von Werten
• Vergleichsoperatoren
Überprüfung von Aussagen
• Bit Operatoren
Manipulation einzelner Bits
• Logische Operatoren
Verknüpfung von Aussagen
Operatoren
Bedeutung
&&
und
||
oder
!
not
Innerhalb der if Anweisung können bool Variablen und VergleichsOperatoren verknüpft werden.
• Syntax
bool IFeelGood = false ;
bool RainyDay = true , Cloudy = true ;
double SunShineHours = 8.2 ;
if ( !RainyDay && (SunShineHours > 8.0 || !Cloudy) )
IfeelGood = true ;
Bedingte Anweisungen
Operatoren verknüpfen Variable zu neuen Ausdrücken, wir unterscheiden
• Arithmetische Operatoren
Berechnung von Werten
• Vergleichsoperatoren
Überprüfung von Aussagen
• Bit Operatoren
Manipulation einzelner Bits
• Logische Operatoren
Verknüpfung von Aussagen
• Beispiele
Operatoren
a
b
true true
false false
false true
true false
Möglichkeiten
!(a)
a && b a || b
false
true
true
true
false
false
true
false
true
false
false
true
Zuerst wird der linke Ausdruck überprüft. Ist der true wird der rechte
überprüft.
Wenn die linke Bedingung falsch ist wird die rechte nicht geprüft.
Bedingte Anweisungen
Implementieren von Fallunterscheidungen
• Wenn … dann .. andernfalls …
if( Bedingung ) { Anweisung }
else { Anweisung }
• Wenn … dann .. andernfalls … Wenn … dann
if ( Bedingung ) { Anweisung }
elseif ( Bedingung ) { Anweisung }
else { Anweisung }
In den Anweisungsblöcken können weitere bedingte Anweisungen verwendet
werden.
if ( Bedingung ) {
Anweisung
if (Bedingung 2) { Anweisung }
}
else { Anweisung }
Bedingte Anweisungen
Alternative Schreibweise, um abhängig vom Wert eines Ausdrucks eine
Zuweisung vorzunehmen
• Auswahl Operator
• Syntax
(Zuweisung mit Bedingung) ?
Zuweisung
wenn true
:
Beispiel: Minimum von 2 Werten soll zugewiesen werden
min = a < b ? a : b
Ausführliche Schreibweise
if( a<b ){
min = a;
}
else {
min = b;
}
Zuweisung
wenn false
conditional.cc
Arbeitsvorschläge:
- modifizieren Sie das Programm so,
das die Division durch eine weitere
Zahl gestest wird.
- passen Sie die Ausgabe an.
- Sie wollen 5 Zahlen testen, die
eingegeben werden. Welches SprachElement in C++ brauchen wir ?
Schleifen
Wichtiges Element einer Programmiersprache
→ Wiederholung von Anweisungen
• Bearbeiten einer festgelegten Anzahl von Schleifenfolgen
for ( Anzahl der Schleifen ) { C++ Anweisungen }
Schleifenkopf: Hier wird die Anzahl der Schleifenfolgen kontrolliert und „eigenständig“ gezählt.
Anweisungsblock:Hier steht
eine Iterationsvariable zur
Verfügung
• Bearbeiten einer Anzahl von Schleifenfolgen mit Abbruchbedingung
while ( Abbruchbedingung ) { C++ Anweisungen }
Anweisungsblock: Hier wird die
Die Abbruchbedingung wird
Abbruchbedingung iteriert.
vorher getestet.
do { C++ Anweisungen } while (Abbruchbedingung)
Anweisungsblock: Hier wird die
Abbruchbedingung iteriert.
Die Abbruchbedingung wird am
Ende getestet.
Schleife wird hier mindestens einmal durchlaufen!
Schleifen
Wichtiges Element einer Programmiersprache
→ Wiederholung von Anweisungen
• Bearbeiten einer festgelegten Anzahl von Schleifenfolgen
int j ; const int jmax = 100 ;
double a[jmax] ;
for (j=0 ; j < jmax ; j++ ){
a[j] = static_cast<double> (j * j) ;
}
• Bearbeiten einer Anzahl von Schleifenfolgen mit Abbruchbedingung
int j = 1 , jmax = 10 ;
while (j <= jmax ){
j++;
if ( j%7 ) jmax = 13;
}
int j = 1 , jmax = 0 ;
do{
j++;
} while ( j <= jmax) ;
Arrays
Arrays sind Listen von Elementen eines Datentyps. Einzelne Elemente
können durch Array Indices angesprochen werden.
• Syntax
Datentyp Name [Anzahl];
Datentyp Name [N] = {a0, … ,aN-1} ;
Überschreitungen des Indexbereiches werden nicht notwendigerweise als Fehler
gemeldet. Zufällige Speicherbereiche werden überschrieben!
const int maxStunden = 24 ;
double Temperatur[maxStunden]={0.};
Temperatur [12] = 22.0 ;
Temperatur [24] = 15.0 ;
Angabe der Arraylänge
Definition und Initialisierung
Zuweisung eines Elements
Fehler: Arraygrenze überschritten
Arrays können auch in mehreren Dimensionen definiert werden
• Syntax
Datentyp Name [Anzahl][Anzahl];
Zeiger
Variable ist ein „Speicherort“ im
C++ Programm und hat eine Adresse.
- Zugriff auf Variable und/oder Adresse
&
Variable
Adresse
*
• & Operator liefert die Adresse einer Variablen im Speicher
int myVariable = 10 ;
&myVariable ; Speicheradresse von myVariable
• Zeiger ist eine Variable deren Wert eine Adresse enthält. Zeiger werden
im Programm definiert
int
*pMyInteger;
double *pMyDouble ;
Type *PointerName ;
char
*pMyCharacter ;
Datentyp eines Zeiger ist für alle Variablentypen eine hex Zahl
• Vorsicht beim Deklarieren von pointern
int * p1, p2 deklariert eine integer pointer variable und eine
integer variable !
Zeiger
Variable ist ein „Speicherort“ im
C++ Programm und hat eine Adresse.
- Zugriff auf Adresse und Variable
&
Variable
Adresse
*
• * Operator ist eine häufige Anwendung in C++ Programmen und hat zwei
unterschiedliche Bedeutungen
- Pointer Variablen Definition mit Typ Angabe
- Dereferenz Operator im Quellcode in Form von
value pointed to by (Wert auf den gezeigt wird)
• * Operator als Dereferenz im code
int MyVariableA = 10 ;
int *pMyVariableA ;
int MyVariableB ;
pMyVariableA = &MyVariableA ; Adresse der Variablen MyVariableA
MyVariableB = *pMyVariableA ; Wert auf den gezeigt wird
MyVariableB ist jetzt 10
Zeiger
• Zuweisungen und Rechnen mit Zeigern
&
Variable
int MyVariableA = 10 ;
int MyVariableB = 20 ;
int *pMyVariableA , *pMyVariableB ;
Adresse
*
pMyVariableA = &MyVariableA ;
pMyVariableB = &MyVariableB ;
Value pointed to by pMyVariableA wird auf 100
gesetzt
Value pointed to by pMyVariableB =
*pMyVariableA = *pMyVariableB;
value pointed to by pMyVariableA
*pMyVariableA = 100;
pMyVariableA = pMyVariableB; A und B haben die gleichen pointer
*pMyVariableA = 200 ; Value pointed to by pMyVariableA = 200
Zeiger und Arrays
• In der Deklaration einer array Variablen ist der array Name
der Zeiger auf das erste array Element
const int nLength = 50 ;
double MyArray [nLength] ;
MyArray is equivalent to &MyArray[0]
double *pMyArray ;
pMyArray = MyArray ;
*pMyArray = 500;
pMyArray++ ;
*pMyArray = 1000;
pMyArray = MyArray + 2;
*pMyArray = 3000;
pMyArray = MyArray;
*(pMyArray + 3) = 2;
MyArray[4] = 10000;
wird häufig so verwendet
setzt das erste array Element auf 500
läuft durch die array Elemente
setzt das zweite array Element auf 1000
setzt den pointer auf Element 2
setzt das dritte array Element auf 3000
setzt den pointer auf Element 0
setzt das vierte array Element auf 2
setzt das fünfte array Element auf 10000
Zeiger und Arrays
• Komplexe Zeiger Konstruktionen
Das Zeigerkonstrukt wird von innen nach aussen aufgelöst.
int n = 50 , m = 100 ;
int *nptr;
int **npptr;
int *ptrArray[2];
nptr = &n ;
npptr = &nptr ;
ptrArray[0] = &n;
ptrArray[1] = &m;
…...
**(&ptrArray[0])
**npptr
…...
int Zeiger
Zeiger auf einen int Zeiger
Array von int Zeigern
Adresse von n
Adresse vom Zeiger auf n
Adressen von m und n
= 50
= 50
pointer.cc
Funktionen
Zum Strukturieren komplexerer Programme werden funktionale Einheiten
ausgelagert.
• Syntax
returnType FunctionName (ParameterList)
{
falls Rückgabewert
C++ Anweisungen
void
oder Parameter leer
}
- Funktionen stehen meistens hinter dem „Hauptprogramm“ int main() {
Dabei ist die Reihenfolge nicht von Bedeutung.
- Sie werden vor dem Hauptprogramm deklariert
returnType FunctionName (ParameterList);
Die Parameterliste muss nur die Typ Deklaration enthalten
- Die Funktionsdeklarationen werden häufig in Files mit der Endung .h
ausgelagert. Das Einfügen erfolgt erfolgt mit
#include “myHeader.h“
}
Funktionen – Ein Beispiel
• Beispiel
int max ( int N , int M )
{
int result ;
if ( N > M )
result = N ;
else
result = M ;
return result ;
}
Rückgabe des Maximums 2er Zahlen
Parametertyp deklarieren
Funktionstyp deklarieren
int max ( int , int);
steht vor dem main Programm
Lokale Variable, nur in der
Funktion bekannt
Rückgabewert
Parameter Liste enthält
nur die Typ Deklaration
Funktionen – Ein Beispiel
• Beispiel
int max ( int N , int M )
{
int result ;
if ( N > M )
result = N ;
else
result = M ;
return result ;
}
Rückgabe des Maximums 2er Zahlen
Parametertyp deklarieren
Funktionstyp deklarieren
Lokale Variable, nur in der
Funktion bekannt
Rückgabewert
int max ( int , int);
steht vor dem main Programm Arbeitsvorschlag:
functionSum.cc
- Schreiben Sie ein Programm, das in einer
Funktion 2 Zahlen summiert.
- Erzeugen Sie eine header Datei mit der
Funktionsdeklaration und binden Sie sie ein.
- Lagern Sie die header Datei in ein include dir
aus. Mit der Compiler Option -I dir
koennen Sie das directory einbinden
Funktionen - Parameterübergabe
Beim Übergeben der Funktionsargumente ist zu beachten, das die Speicherbereiche beim Aufruf der Funktion erzeugt werden und beim Verlassen der
Funktion nicht mehr existieren!
• Methoden zur Übergabe von Funktionsparametern
- Call by value (default)
double function (int A, int B) { }
A und B werden beim Funktionsaufruf kopiert und Änderungen innerhalb
der Funktion haben keinen Effekt auf die Werte A und B im Hauptprogramm
- Call by reference
double function (int &A, int &B) { }
Die Adressen von A und B werden beim Funktionsaufruf übergeben und
Änderungen der Adressinhalte innerhalb der Funktion beeinflussen die
Werte A und B im Hauptprogramm
void swap( int &N , int &K ){
int temp; temp = N;
N = K;
K = temp;
return ;
functionSwap_I.cc
}
Alternativ können auch pointer übergeben werden
Funktionen - Parameterübergabe
Arrays werden häufig an die Funktionen als Zeiger übergegeben. Dabei wird
die Arraylänge als konstanter Wert ebenfalls übergegeben.
addArray.cc
Der Inhalt von Array ValC wird in der
Funktion sum modifiziert. Die Werte
werden by Reference zurückgegeben,
Daher sind die Änderungen sichtbar.
Funktionen – statische Variablen
Die lokalen Variablen von Funktionen existieren nur für die Lebensdauer der
Funktion. Zugewiesene Werte existieren nach dem Aufruf nicht mehr.
• Statische Variable
static Datentyp Name ;
Diese Anweisung definiert eine Variable, deren Inhalt nach dem Schliessen
der Funktion erhalten bleibt und bei erneutem Aufruf zur Verfügung steht.
• Globale Variable
Datentyp myGlobalVariable ;
…..
void function(){ }
main() {
…..
}
Variablen, die ausserhalb von Funktionen und vor dem Hauptprogramm
definiert werden, stehen in allen Funktionen zur Verfügung und behalten
ebenfalls den Inhalt nach dem Schliessen der Funktionen.
Funktionen - Bibliotheken
Funktionen können in Bibliotheken als Objektfiles sowohl statisch (.a) als auch
dynamisch (.so) gespeichert werden.
• Erzeugen einer statischen Bibliothek
Der Quellcode ist die function myFunc.cc und die header Datei myFunc.h
- compilieren der Quelldateien und erzeugen des Objektfiles
gcc -c myFunc.cc -o myFunc.o
- verwenden der archiver ar zur Erzeugung der statischen Bibliothek
ar rcs libmyFunc.a myFunc.o
Der Bibliotheksname muss die ersten 3 Buchstaben lib enthalten und mit .a enden.
Im link Schritt von gcc muss -static hinzugefuegt werden.
• Erzeugen einer dynamisch gelinkten Bibliothek
- compilieren der Quelldateien und erzeugen des Objektfiles
gcc -fPIC -c myFunc.cc -o myFunc.o
Die Option -fPIC erzeugt positionsunabhaengigen code
- verwenden von gcc zur Erzeugung der dynamischen Bibliothek
gcc -shared -Wl,-soname,libmyFunc.so -o libmyFunc.so myFunc.o
- beim link Schritt in gcc zum Einbinden der dynamischen Bibliothek reicht
die Endung .so der Bibliothek
g++ myProg.cc -L. -lmyFunc
Funktionen – Werkzeug Bibliotheken
Es existiert eine C++ Bibliothek, die standardisierte Werkzeugprogramme
enthält (C++ Standard Library). Die C Bibliothek ist darin enthalten.
• Standard Funktionen aus den Bereichen
Mathematische Funktionen, Input / Output, Zeichenketten, Zeit / Datum,
Speichermanipulation, …....
Erzeugung von Zufallszahlen:
#include <cmath>
#include <cstdlib>
…..
#include <ctime>
double t, x;
…..
x = sin(t);
// initialize with time
x = log(t);
srand(time(0));
x = exp(t);
// random integer
x = sqrt(t);
int r = rand();
…..
…..
• Objektorientierte Klassenbibliothek
Klassendefinitionen für Input/Output, Strings, Standard Template,
Container, Iteratoren, Fehlerbehandlung, …....
Die C++ Standard Library wird im g++ Link Schritt automatisch hinzugefügt.
Funktionen – Werkzeug Bibliotheken (2)
Die C++ Standard Library wird bei der Verwendung des g++ Compilers im
Link Schritt automatisch hinzugefügt.
Neben der C++ Standard Library gibt es viele kommerzielle und public
domain Bibliotheken mit spezieller Funktionalität. Vor dem Programmieren
einer speziellen Softwarelösung sollten existierende Bibliotheken
durchgesehen werden.
• Bibliotheken - Beispiele
boost
OpenMP
cuda
freie C++ Bibliothek (mathematische Lösungen, …..)
Paralleles Computing
Programmieren auf Nvidia Graphikkarten
• Verwendung von Bibliotheken
- Hinzufügen des header files im Programmcode
#include <boost/random.hpp>
- Aufrufen der Funktion im Hauptprogramm
gen()
- Hinzufügen der Bibliothek im Link Schritt des Compilers
g++ myCode.cc -L/usr/lib64/boost/ -lboost_random
(/usr/lib64/boost/libboost_random.so wird hinzugefügt)
Klassen – Einleitung
Ziel von C++ ist der Support objektorientierter Programmierung (OOP). Dabei
handelt es sich um ein Konzept zur Strukturierung von Programmen bei
dem Programmlogik (Funktionalität) und Programmzustand (Datenstrukturen)
vereinigt werden. Die Vereinigung wird Objekt genannt.
• Objekte werden im Programm erzeugt und vernichtet.
• Objekte haben zur Laufzeit des Programms definierte Zustände
• OOP erlaubt die Kommunikation zwischen Objekten
OOP wird in C++ mit Hilfe von Klassen realisiert. Sie vereinigen
Datenstrukturen und Funktionen zur Veränderung der Daten.
• Anschaulich: Klassen sind Vorlagen und Konstruktionspläne aus denen
zur Laufzeit Objekte erzeugt werden (Instanzen).
• Alorithmen die auf den Datenstrukturen von Klassen operieren heißen
Methoden
• Klassen kapseln zusammengehörige Daten und Funktionen und unterstützen Datenzugriff nur über spezielle Funktionen. Methoden die Objekte
erzeugen oder zerstören werden als Konstruktoren oder Destruktoren
bezeichnet.
Klassen – ein Beispiel
Ziel von C++ ist der Support von OOP. Dabei spielen Klassen eine wichtige
Rolle. Sie vereinigen Datenstrukturen und Methoden zur Änderung der Daten.
• Betrachte ein Beispiel: Klasse von Vierervektoren zur Beschreibung von
Vierervektor:
Teilchenreaktionen
class FourVector
{
Klassenname, identifiziert die Klasse
public:
Definiere Funktionen, die die Elemente des Vektors
füllen
Definiere Funktionen, die den Impuls, Energie und
invariante Masse zurückgeben.
Klassenmitglieder
- Datenstrukturen
- Funktionen/Methoden
private:
definiere Daten, die zum Vektor gehören
} vect ;
int main(){
FourVector Elektron, Proton;
…..
Optional Objektnamen
Erzeuge Instanzen von FourVector
Klassen – ein Beispiel
Ziel von C++ ist der Support von OOP. Dabei spielen Klassen eine wichtige
Rolle. Sie vereinigen Datenstrukturen und Methoden zur Änderung der Daten.
• Betrachte ein Beispiel: Klasse von Vierervektoren zur Beschreibung von
Teilchenreaktionen
Zugriffsrechte werde explizit mit Hilfe
class FourVector
von Schlüsselwörtern gewährt
{
Auf alle Klassenmitglieder die hier stehen
gibt es nur von Mitgliedern Zugriff
public:
Diese Klassenmitglieder können vom gesamten
Programm benutzt werden
private:
Nur Mitgliedern ist der Zugriff erlaubt
};
int main(){
FourVector Elektron, Proton;
…..
Klassen – ein Beispiel
• Betrachte ein Beispiel: Klasse von Vierervektoren zur Beschreibung von
Teilchenreaktionen
Methoden erlauben Zugriff auf die
class FourVector{
Datenstruktur.
public:
void setE(double e) {E = e;}
void setP(double x, double y, double z){
px = x; py = y ; pz = z;}
double getE(void)const {return E;}
double getP(void)const {
return sqrt(px*px+py*py+pz*pz);}
FourVectorClass_0.cc
private:
double E, px, py, pz;
} ;
Datenstruktur ist nicht zugänglich
int main(){
FourVector Elektron, Proton;
Elektron.setE(100.);
Proton.setP(10., 20., 50.);
Proton.getP();
return 0 ;}
Zwei Instanzen von FourVector
werden erzeugt.
Mit dem Punkt Operator werden
die Methoden erreicht.
Klassen – ein Beispiel
• Betrachte ein Beispiel: Klasse von Vierervektoren zur Beschreibung von
Teilchenreaktionen
Klassendefinition werden im Header
class FourVector{
File untergebracht.
public:
void setE(double e);
void setP(double x, double y, double z);
double getE(void)const;
Die Methoden können auch
double getP(void)const;
ausserhalb der Klassendefinition
private:
definiert werden. Auf die Klasse
double E, px, py, pz;
wird mit Klassenname:: bezug
} ;
genommen.
FourVector::setE(double e){
E = e;
Scope operator
}
double FourVector::getE(void)const{
return E;
}
…….
FourVectorClass_I.cc
Klassen – ein Beispiel
• Konstruktor und Destruktor einer Klasse
Konstruktor, code wird bei der
Instanzierung gerufen
class FourVector{
public:
FourVector(void){ E=0.;px=0.;py=0.;pz=0.}
~FourVector(void) { }
Destruktor
void setE(double e) {E = e;}
void setP(double x, double y, double z){
px = x; py = y ; pz = z;}
double getE(void) {return E;}
double getP(void) {return sqrt(px*px+py*py+pz*pz);}
private:
double E, px, py, pz;
} ;
int main(){
FourVector Elektron, Proton;
Zwei Instanzen von FourVector
werden erzeugt.
Beide sind durch den Konstruktor
initialisiert.
Klassen – ein Beispiel
• Konstruktor einer Klasse
- Kein Rückgabetyp, Argumente können void oder eine Variableliste sein
- Konstruktor hat den Namen der Klasse und dient der Initialisierung des
Objektes
class FourVector{
Public:
FourVector(double e,double x,double y, double z);
FourVector();
….
Private:
double E, px, py, pz;
Initialisierung der Variablen
};
FourVector::FourVector(double e,double x,double y,
double z): E(e),Px(x),Py(y),Pz(z){} Synthax
FourVector::FourVector(){ E=0.; px=0.; py=0.; pz=0.}
……..
FourVector Pion;
FourVector Kaon(5.,1.0,1.5,19.);
Zuweisung der Variablen,
um zu initialisieren
Initialisierung von array geht
nur über Zuweisung !
Klassen – ein Beispiel
• Konstruktor einer Klasse
- Im Header können Default Parameter angegeben werden.
- Konstruktor kann ueberladen werden
- Kopierkonstruktur wird vom System erzeugt, erstellt ein Objekt der Klasse
anhand eines vorhandenen Objektes. Der Parameter ist immer eine
Referenz auf ein konstantes Objekt der selben Klasse.
class FourVector{
Public:
~FourVector(){}; Destruktor
FourVector(double e=0.,double x,double y, double z);
FourVector(FourVector const& FourVectorObjekt);
….
Private:
double E, px, py, pz;
};
• Destruktor einer Klasse
- Einer pro Klasse
- Ist fuer Aufräumarbeiten zuständig
Klassen – ein Beispiel
• Eine Klasse wird instanziert, indem die Klassenbezeichnung und ein
Name angegeben wird. Der Zugriff auf Member Funktionen und Variablen
erfolgt über den Operator „ . “ Für Pointer auf Klassen wird der Operator
„ → “ verwendet. Er besorgt die Dereferenzierung und den Memberzugriff.
class FourVector
{
….
}
int main() {
FourVector Kaon;
FourVector *Pion;
…..
Kaon.setE(20.);
…..
Pion->GetMomentum();
…...
}
