Vous êtes sur la page 1sur 166

Computer Science

and Programming

for Engineer

Fakulty for mechanical Engineering and

Prof. Dr.-Ing. Hans-Werner Dorschner

WS 2010/11

September 2009 Fakultt fr Maschinenbau u. Mechatronik Prof. Dr.-Ing. Hans-Werner Dorschner


Hochschule Karlsruhe Technik und Wirtschaft
Contents Seite II/166

Contents
Contents................................................................................................................................................................ 2
1 Lecture Outline ............................................................................................................................................ 5
2 Sprachsyntax von C/C++ ............................................................................................................................. 7
2.1 C++ - Character Set ........................................................................................................................... 8
2.2 Variables ........................................................................................................................................... 9
2.2.1 Expressions ................................................................................................................................. 10
2.2.2 Operators .................................................................................................................................... 10
2.3 Characters ........................................................................................................................................ 12
2.4 Data Structures ................................................................................................................................ 13
2.5 Arrays .............................................................................................................................................. 14
2.5.1 Array Definition ......................................................................................................................... 14
2.5.2 Array Initializing ........................................................................................................................ 15
2.5.3 Mehrdimensionale Arrays .......................................................................................................... 17
2.5.4 Initializing of multidimensional Arrays...................................................................................... 17
2.5.5 Arrays als Funktionsparameter ................................................................................................... 21
2.6 Mathematische Funktionen ............................................................................................................. 23
2.7 Zeiger .............................................................................................................................................. 30
2.8 Call-by-reference ............................................................................................................................. 32
2.9 Adressierung von Arrays................................................................................................................. 35
2.10 Referenz als Konstante .................................................................................................................... 43
2.11 Speicherplatzbelegung (new, delete) ............................................................................................. 45
2.12 Numerische Integration ................................................................................................................... 48
2.13 Numerische Ableitung..................................................................................................................... 51
2.14 Numerische Nullstellensuche .......................................................................................................... 54
2.14.1 Nullstellensuche durch lineare Interpolation .............................................................................. 54
2.14.2 Nullstellenbestimmung nach dem Tangentenverfahren ............................................................. 58
2.15 Numerischen Lsung linearer Gleichungssysteme.......................................................................... 63
2.16 Klassen ............................................................................................................................................ 68
2.16.1 NimmSpiel als Klasse ................................................................................................................. 68
2.16.2 Klasse Vektoren.......................................................................................................................... 71
2.17 Konstante Elementfunktionen ......................................................................................................... 73
2.18 Externe Methodendefinition ............................................................................................................ 75
2.19 Klassenkonstruktor .......................................................................................................................... 75
2.20 berladen des Klassenkonstruktors ................................................................................................ 77
2.21 Initialisierungslisten ........................................................................................................................ 78
2.22 Klassendestruktor ............................................................................................................................ 80
2.23 Klassendeklaration und Methodendefinition................................................................................... 81
2.24 Vererbung ........................................................................................................................................ 91
2.25 Klassen als Datenelemente einer Klasse ......................................................................................... 93
2.26 Strings ............................................................................................................................................. 97
2.26.1 C-Strings ..................................................................................................................................... 97
2.26.2 strcpy-Funktion .......................................................................................................................... 99
2.26.3 string-Klasse ............................................................................................................................. 100
2.27 I/O-Stream-Klassen ....................................................................................................................... 103
2.27.1 Formatierte Ausgabe mit cout .................................................................................................. 103
2.27.2 Nationale Sonderzeichen .......................................................................................................... 104
2.27.3 Umwandlung von Zahlen und Strings ...................................................................................... 105
2.27.4 I/O-Verkehr mit Dateien ........................................................................................................... 107

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Contents Seite III/166

3 Computeralgebra mit MATLAB ............................................................................................................. 112


3.1 Benutzeroberflche von MATLAB ............................................................................................... 113
3.2 Elementare MATLAB-Operationen .............................................................................................. 116
3.2.1 Variablendefinitionen ............................................................................................................... 116
3.2.2 Matrixoperationen .................................................................................................................... 117
3.2.3 Matrixarithmetik ....................................................................................................................... 120
3.2.4 Vektorarithmetik....................................................................................................................... 124
3.2.5 Polynome .................................................................................................................................. 131
3.2.6 Mathematische Funktionen....................................................................................................... 134
3.2.7 Graphikfunktionen.................................................................................................................... 136
3.3 Symbolic Toolbox ......................................................................................................................... 140
3.4 MATLAB-Programmierung .......................................................................................................... 144
3.4.1 Funktionen und Prozeduren...................................................................................................... 144
3.4.2 MATLAB-Funktion feval ........................................................................................................ 146
3.4.3 Differentialgleichungen ............................................................................................................ 147
3.4.4 Graphik-Animation................................................................................................................... 149
3.5 Simulink-Toolboxen...................................................................................................................... 151
3.5.1 Lsung von Differentialgleichungen ........................................................................................ 153
3.5.2 Simulation dynamischer, linearer, zeitinvarianter Systeme ...................................................... 157
3.6 Anhang MATLAB Funktionen ..................................................................................................... 160
3.6.1 Steuerfunktionen fr MATLAB: .............................................................................................. 160
3.6.2 Mathematische Funktionen....................................................................................................... 162
Literaturverzeichnis ............................................................................................................................................. A

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Contents C++ - Character Set Seite 4/166

Copyright

This script was written by Prof. Dr.-Ing. Hans-Werner Dorschner, HS Karlsruhe University
of Applied Sciences. It is only for internal use for the semester student of MSST at VGU in
HCMC.
It is expressly forbidden to document on paper or electronically to third parties or use infor-
mation for training purposes or other commercial or noncommercial purposes.
Violators will be prosecuted with all legal means necessary.

Prof. Dr.-Ing. H.-W. Dorschner

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Lecture Outline C++ - Character Set Seite 5/166

1 Lecture Outline

The course is not a computer science course in the original sense. Rather it is
an active guide to programming and to logic and mathematics and algorith-
mic issues. You cannot learn programming if you onlylook at the syntax.
One has to learn by doing.
So a lot of exercises are necessary to become an expert in C++ programming
and in understanding to structure a problem in order to implement it into an
algorithm.

First and foremost I would like to make two basic statements, which one should be aware of:

Those who see the computer more than a tool,

underestimates himself !

The man knows what he is doing,

the computer does what he knows.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Lecture Outline C++ - Character Set Seite 6/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ C++ - Character Set Seite 7/166

2 Sprachsyntax von C/C++

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ C++ - Character Set Seite 8/166

2.1 C++ - Character Set


Der C-Zeichensatz umfasst die folgenden Zeichen:

Numbers:

0 1 2 3 4 5 6 7 8 9

Alphanumericals:

A B C D E F G H I J K L M N O P Q R S T U V
W X Y Z
a b c d e f g h i j k l m n o p q r s t u v
w x y z

Special Symbols:

+ plus ^ circumflex
- hyphen or minus ~ tilde
* asterisk _ underscore
% percent ( left parenthesis
/ slash ) right parenthesis
\ backslash [ left bracket
" double quote ] right bracket
' apostrophe { left brace
# number sign } right brace
! exclamation pt.
= equal Leerzeichen,
< less than Tabulator,
> greater than Seitenwechselzeichen (whitespaces)
: colon
; semicolon
, comma
. period
? question mark
| vertical bar
& ampersand

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Variables Seite 9/166

2.2 Variables
A = 1000; A hast he value of 1000
x=x+1; xnew = xold + 1

x=x+y is no mathematical equation but an assignment.

It means: new value of x is calculated by adding

y to the old value of x.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Variables Seite 10/166

2.2.1 Expressions

Pi=3.1415;
result = (10+Pi)*5.8; // result has the value 76,221.

2.2.2 Operators

2.2.2.1 Arithmetic Operators

Operator Operandentyp (Eingabe) Ergebnistyp Beispiel

+ integer, float integer, float 21 = 10 + 11

- integer, float integer, float 8 = 10 2

* integer, float integer, float 1.21 = 1.1 * 1.1

/ integer, float integer, float 3 = 38 / 12

% integer integer 2 = 38 % 12 (Modulo)

++,-- integer, float integer i ++ increase i by 1

+= integer, float integer, float add to

-= integer, float integer, float subtract to

*= integer, float integer, float multiply by

/= integer, float integer, float divide by

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Variables Seite 11/166

2.2.2.2 Comparison Operators

Operator Beschreibung
== equal

!= unequal

> biger

< smaler

>= biger or equal

<= smaler or equal

int a= 3;
int b= 2;
bool x = a != b; // x ist true
x = a < b; // x ist false

2.2.2.3 Logical Bit Operators

Operator Beschreibung
& UND

| ODER

^ Exklusives ODER

~ NICHT

a = 5; // Bit Pattern 0000.0101


b = 12; // Bit Pattern 0000.1100
c = a & b; // Bit Pattern 0000.0100

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Characters Seite 12/166

2.3 Characters
Characters are represented by the so called ASCII-Code.

ASCII stands for American Standard Code for Information Interchange. This Code asigns to
each character - including all special characers - a value between 0 and 127.

To build an ASCII-character table we execute the following program:

#include <iostream>
using namespace std;
void main()
{
for(int cNummber=32;cNummber<128;cNummber++)
{
char character=cNummber;
cout<<cNummber<<":"<<character<<" ";
if(cNummber%8==7)cout<<endl;
};
system ("PAUSE");
};

C++ does not distinguish between charackters and numbers -


its ASCII-Code.

You can write:


char ch='A'; // or ch = 65
int i= ch; // now i has the value of 65
int j='C'-'A'; // 67-65==2
bool b='C'>'A'; // gives true
int k='z'-'a'; //==25,'z' ist he 26. Character of the alphabet

Mostly we find
'A'<'B'<'C'<...<'X'<'Y'<'Z'
and
'a'<'b'<'c'<...<'x'<'y'<'z'
and
'0'<'1'<'2'<...<'7'<'8'<'9' .
Normally we get 'A' - 'a' = -32.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Data Structures Seite 13/166

Exercise: 3.20-1

Write the following functions:

bool isdigit(char ch)// ch is a number


bool isalpha(char ch)// ch is an alphanumeric character
bool islower(char ch)// ch is a small letter
bool isupper(char ch)// ch is a capital letter
char tolower(char ch)// converts capital to small letters

2.4 Data Structures


We can put data together and build a new data type:

#include <iostream>
#include <string>
using namespace std;
struct Time
{
int hour;
int minute;
};
void main()
{
Time startWorking;
// new typ of variables used like int or
// float...
Time endWorking;
startWorking.hour=8;
startWorking.minute =30;
endWorking.hour =18;
endWorking.minute =15;
int workingMinutes =60*(endWorking.hours-\
startWorking.hours)\
+endWorking.minute-startWorking.minute;
cout<<workingMinutesn<<" Minutes"<<endl;
system ("PAUSE");
};
Similar types:
struct motor
{ char motorTyp;
int revolution, supply_voltage;

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Arrays Seite 14/166

float normnmomentum; };
struct newDataTyp
{ int x1, x2; float y1,y2,y3;
bool status1, status2; };

Exercise: 3.21-1

Define a data structure for a name list consisting


of the first name, second name, birth day, married (yes/no).
Use the data structure in a main program and define the variables. Then make an output of the
structure elements to the screen.
Use string-variables for the names.

#include <iostream>
#include <string>
using namespace std;

#include <string>
.
string myName="xyz";

2.5 Arrays
An Array is a data structure with equal type elements.
An array is a list if values which are addressed by numbers. The single values are addressed
by consecutive numbers.
The first value of the array in C++ is always numbered by 0.

2.5.1 Array Definition

int days[12];
float measurementValues[1000];
char titel[8];

You can define the values of the array while defining the array:

char titel[5]={'B','e','g','i','n'};

int days[12]={31,28,31,30,31,30,31,31,30,31,30,31};

To access a single element:


measurementValues[10] =12.98; measurementValues[11]=13.02;
cout<<days[1]; // output: 28

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Arrays Seite 15/166

Note: -> days[i]:

i 0 1 2 3 4 5 6 6 8 9 10 11
-------------------------------------------------------------
days31 28 31 30 31 30 31 31 30 31 30 31

The dimension of an array has to be constant!

That works:

const int Years=5;


double monthlyStatement[Years*12];

That doesnt:

int years
cin>>years;
double monthlyStatement[years*12];

2.5.2 Array Initializing

int A[100]={0};

Exercise: 3.22-1

The last numerical of a number z can be detected by z%10. With the algorithm for prime
numbers we should detect within an interval the number of prime numbers which end with 0,
1, 2 . 9. The respective number should be stored in an array int prims[10].
Modify the main program so that you can change the interval (first and last
number).
Does the occurrence frequency change with increasing numbers?

Exercise: 3.22-2

Calculate the powers in a main module:

x3 for x=1 to x=10.000,

and store the number of powers that end with 0, 1, 2 etc. in an array:

int anzahl[10] .

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Arrays Seite 16/166

Exercise: 3.22-3

The following program should calculate the angel between two arbitrary vectors defined by
the user of the program. To do so, you need the subroutine scalarProduct and norm which
calculates the length of a vector.
Complete the functions below accordingly.

#include <iostream>
#include <math.h>
#include <cstdlib>
using namespace std;
float scalarProduct(float a[3],float b[3]);
float norm(float a[3]);
void main()
{ float a[3],b[3]; //Initializing of the vectors a and b
int i;
cout<<"Input Vector a: "<<endl;
for (i=0;i<3;i++) //Inpu vector a
{ cout<<"a("<<i<<"): "; cin>>a[i]; }
cout<<"Input of Vector b: "<<endl;
for (i=0;i<3;i++) //Input vector b
{ cout<<"b("<<i<<"): "; cin>>b[i]; }
float angel=acos(scalarProduct(a,b)/norm(a)/norm(b))\
*180/3.14; //Calculation of the angel between a and b
cout<<"The angel between a and b has the value: "<<angel<<endl;
system ("PAUSE");
}

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Arrays Seite 17/166

2.5.3 Multidimensional Arrays


Arrays can be defined multidimensional:

chessboard[8][8];
That is equal to

chesboard [64];

At the beginning the king is at the position


chesboard [0][3];

2.5.4 Initializing of multidimensional Arrays

To initialize multidimensional arrays we proceed like with an one-dimensional array:


int theMatrix [5][3] = { {0},{0},{0},{0},{0} };

or simpler:

int theMatrix [5][3] ={0};


To assign special values to each element we write:

theMatrix [5][3] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 };

one has to assign a value to the elements with the least indices while the higher indices remain
constant. We look at an example:
int theMatrix[5][3];

The matrix should have a zero in the first 3 elements, the next 3 elements should be assigned
a value 1 and so on:
Zur Initialisierung des Array schreibt man

Diese Anweisung lsst sich bersichtlicher darstellen, wenn man die einzelnen Initialisierun-

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Arrays Seite 18/166

gen mit geschweiften Klammern gruppiert:

int dieMatrix [5][3] = { {1,2,3},


{4,5,6},
{7,8,9},
{10,11,12},
{13,14,15} };

Die inneren geschweiften Klammern ignoriert der Compiler - sie dienen lediglich dem Pro-
grammierer zur bersichtlichen Gruppierung der Zahlen.
Die Werte sind durch Kommata zu trennen, unabhngig von eventuell vorhandenen Klam-
mern. Die gesamte Initialisierungsliste ist in geschweifte Klammern einzuschlieen und muss
mit einem Semikolon enden.

Will man nur einzelne Matrixelemente initialisieren, so ergibt sich z.B.

int dieMatrix [5][3] = { {1},{2},{3},{4},{5} };

eine Matrix mit den Elementen { {1,0,0},{2,0,0},{3,0,0},{4,0,0},{5,0,0} };

Setzt man die Werte alle auf Null, so wird die mehrdimensionale Matrix mit Nullen vorbe-
setzt:

Ein Beispiel soll die Nutzung von 2-dimensionalen Arrays veranschaulichen:

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Arrays Seite 19/166

#include <iostream>
#include <cstdlib>
using namespace std;
void main()
{
int dieMatrix [5][2] = { {0,0}, {1,2}, {2,4}, {3,6}, {4,8}};
for (int i = 0; i<5; i++)
for (int j=0; j<2; j++)
{
cout << " dieMatrix [" << i << "][" << j << "]: ";
cout << dieMatrix [i][j]<< endl;
};
system ("PAUSE");
};
Das Programm liefert dann die Ausgabe:

dieMatrix [0][0]: 0
dieMatrix [0][1]: 0
dieMatrix [1][0]: 1
dieMatrix [1][1]: 2
dieMatrix [2][0]: 2
dieMatrix [2][1]: 4
dieMatrix [3][0]: 3
dieMatrix [3][1]: 6
dieMatrix [4][0]: 4
dieMatrix [4][1]: 8

bung: 3.22-4

Definieren Sie mittel zweier verschachtelter Schleifen eine 10x10 Einheitsmatrix.

bung: 3.22-5

Programmieren Sie den Algorithmus zur allgemeinen Multiplikation zweier Matrizen, und
probieren sie ihn in einem Beispielprogramm, das zwei 2x2 Matrizen einliest, aus.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Arrays Seite 20/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Arrays Seite 21/166

2.5.5 Arrays als Funktionsparameter

Arrays knnen Funktionen als Parameter bergeben werden. Dazu muss der Funktionn aber
die Gre des Arrays bekannt gemacht werden. Dies gibt Ntrlich auch fr mehrdimensionale
Arrays. Hierzu ein Beispiel:
#include <iostream>
#include<string>
using namespace std;
void tabellenAusgabe( float tabelle[], int size_tabelle)
{
for(int i=0;i<size_tabelle;i++) cout<<tabelle[i]<<endl;
};
int main( )
{
float vektor[10]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
tabellenAusgabe(vektor,10);
system ("PAUSE");
return 0;
}

Bei mehrdimensionalen Feldern muss man einen Parameter fest mitangeben, da er zur
Typdefinition gehrt:
#include <iostream>
#include<string>
using namespace std;
void tabellenAusgabe( float tabelle[], int size_tabelle)
{
for(int i=0;i<size_tabelle;i++) cout<<tabelle[i]<<endl;
};
void tabellenAusgabe( float tabelle[][5], int size_tabelle)
{
for(int i=0;i<size_tabelle;i++)
{for (int j=0; j<5;j++)
cout<<tabelle[i][j]<<endl;
cout<<endl;
};};
int main( )
{
float vektor_1[4]={1, 1/2. , 1/3. ,1/4.};
float vektor[2][5]={{1, 2, 3, 4, 5},{ 6, 7, 8, 9, 10}};
tabellenAusgabe(vektor_1,4);
tabellenAusgabe(vektor,2);
system ("PAUSE");
return 0;
}

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Arrays Seite 22/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Mathematische Funktionen Seite 23/166

2.6 Mathematische Funktionen

Mit Vektoren wir im Allgemeinen gerechnet. Die vier Grundrechenarten sind dabei schon
fter aufgetaucht und als Standardoperatoren +, -, * und / hinterlegt. Komplexere mathemati-
sche Operationen wie sin(x), x , e x etc. sind durch die Headerdatei <math.h> bzw. in der
C++-Version unter <cmath> verfgbar.

Um die Lnge eines Vektor zu berechnen, kann man nun unter Nutzung der <math.h>
schreiben:

#include<cmath>


laenge = sqrt(x*x+y*y).

bung: 3.23-1

1. Schauen Sie in der Visual Studio Hilf unter cmath oder " Floating-Point Support
nach.
2. Machen Sie sich anhand einiger Standardfunktionen die Funktionsweise der Biblio-
thekselemente klar.

bung: 3.23-2

3. Berechnen Sie aus einem 3-dimensionalen Vektor, den Sie als float-Array initialisie-
ren mit den Werten (10,15,20) den Betrag und den Winkel zur x-y-Ebene in .

Vektor (10,15,20)

Die wichtigsten Funktionen, die in der math.h bzw cmath implementiert sind, finden sie in

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Mathematische Funktionen Seite 24/166

der untenstehenden Tabelle 3-12 bzw. 3-13.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Mathematische Funktionen Seite 25/166

#include <math.h>
namespace std {
using ::abs;
using ::acos;
using ::acosf;
using ::acosl;
using ::asin;
using ::asinf;
using ::asinl;
using ::atan;
using ::atan2;
using ::atan2f;
using ::atan2l;
using ::atanf;
using ::atanl;
using ::ceil;
using ::ceilf;
using ::ceill;
using ::cos;
using ::cosf;
using ::cosh;
using ::coshf;
using ::coshl;
using ::cosl;
using ::exp;
using ::expf;
using ::expl;
using ::fabs;
using ::fabsf;
using ::fabsl;
using ::floor;
using ::floorf;
using ::floorl;
using ::fmod;
using ::fmodf;
using ::fmodl;
using ::frexp;
using ::frexpf;
using ::frexpl;
using ::ldexp; Durch das Einbinden des cmath-Headers
using ::ldexpf; werden die Namen der mathematischen
using ::ldexpl;
using ::log; Funktionen im Standard Namespace definiert
using ::log10; und dadurch zugnglich. Die Funktionen
using ::log10f; selber sind in der Standard C++-Library
using ::log10l;
using ::logf; implementiert.
using ::logl;
using ::modf;
using ::modff;
using ::modfl;
using ::pow;
using ::powf;
using ::powl;
using ::sin;
using ::sinf;
using ::sinh;
using ::sinhf;
using ::sinhl;
using ::sinl;
using ::sqrt;
using ::sqrtf;
using ::sqrtl;
using ::tan;
using ::tanf;
using ::tanh;
using ::tanhf;

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Mathematische Funktionen Seite 26/166

using ::tanhl;
Tabelle 3-12 : cmath-Header
using ::tanl; }#endif
Viel Run-time Bibliotheken bentigen sog. Floating Point Support entweder von einem Math-
Coprozessor oder in Form von speziellen Bibliotheken, die der Compiler zur Verfgung
stellt(s.cmath). Die folgende Tabelle stellt die entsprechenden Funktionen und ihr quivalent
in der .NET Framework Umgebung (s. Kapitel Fehler! Verweisquelle konnte nicht gefun-
den werden.) zusammen.

Routine Use .NET Framework equivalent

abs Return absolute value of System::Math::Abs


int

acos, acosf Calculate arccosine System::Math::Acos

asin, asinf Calculate arcsine System::Math::Asin

atan, atanf, atan2, atan2f Calculate arctangent System::Math::Atan, Sys-


tem::Math::Atan2

atof, _atof_l, _wtof, Convert character string to System::Convert::ToSingle, Sys-


_wtof_l double-precision floating- tem::Convert::ToDouble
point value

Bessel functions Calculate Bessel functions Not applicable. To call the standard C
_j0, _j1, _jn, _y0, _y1, function, use PInvoke. For more
_yn information, see Platform Invoke
Examples.

_cabs Find absolute value of Not applicable.


complex number

ceil, ceilf Find integer ceiling System::Math::Ceiling

_chgsign, _chgsignl Reverse sign of double- Not applicable.


precision floating-point or
long double-precision
floating-point argument

_clear87, _clearfp Get and clear floating-point Not applicable.


status word

_control87, _controlfp, Get old floating-point Not applicable.


__control87_2, control word and set new
_controlfp_s control-word value

_copysign, _copysignl Return one value with sign Not applicable.


of another

cos, cosf, cosh, coshf Calculate cosine System::Math::Cos, Sys-


tem::Math::Cosh

difftime Compute difference System::DateTime::Subtract


between two specified time
values

div Divide one integer by Not applicable.


another, returning quotient
and remainder

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Mathematische Funktionen Seite 27/166

_ecvt, _ecvt_s Convert double to charac- System::Convert::ToString


ter string of specified
length

exp, expf Calculate exponential System::Math::Exp


function

fabs, fabsf Find absolute value System::Math::Abs

_fcvt, _fcvt_s Convert double to string System::Convert::ToString


with specified number of
digits following decimal
point

_finite Determine whether given System::Double::IsInfinity


double-precision floating-
point value is finite

floor, floorf Find largest integer less System::Math::Floor


than or equal to argument

fmod, fmodf Find floating-point remain- System::Math::IEEERemainder


der

_fpclass Return status word contain- System::Double::IsInfinity, Sys-


ing information on floating- tem::Double::IsNegativeInfinity,
point class System::Double::IsPositiveInfinity,
System::Double::IsNan

_fpieee_flt Invoke user-defined trap Not applicable.


handler for IEEE floating-
point exceptions

_fpreset Reinitialize floating-point


math package

frexp Calculate exponential value Not applicable.

_gcvt, _gcvt_s Convert floating-point System::Convert::ToString


value to character string

_hypot, hypotf Calculate hypotenuse of Not applicable.


right triangle

_isnan Check given double- System::Double::IsNan


precision floating-point
value for not a number
(NaN)

labs Return absolute value of System::Math::Abs


long

ldexp Calculate product of System::Math::Pow


argument and 2 to speci-
fied power

ldiv Divide one long integer by Not applicable.


another, returning quotient
and remainder

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Mathematische Funktionen Seite 28/166

log, logf, log10, log10f Calculate natural or base- System::Math::Log, Sys-


10 logarithm. tem::Math::Log10

_logb Extract exponential value of Not applicable.


double-precision floating-
point argument

_lrotl, _lrotr Shift unsigned long int Not applicable.


left (_lrotl) or right
(_lrotr)

_matherr Handle math errors Not applicable.

__max Return larger of two values System::Math::Max

__min Return smaller of two System::Math::Min


values

modf, modff Split argument into integer Not applicable.


and fractional parts

_nextafter Return next representable Not applicable.


neighbor

pow, powf Calculate value raised to a System::Math::Pow


power

printf, _printf_l, wprintf, Write data to stdout System::Console::Write, Sys-


_wprintf_l, printf_s, according to specified tem::Console::WriteLine
_printf_s_l, wprintf_s, format
_wprintf_s_l

rand, rand_s Get pseudorandom number System::Random Class

_rotl, _rotr Shift unsigned int left Not applicable.


(_rotl) or right (_rotr)

_scalb Scale argument by power Not applicable.


of 2

scanf, wscanf, scanf_s, Read data from stdin System::Console::Read, Sys-


_scanf_s_l, wscanf_s, according to specified tem::Console::ReadLine
_wscanf_s_l format and write data to
specified location

_set_controlfp set new control-word value Not applicable.

sin, sinf, sinh, sinhf Calculate sine or hyperbolic System::Math::Sin, Sys-


sine tem::Math::Sinh

sqrt Find square root System::Math::Sqrt

srand Initialize pseudorandom System::Random Class


series

_status87, _statusfp, Get floating-point status Not applicable.


_statusfp2 word

strtod, _strtod_l, wcstod, Convert character string to System::Convert::ToDouble


_wcstod_l double-precision value

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Mathematische Funktionen Seite 29/166

tan, tanf, tanh, tanhf Calculate tangent or System::Math::Tan, Sys-


hyperbolic tangent tem::Math::Tanh

Tabelle 3-13 : Mathematische Funktionen (Floating-Point Support) der C++ Standard Library.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Zeiger Seite 30/166

2.7 Zeiger
Der Speicher des Computers ist in Bytes aufgeteilt. Jedes dieser Bytes hat eine eindeutige
Adresse, durch die es angesprochen werden kann. Die Adresse ist eigentlich nichts anderes,
als eine ganze Zahl, wird vom Compiler aber ein wenig anders behandelt.
Belegt eine Variable nur ein Byte, dann ist die Adresse dieser Variablen die Adresse dieses
Bytes. Belegt eine Variable mehr als ein Byte, dann ist die Adresse dieser Variablen die
Adresse des ersten Bytes, das von dieser Variablen belegt wird.

An die Adresse einer Variablen kommt man, indem man vor die Variable den

Adreoperator &

schreibt. Eine Adresse kann man dann in eine andere Variable speichern. Diese andere Vari-
able ist dann ein Zeiger.

Hat man z.B. eine Variable vom Typ int, so kann man deren Adresse in einer Variablen vom
Typ "Zeiger auf int" speichern. Sie zeigt auf einen int. Zeiger heit auf Englisch pointer, und
um Zeigervariablen von normalen zu unterscheiden, wird oft ein kleines p vorne angehngt.

Ein Zeiger wird deklariert, indem vor dem Bezeichner ein Sternchen

(*pointer = &adresse)

steht.

In Bild 3-15 ist dieser Zusammenhang graphischn dargestellt.

Der Zeiger *px enthlt die Adresse der Variable x (hier im Beispiel 0xFF1A, z.B ber die
Zuweisung *px=&x).
ber diese Adresse kann man auf den Inhalt der Speicherzelle, die den Namen x trgt zugrei-
fen. Man sagt auch, dass der Zeiger *px auf x zeigt.
Um auf den Inhalt zuzugreifen, auf den ein Zeiger zeigt, schreibt man vor den Zeiger auch
ein Sternchen.

Variable Speicherzellenin- Adresse


halt

x 100 0xFF1A

*px 0xFF1A 0xFF1C

Bild 3-15: Zeiger und Zelleninhalt

Man kann auch Zeiger auf Zeiger auf Zeiger... erzeugen, aber das ist meistens unsinnig und
bringt nur Fehler, weil das sehr schnell sehr kompliziert wird.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Zeiger Seite 31/166

Zeiger sind immer dann notwendig, wenn der Platzbedarf der zu verarbeitenden Daten zur
Compilezeit nicht feststeht (s. weiter unten new) oder man aus Funktionen heraus auf Vari-
able anderer Funktionen und Blcke zugreifen mchte.

Mit Zeigern lassen sich auch sehr schn Beziehungen zwischen Objekten beschreiben. So
knnten z.B. Personen, die einen Stammbaum darstellen, so organisiert sein, dass jede Person
noch je einen Zeiger auf Vater und Mutter hat. Solche Datenstrukturen heien dynamische
Datenstrukturen, weil sie erst zur Laufzeit erzeugt werden.

Im Folgenden sind einige Beispiele zur Verwendung von Zeigern dargestellt.

#include <iostream>
using namespace std;
void main()
{
int a=5; // int a ist 5
cout<<a<<endl; // Ausgabe: 5
int *pa=&a; // int Zeiger pa ist Adresse von a
*pa=6; // Inhalt von pa ist 6
cout<<a<<endl; // Ausgabe: 6
a=7; // a ist 7
cout<<*pa<<endl; // Ausgabe: 7
int b=8; // int b ist 8
int *pb=pa; // int Zeiger pb ist pa, pb zeigt jetzt
// auch auf a
cout<<*pb<<endl; // Ausgabe: 7
int **ppa=&pa; // int Zeiger Zeiger ppa = Adresse von pa;
cout<<**ppa<<endl; // Ausgabe: 7
ppa=&pb; // Inhalt von ppa ist Adresse von pb;
cout<<**ppa<<endl; // Ausgabe: 7
pb=&b; // pb ist Adresse von b
cout<<**ppa<<endl; // Ausgabe: 8
system ("PAUSE")
};

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Call-by-reference Seite 32/166

2.8 Call-by-reference
Zeiger werden insbesondere dann gebraucht, wenn man ber die Definitionsgrenzen und
Gltigkeitsgrenzen von Variablen hinweg auf diese sozusagen von auen zugreifen will.
Als Beispiel dient der sogenannte Dreieckstausch.
Die Werte zweier Variablen sollen miteinander vertauscht werden:

#include <iostream>
#include <cstdlib>
using namespace std;
void main()
{
int a=1;
int b=2;
{
int tmp=a; // tmp=1
a=b; // a=2
b=tmp; // b=1
};
cout<<"a: "<<a<<endl;
cout<<"b: "<<b<<endl;
system("PAUSE");
};

Dieses Verfahren, zwei Variablen unter Zuhilfenahme einer dritten zu vertauschen nennt man
Dreieckstausch.

Zu beachten ist, dass die dritte Variable nur temporr gebraucht wurde. Deshalb wird fr sie
eigens ein Block aufgemacht. Nach dem Schlieen des Blocks ist sie wieder verschwunden.

Um einen solchen Dreieckstausch mehrfach in einem Programm zu verwenden, sollte man sie
in eine Funktion auslagern:

#include <iostream>
#include <cstdlib>
using namespace std;
void swap(int a,int b)
{
int tmp=a;
a=b;
b=tmp;
};
void main()
{

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Call-by-reference Seite 33/166

int a=1;
int b=2;
swap(a,b);
cout<<"a: "<<a<<endl;
cout<<"b: "<<b<<endl; system("PAUSE");
};

Der Typ der Funktion swap ist void. Das heit, sie gibt keinen Wert zurck.

Es fllt auf, dass die beiden Werte NICHT vertauscht wurden. Das liegt daran, dass beim
Aufruf von swap nur die beiden Werte der Variablen in die entsprechenden Variablen
der Funktion kopiert wurden, nicht aber irgendwelche Adressen.

Die Funktion erhlt nur die Werte der Variablen (call-by-value).

Innerhalb der Funktion wurde mit den Werten der Variablen gearbeitet, ohne dass dies die
Variablen im Hauptprogramm selbst beeinflusst. Beim Verlassen der Funktion wird die lokale
Variable tmp einfach weggeworfen.
Die an eine Funktion bergebenen Argumente sind zur Funktion lokal. An den Argumenten
vorgenommene nderungen beeinflussen nicht die Werte in der aufrufenden Funktion. Dieses
Verhalten, dass von einer Funktion nur die Werte bernommen werden, nennt man call-by-
value. Das bedeutet, dass die Funktion von jedem Argument eine lokale Kopie anlegt.
Die lokalen Kopien lassen sich wie andere lokale Variable behandeln.

Call-by-value ist deshalb sehr schn, weil man sich als Programmierer darauf verlassen kann,
dass innerhalb einer Funktion, die man aufruft, die bergebenen Variablen nicht verndert
werden knnen. Falls man also einmal einen Fehler entdeckt, bei dem eine Variable einen
Wert hat, den sie nicht haben sollte, dann brauche man nicht in allen Funktionen, die man
verwendet nachzuschauen, ob irgend etwas fehlerhaft ist. Nur im Hauptprogramm kann der
Fehler liegen. Das verkrzt die Fehlersuche ungemein.

Um die beiden Variablen zu vertauschen, ohne blo Werte zu bergeben, muss man Zeiger
auf die Elemente verwenden.

Man bergibt statt der Werte die Adressen der beiden Variablen (call-by-reference)
und vertauscht die Inhalte, auf die die beiden Adressen hinzeigen.

#include <iostream>
#include <cstdlib>
using namespace std;
void swap(int *pa,int *pb)
//int Zeiger pa auf eine int Variable a
//int Zeiger pb auf eine int Variable b
{
int tmp=*pa; // int temp ist Inhalt von a

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Call-by-reference Seite 34/166

*pa=*pb; // Inhalt von a ist Inhalt von b


*pb=tmp; // Inhalt von b ist temp
// Inhalte von a und b sind getauscht
};
void main()
{
int a=1;
int b=2;
swap(&a,&b); // Adressen von a und b werden bergeben
cout<<"a: "<<a<<endl;
cout<<"b: "<<b<<endl;
system("PAUSE");
};
Man kann im Hauptprogramm an den Adressoperatoren leicht erkennen, dass die Funktion
beabsichtigt, die Werte der Variablen zu verndern.

Einige Besonderheiten :

int* v[10] // Vektor der Lnge 10 bestehend aus Zeigern


int (*z) [10] // Zeiger auf den Vektor z der Lnge 10
oder einfacher nur z
int* z, i /* gleichbedeutend mit int* z, int i
*- und &-Operatoren hinter einer Typdefinition gel-
ten nur fr das erste Element Um Missverstndnissen
vorzubeugen, sollte man Deklarationen von Zeigern und
Referenzen niemals zusammenfassen */

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Adressierung von Arrays Seite 35/166

2.9 Adressierung von Arrays


Wie oben erwhnt zeigt der Pointer int *meinArray[n] auf ein Array mit n int-Werten.
In C++ ist ein Array-Name ein konstanter Zeiger auf das erste Element des Arrays.

In der Deklaration
int meinArray[50];

ist meinArray demzufolge ein Zeiger auf das Element &meinArray[0] - also die
Adresse des ersten Array-Elements von meinArray.

Es ist zulssig, Array-Namen als konstante Zeiger - und konstante Zeiger als Array- Namen
- zu verwenden.
Demzufolge kann man mit meinArray + 4 auf die Daten in meinArray[4] zugreifen.

Der Compiler fhrt die korrekten Berechnungen aus, wenn man Zeiger addiert, inkrementiert
oder dekrementiert. Die Adresse fr den Ausdruck meinArray + 4 liegt nmlich nicht
einfach 4 Byte, sondern 4 Objekte hinter der Adresse von meinArray.

Hat jedes Objekt eine Lnge von 4 Byte, bedeutet meinArray + 4 eine Adressverschie-
bung von 16 Byte.

Die Adressierung von Arrays ber Zeiger wird auch bei Funktionsaufrufen genutzt (s. Kapi-
tel 2.5.5). Man kann als anstatt das Array direkt aufzurufen auch mit Zeigern operieren:

#include <iostream>
#include<string>
using namespace std;
void tabellenAusgabe( float *tabelle, int size_tabelle)
{
for(int i=0;i<size_tabelle;i++) cout<<*(tabelle+i)<<endl;
};
void tabellenAusgabe( float (*tabelle)[5], int size_tabelle)
{
for(int i=0;i<size_tabelle;i++)
{for (int j=0; j<5;j++)
cout<<tabelle[i][j]<<endl;
cout<<endl;
}};
int main( )
{

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Adressierung von Arrays Seite 36/166

float vektor_1[4]={1, 1/2. , 1/3. ,1/4.};


float vektor[2][5]={{1, 2, 3, 4, 5},{ 6, 7, 8, 9, 10}};
tabellenAusgabe(vektor_1,2);
tabellenAusgabe(vektor,2);
system ("PAUSE");
return 0; }

bung: 3.26-1

Schreiben sie eine Funktion, die drei Zahlen a, b und c sortiert.

void main()
{ int a=3;
int b=5;
int c=2;

sort(&a,&b,&c);

cout<<a<<endl;// Ausgabe: 2
cout<<b<<endl;// Ausgabe: 3
cout<<c<<endl;// Ausgabe: 5
};

bung: 3.26-2

Programmieren Sie eine Funktion, die die quadratische Gleichung a1 x 2 a2 x a3 0


lst.
Bekanntlich ist die Lsung der quadratischen Gleichung gegeben durch:

a2 a2 2 4a1a3
x01,02 .
2a1

Die Lsungsfunktion hat das Aussehen bool quadGl(double*a, double*x).

Ist die Lsung der quadratischen Gleichung reell, so gibt die Funktion true zurck
andernfalls false.
Die Lsungswerte stehen im reellen Fall unter der Adresse von x.
Im komplexen Fall muss der Lsungsvektor zu Null gesetzt werden.
Die Parameter ai sind unter der Adresse von a abgelegt und werden der Funktion ber-
geben.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Adressierung von Arrays Seite 37/166

bung: 3.26-3

Welchen Ausdruck erhlt man durch folgenden Code und was bedeuten die einzelnen
Zeilen?
#include<iostream>
using namespace std;
void main( )
{
int a[3]= {1, 2, 3};
cout<< "Adresse von a= "<<a<< endl;
cout<<"a+2= "<< a+2 << '\t'<<"*(a+2)= "<<*(a+2)<<endl;
cout<<"a[2]= "<<a[2]<<endl;
int *p =a;
cout<<"p[2]= "<<p[2];
system("PAUSE");;
};

bung: 3.26-4

Was druckt das folgende Programm auf dem Bildschirm aus?

#include <iostream>
#include <cmath>
#include<cstdlib>
using namespace std;
int main()
{
int a,*b,**c;
a=1000;
b=&a;
c=&b;
cout<<a<<endl;
cout<<*b<<endl;
cout<<b<<endl;
cout<<c<<endl;
cout<<*c<<endl;
cout<<**c<<endl;
**c=2000;
cout<<a<<endl;
cout<<*b<<endl;
cout<<**c<<endl;
system("PAUSE");

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Adressierung von Arrays Seite 38/166

};

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Adressierung von Arrays Seite 39/166

bung: 3.26-5

Was gibt das nachfolgende Programm aus?


Welche Reaktion vom Betriebssystem erwarten Sie auer der Ausgabe des Vektors?

#include <iostream>
#include <cstdlib>
#include<cmath>
using namespace std;
void main ()
{ float v[10]={1,2,3,4,5,6,7,8,9,10};
float *zv=v+5;
for (int i=0; i<10; i++)
*(zv+i)=pow(1.0+i,-2);
for (int i=0;i<10;i++)
{
cout<<endl;
cout<<"v["<<i<<"]= "<<v[i];
if (i%3==0)cout<<endl;
};
system("PAUSE");

};

bung: 3.26-6

Programmieren Sie eine Funktion bool rechtEck, die die Koordinaten der
Rechteckpunkte im Array int koordinaten findet und daraus den Flcheninhalt und
den Umfang des Rechteckes berechnet, die ber den Vektor float ergebnisse an
das aufrufende Programm zurckgegeben werden. Wenn der Flcheninhalt Null ist,
dann gibt die Funktion false zurck sonst true.
Beachten Sie, dass ein Flcheninhalt und eine Strecke nie negativ sein kann!
Der Kopf der zu schreibenden Funktion sieht folgendermaen aus:

bool rechteck(float *koordinaten,float *ergebnisse)

Annahme : koordinaten [4]={x1, x2, y1, y2}


y
y2

y1 x

x1 x2
C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Adressierung von Arrays Seite 40/166

bung: 3.26-7

Was gibt dieses Programm aus?

#include<iostream>
#include<cmath>
using namespace std;
void main()
{ float x[5]={1,2,3,4,5};
float *zeiger=x+1;
cout<<zeiger<<endl;
cout<<*(zeiger +2)<<endl;
for(int i=0;i<3;i++)
{ zeiger+=i;
x[i]=pow(*zeiger*1.0,-1);
cout<<x[i]<<endl; };
system("PAUSE");
};

bung: 3.26-8

Was gibt das untenstehende Programm aus?

#include <iostream>
#include <cstdlib>
using namespace std;
int myFunction(int *a,int *b);

void main()
{
int x1=3, x2=17, *p1, *p2;
p1=&x1; p2=&x2;
cout<<"Ergebnis = "<<myFunction(p1,p2)<<endl;
p1=&x2; p2=&x1;
cout<<"Ergebnis = "<<myFunction(p1,p2)<<endl;
system("PAUSE");
};

int myFunction(int *a,int *b)


{
if(*a<*b)return *b%*a;
else return *b**a;

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Adressierung von Arrays Seite 41/166

};

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Adressierung von Arrays Seite 42/166

bung: 3.26-9

Gegeben ist das Projekt

#include <iostream>
#include <limits>
using namespace std;
bool isalpha(char ch);
bool islower(char ch);
bool isupper(char ch);
char tolower(char ch);
char toupper(char ch);
// zu programmierende Funktion
void strInvert(char *text,int size);

void main()
{
char Text[13]={'D','a','s','8','H','a','u','s',' ','!','s','t','4 '};
usw.
};
Schreiben Sie die Funktion void strInvert(char *text,int size), die in der Variab-
len Text Gro- und Kleinbuchstaben tauscht. Verwenden Sie dabei u.U. die anderen im Pro-
grammkopf deklarierten Funktionen.

bung: 3.26-10

Welche Ausgabe erhlt man, wenn man das folgende Programm ablaufen lsst?

#include <iostream>
#include <limits>
using namespace std;

void swap (char A, char B) {char C= A; A = B; B = C;};


void swap (char *x, char *y) {char C= *x; *x = *y; *y = C;};
void swap (char *I, int K) {char C= *I; *I = K; K = *I;};

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Referenz als Konstante Seite 43/166

void main ()
{
char A = 'A' , B= 'B' , C='C';
int I = 66;
cout<<"1. Zeichen: "<<A<<" 2. Zeichen "<<B<<endl;
swap (A,B);
cout<<"1. Zeichen: "<<A<<" 2. Zeichen "<<B<<endl;
swap (&A,&C);
cout<<"1. Zeichen: "<<A<<" 2. Zeichen "<<C<<endl;
swap (&A,I);
cout<<"1. Zeichen: "<<A<<" 2. Zeichen "<<I<<endl;
system ("PAUSE");
};

2.10 Referenz als Konstante


Zeiger-Parameter werden auch gerne dafr verwandt, um Funktionsaufrufe schneller zu ma-
chen.

Eine Struktur, die viele Attribute enthlt, z.B.

struct Student
{

string vorname;
string name;
string strasse;
string hausnummer;
int postleitzahl;
string ort;

string hochschulort;
string hochschule;
int matrikelnummer;
int semesteranzahl;
[...]
};

und dazu eine Funktion, die aus einem Array voller Studenten eine Liste aller Namen aus-
druckt, nutzt sinnvoller Weise Referenzierungen, um direkt auf die Daten zugreifen zu kn-
nen. Weil es bersichtlicher ist, wird diese Funktion in zwei kleinere Funktionen zerlegt:

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Referenz als Konstante Seite 44/166

void printStudent(Student)
{
cout<<student.Vorname()<<' '<<student.Name()<<endl;
};
void printList()
{
for(int i=0;i<ANZAHL_STUDENTEN;i=i+1)
printStudent(student[i]);
};

Weil die bergabe des Studenten in der Funktion printStudent call-by-value ist, wird jedes
Mal eine komplette Kopie des Studenten angelegt und in der lokalen Variablen student ge-
speichert. Weil die Klasse Student recht viele Attribute besitzt, kostet das viel Rechenzeit.

Deshalb ist es blich, zu diesem Zweck einen Zeiger-Parameter zu verwenden

Zeiger-Parameter = Performance.

void printStudent(*pStudent)

Die bergabe ist jetzt erheblich schneller, weil nur ein Zeiger auf das zu bergebende Objekt
bergeben wird.
Doch mit dieser Variante wre nie sichergestellt, dass die Funktion printStudent nicht doch
Vernderungen am bergebenen Objekt vornimmt.
Um den Geschwindigkeitsvorteil der Zeiger-bergabe mit dem Sicherheitsvorteil der Wert-
bergabe kombinieren zu knnen, gibt es die bergabe als const-Referenz.
void printStudent(const *pStudent)

Ab jetzt wehrt der Compiler alle Versuche ab, innerhalb der printStudent-Funktion nderun-
gen am bergebenen Objekt vorzunehmen.

Innerhalb dieser Funktion ist die Variable Student eine Konstante.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Speicherplatzbelegung (new, delete) Seite 45/166

2.11 Speicherplatzbelegung (new, delete)


Bisher haben wir nur Speicher reserviert, indem wir eine entsprechende Variable definiert
haben. Wenn die Variable dann verschwindet, weil sie z.B. nur lokal definiert ist, dann ist der
Speicherplatz auch wieder frei.
Will man in einem Programm ein dynamisches Objekt erzeugen, d.h. ein Objekt, dessen
Umfang und Gre zum Zeitpunkt des Programmierens noch nicht bekannt ist, so kann man
es auf dem sog. Freispeicher anlegen. Das ist Speicherbereich im RAM des Rechners, der
zum Zeitpunkt der Ausfhrung des Programmes noch frei zur Verfgung steht.

Zur Erzeugung und wieder Vernichtung solch dynamischer Objekt gibt es die
Operatoren
new und delete.

new legt auf dem heap (Freispeicher) ein Objekt an und gibt die Adresse die-
ses Objekts zurck. Dieser Speicher wird wieder freigegeben durch delete.

#include <iostream>
#include <cstdlib>
using namespace std;
void main()
{
int *pi=new int; // Speicherplatz fr einen int anlegen
// auerhalb des Programms
*pi=5; // 5 rein schreiben
cout<<*pi<<endl; // Ausgabe: 5
delete pi; // Speicherplatz lschen
pi=new int; // noch mal Speicherplatz anlegen
int i=6; // eine normale integer-Variable
cout<<*pi<<endl; // Ausgabe: irgend eine undefinierte Zahl
pi=&i; // pi ist Adresse von i

/* Jetzt ist die Adresse des int auf dem heap verloren.
Er kann nicht mehr mit delete freigegeben werden!!! */

cout<<*pi<<endl; // Ausgabe: 6
delete pi; /* Fehler!!! Die Variable i kann so nicht
gelscht werden! */
system("PAUSE");
};
Das folgende Beispiel zeigt die Deklaration und Verwendung eines Arrays auf dem Heap.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Speicherplatzbelegung (new, delete) Seite 46/166

#include<iostream>
#include <cmath>
#include <cstdlib>
using namespace std;
void main( )
{
// - Ein Array auf dem Heap
float *messWerte = new float[5];

for (int i = 0; i < 5; i++)


{
cout<<" Bitte Messwerte eingeben : ";
cin>>messWerte[i];
cout<<endl;
}
for (int i = 0; i < 5; i++)
{
cout << "Messwerte" << i+1 << ": ";
cout << messWerte[i] << endl;
}
delete []messWerte; // Freigabe des reservierten Speichers
system("PAUSE");
};

Wenn man mit new ein einzelnes Element auf dem Heap erzeugt, ruft man zum Lschen des
Elements und zur Freigabe des zugehrigen Speichers immer den delete- Operator auf.

Wenn man ein Array mit new <class>[size] erzeugt, schreibt man
delete[] arrayName, um dieses Array zu lschen und dessen Speicher freizugeben. Die
eckigen Klammern signalisieren dem Compiler, dass ein Array zu lschen ist. Wenn man die
Klammern weglsst, wird nur das erste Objekt im Array gelscht.

bung: 3-.28-1

Implementieren Sie das obige Beispiel und modifizieren Sie den Code, so dass 10 int-
1 n
Werte auf dem heap eingelesen werden und anschlieend der Mittelwert X X i
n i 1
gebildet und ebenfalls auf dem Freispeicher abgelegt wird.

Mit Hilfe des berechneten Mittelwertes bilden Sie de Standardabweichung der Mess-
werte nach der Formel;

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Speicherplatzbelegung (new, delete) Seite 47/166

1 n Xi Messwerte

n
(X
i 1
i X ) , hierbei ist
2

X Mittelwert der Messwerte

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Integration Seite 48/166

2.12 Numerische Integration


Im Folgenden werden einige algorithmische Beispiel aus der Mathematik vorgestellt.
Fr das Integral ber eine Funktion f(x) im Intervall [L,x] kann man schreiben:
x n 1
I a f ( x) f ( )d I na f ( x) ak x (3-1)
a k 0

Je nach Algorithmus muss nun eine passende Wahl fr die Koeffizienten ak gefunden werden,
so dass der numerische Fehler mglichst klein wird.
Ein sehr einfacher Algorithmus ergibt sich, wenn man fr die ak den Funktionswert am Inter-
vallrand whlt: ak f ( L k x) .

Der so erzeugte Integrationsalgorithmus nennt man den Rechteckalgorithmus, wie er im


folgenden Programm implementiert ist.

#include<iostream>
#include <cmath>
#include<cstdlib>
using namespace std;
double quadratFunktion(double x) {return pow(x,2);}

double integrieren(double linkeGrenze, double rechteGrenze,\


int anzahlIntervalle, double integrand(double) )
{
double dx = (rechteGrenze-linkeGrenze)/anzahlIntervalle;
double x = linkeGrenze; // Rechteckregel
double sume = 0;
for (int i = 0; i < anzahlIntervalle; i++)
{sume += integrand(x);// Funktionsberechnung
x += dx; }; // Endpunkt neu berechnen
return sume * dx;
};

void main( )
{
double links, rechts, eps, ergebnis;
int intervalle;
cout<< "Bitte linke, rechte Integrationsgrenze,
Integrationsintervalle und den maximalen Fehler eingeben : ";
cin>> links >> rechts >> intervalle >> eps;

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Integration Seite 49/166

double altesErgebnis = 1.e30;


int maximaleInterationen = 25;
for (int i = 0; i < maximaleInterationen; i++)
{
ergebnis = \
integrieren(links,rechts,intervalle,quadratFunktion);
if (fabs(ergebnis - altesErgebnis) < eps) break;
altesErgebnis = ergebnis;
intervalle *= 2;
}
cout << "linke Grenze = " << links << \
"\nrechte Grenze = " << rechts \
<< "\nAnzahl der Intervalle = " \
<<intervalle<<"\nIntegrationsfehler = " \
<< eps <<"\nIntegral = " <<ergebnis<<endl;
system ("PAUSE");
};

Interessant am obigen Beispiel ist die Verwendung der zu integrierenden Funktion als
Parameter in der Funktion:

double integrieren(double linkeGrenze, double rechteGrenze,


int anzahlIntervalle, double integrand(double)
).

Als formaler Parameter tritt die Funktion double integrand(double)in der integrieren-
Funktion auf.

Im Hauptprogramm kann man dann eine beliebige Funktion, z.B. quadratFunktion -


einsetzen:

ergebnis= integrieren(links,rechts,intervalle,quadratFunktion);

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Integration Seite 50/166

Den Fehler durch die diskrete Approximation kann man abschtzen:

k n 1 xk x
Frec f ( x ) f ( x) dx .
k 0
k
(3-3)
xk

Wenn die Funktion im Intervall xk , xk x , dann kann man die Funktion mittels einer Tay-
lorentwicklung darstellen. Daraus errechnet sich dann der Fehler zu:

k n 1 xk x
Frec
k 0
f ' ( xk ) xk x dx ( x 2 ) . (3-4)
xk

Wenn die erste Ableitung der Funktion beschrnkt ist, d.h. die Funktion ein beschrnktes
Wachstum aufweist, dann kann man weiter schreiben, wobei I n x das Integrationsintervall
darstellt:
xk x
f ' ( x) M
xk
(3-5)
M n x 2 M x I
Frec .
2 2

Der Fehler ist also proportional x 2 , jedoch ist x n I konstant, sodass man - abgesehen
von einem auergewhnlichen Eliminieren positiver und negativer Fehleranteile - von einer
linearen Abhngigkeit des numerischen Fehlers vom Interpolationsintervall x ausgehen
kann.

bung: 3.29-1

Integrieren Sie die Funktion f ( x ) 40 x 3 20 x 10 mit der obigen Routine.

Ersetzen Sie die Rechteckregel in der Routine zur numerischen Integration durch die
Simpsonsche Fassregel:

R
x n 1 x x
f ( x) dx
6 i 0 f ( xi ) 4 f ( i i 1 ) f ( xi 1 ) .
2
(3-6)
L

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Ableitung Seite 51/166

2.13 Numerische Ableitung


hnlich wie bei der numerischen Integration wird auch die Ableitung durch eine Differenz
approximiert:

df ( x ) f ( x x ) f ( x )
lim . (3-7)
dx x 0
x

Zur Fehlerabschtzung dieser Approximation wird die Funktion f(x) wieder in eine Taylorrei-
he entwickelt:

df ( x ) ( x )2 d 2 f ( x )
f ( x x ) f ( x ) x . (3-8)
dx 2! dx 2

Benutzt man diese Entwicklung und setzt sie in Gl. (3-7) ein, so erhlt man:

df ( x )
Dx ( f ( x )) ( x )
dx
. (3-9)
x d 2 f ( x )
( x )
2 dx 2

Hinsichtlich der Fehleranalyse mssen aber zwei Dinge bercksichtigt werde:

- Erstens ist der Algorithmus exakt fr lineare Funktionen, d.h. der Fehler
x d 2 f ( x )
( x ) ist Null. Dadurch kann eine Fehlerabschtzung fr lineare oder
2 dx 2
fast lineare Funktionen zu Fehlinterpretationen fhren kann.

- Zweitens knnen bei kleinen x Rundungsfehler auftreten, die den numerischen Feh-
ler des Differentialalgorithmus Dx ( f ( x )) erheblich in die Hhe treiben kann
(s. bung 23).

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Ableitung Seite 52/166

Das folgende Programm realisiert den Algorithmus fr zwei Beispielfunktionen.

#include <iostream>
#include <cmath>
#include<cstdlib>
using namespace std;
double kubischeFunktion(double x)
{
return pow(x,3);
};
double lineareFunktion(double x)
{
return pow(x, 1);
};

double ableiten(double f(double),double X, double Del)


{
return (f(X + Del) - f(X) ) / Del;
};

void main ( )
{
double x, del = 1.e-15;
int auswahl;
cout << "Eine Funktion whlen 1 - kubisch, 2 - linear "<< endl;
cin >> auswahl;

switch (auswahl)
{
case 1:
cout<<"Berechen der Ableitg. von f(x)=x^3 an der Stelle x= ";
cin>>x;
cout << ableiten(kubischeFunktion, x, del);
break;

case 2:
cout<<"Berechen der Ableitg. von f(x)=x an der Stelle x= ";
cin>>x;
cout << ableiten(lineareFunktion, x, del);
break; // Output: 1

default: cout << "Falsche Eingabe - Programmabbruch";

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Ableitung Seite 53/166

};
system ("PAUSE"); };

bung: 3.30-1

Implementieren Sie das Programm in Visual Studio und berechnen Sie die Ableitung
von f ( x ) x 2 an der Stelle x = 1.

Ab welchem x wird die Berechnung falsch?

2
Berechnen Sie die Ableitung der Funktion f ( x ) 2.0 e x an der Stelle
x = 1 und x = 0

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Nullstellensuche Seite 54/166

2.14 Numerische Nullstellensuche

2.14.1 Nullstellensuche durch lineare Interpolation


Die einfachste Methode nach einer Nullstelle einer Funktion f(x) im Intervall a, b zu suchen,
ist die sog. Mittelpunktsmethode oder auch lineare Interpolationsmethode. Ist f(x) stetig ber
dem Intervall a, b und ist f ( a ) f (b) 0 , dann hat f(x) in diesem Intervall mindestens eine
Nullstelle.
Um nun alle Nullstellen einer Funktion zu finden, muss die Funktion in einem ausreichend
groen Intervall an gengend vielen gleichverteilten Stellen berechnet werden, so dass nicht
mehr als eine Nullstelle zwischen zwei Punkten auftreten kann. Danach werden nur diese
Intervalle weiter bercksichtigt, bei denen die Bedingung f (a ) f (b) 0 erfllt ist.
In Bild 3-22 wird dieser Zusammenhang deutlich mit den Intervallgrenzen [-2,0].

2
f(x)=x -5x-3
50

40

30
f(x)

20

f(-2)>010 gesuchte 1. Nullstelle

f(-1)>0
0
f(0)<0

-10
-4 -2 0 2 4 6 8 10
x-Werte

Bild 3-22 : Nullstellensuche durch lineare Interpolation

Werden nun die Nullstelle in einem Intervall [a,b] gesucht, so wird zuerst der Mittelpunkt
ab
c berechnet.
2

Ist die Bedingung f (b) f (c ) 0 erfllt, dann wird a=c gesetzt und man bekommt eines
neues Interval [c,b] mit dem die Iteration zu Nullstellenbestimmung beginnt.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Nullstellensuche Seite 55/166

Ist f (b) f ( c) 0 , dann liegt die Nullstelle zwischen a und c und man bestimmt die
Nullstelle im Intervall [a,c].
Durch weitere Iterationen wird die Nullstelle bis zu einem vorher definierten Fehler eps
berechnet, indem man die Intervalle immer wieder teilt und einen neuen Mittelpunkt
bestimmt.

Das folgende Programm implementiert den beschriebenen Algorithmus.


Wenn man ein zugroes Intervall um die Nullstelle ansetzt, dann kann passieren, dass durch
die Mittelpunktsstrategie die Nullstelle auerhalb zu liegen kommt und der Algorithmus
diverdiert. Dies wird durch eine entsprechende Abfrage abgefangen.

#include <iostream>
#include <cmath>
#include<cstdlib>
using namespace std;

double quadratischeFunktion(double x) { return x * x -5*x - 3; }

double nullStellenSucheLinear ( double funktion(double),\ double

linkeGrenze, double rechteGrenze, double fehler )

while (fabs(linkeGrenze - rechteGrenze) > fehler)

double mittelPunkt = (linkeGrenze + rechteGrenze) / 2;

if (funktion(mittelPunkt) * funktion(rechteGrenze) <= 0)

linkeGrenze = mittelPunkt;

else rechteGrenze = mittelPunkt;

if(funktion(rechteGrenze)*funktion(linkeGrenze)>0)

{ cout<<endl<<\

" Algorithmus divergiert, da Intervalgrenzen zu gross!

Programmabbruch! "\

<<endl;

return HUGE_VAL; // Unendlich zurckgegeben

};

};

return (linkeGrenze + rechteGrenze) / 2;

};

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Nullstellensuche Seite 56/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Nullstellensuche Seite 57/166

void main( )
{
float linkerWert, rechterWert, fehler, nullStelle;
cout << "Eingabe linke Intervallgrenze, rechte
Intervallgrenze,zulaessiger Fehler" << endl;
cin >> linkerWert >> rechterWert >> fehler;
cout << "linker Wert = " << linkerWert <<\
" rechter Wert = " <<rechterWert \
<< " Fehler = " << fehler;
nullStelle=nullStellenSucheLinear(quadratischeFunktion,\
linkerWert,rechterWert, fehler);
cout << " Nullstelle = " << nullStelle<<endl<<endl;
system ("PAUSE");
};

Die lineare Interpolationsmethode errechnet eine Nullstelle, deren Genauigkeit von


Rundungsfehlern der Berechnungen abhngt, solange die Funktion stetig ist und in dem
gegebenen Anfangsintervall a, b eine einzelne Wurzel enthalten ist. Bei jedem Rechen-
schritt wird das Interpolationsintervall halbiert. Bei komplizierten Funktionen knnen
dadurch aber auch groe Rechenzeiten entstehen.

bung: 3.31-1

Implementieren Sie den Algorithmus der linearen Interpolatzion zur Nullstellensuche in


einem Projekt.

Modifizieren Sie den Programmcode, so dass Sie die Nullstellen aus Bild 3-15
numerisch suchen.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Nullstellensuche Seite 58/166

2.14.2 Nullstellenbestimmung nach dem Tangentenverfahren


Eine wesentlich effizientere Methode zur Nullstellensuche stellt das Verfahren nach Newton
dar.
Bild 3-23 zeigt die prinzipielle Voprgehensweise, indem ein Nherungswert durch lineare
Interpolation mit dem Gradienten (Steigungstangente im jeweiligen Iterationspunkt) gesucht
wird.

Bild 3-23 : Nullstellensuche nach dem Nherungsverfahren nach New-

Es wird also von einer Taylorentwicklung der Funktion um die Nullstelle ausgegangen:

df ( x)
f ( x0 ) Taylor f ( x1 ) x1 x0
dx x1
. (3-10)
f ( x)
f ( x1 ) x1 x0
x x1

Aus der numerischen Nherung lsst sich ein Schtzwert fr die Nullstelle x0 berechnen:

f ( x1 )
x0 x1 . (3-11)
f ( x1 )
x

Gleichung 3-11 wird nun sooft angewandt, bis der Abstand zwischen zwei Werten unterhalb
einer vorgegebenen Fehlergrenze fllt:

xi 1 xi . (3-12)

Die nachfolgende Funktion implementiert den Algorithmus.

double ableitung(double funktion(double), double x)


{
double delta = 1.e-4;
return (funktion(x+delta)-funktion(x-delta))/(2. * delta);

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Nullstellensuche Seite 59/166

double newton(double funktion(double),double schaetzWert,\


double fehler)
{
double delta=- \
funktion(schaetzWert)/ableitung(funktion,schaetzWert);
schaetzWert += delta;
if (fabs(delta) < fehler) return schaetzWert;
else return newton(funktion, schaetzWert, fehler);
//rekursiver Aufruf
}

Ein komplettes Programm zur Nullstellensuch nach beiden Methoden knnte nun
folgendermaen aussehen.

#include <iostream>
#include <cmath>
#include<cstdlib>
using namespace std;
double quadratischeFunktion(double x) { return x * x - 4; }

double nullStellenSucheLinear ( double funktion(double,\


double linkeGrenze, double rechteGrenze, double fehler )
{
while (fabs(linkeGrenze - rechteGrenze) > fehler)
{
double mittelPunkt = (linkeGrenze + rechteGrenze) / 2;
if (funktion(mittelPunkt) * funktion(rechteGrenze)<= 0)
linkeGrenze = mittelPunkt;
else rechteGrenze = mittelPunkt;
if(funktion(rechteGrenze)*funktion(linkeGrenze)>0)
{ cout<<endl<<" Algorithmus divergiert, da Intervalgrenzen zu gross!
Programmabbruch! "<<endl;
return 1e15;
};
};return (linkeGrenze + rechteGrenze) / 2; };
double ableitung(double funktion(double), double x)
{
double delta = 1.e-4;
return(funktion(x+delta)-funktion(x-delta))/(2.0*delta);
};

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Nullstellensuche Seite 60/166

double newton(double funktion(double),\


double schaetzWert,double fehler)
{
double delta = -\
funktion(schaetzWert)/ableitung(funktion,schaetzWert);
schaetzWert += delta;
if (fabs(delta) < fehler) return schaetzWert;
else return newton(funktion,schaetzWert,fehler);
//rekursiver Aufruf
};

void main( )
{
float linkerWert,rechterWert,fehler,geschaetzteNullstelle;
double nullStelle;
cout << "Eingabe linke Intervallgrenze, rechte Intervallgrenze,
zulaessiger Fehler" << endl;
cin >> linkerWert >> rechterWert >> fehler;
cout << "linker Wert = " << linkerWert \
<< " rechter Wert = " \
<< rechterWert<< " Fehler = " << fehler;

// lineares Interpolationsverfahren

nullStelle= nullStellenSucheLinear(quadratischeFunktion,\
linkerWert, rechterWert, fehler);
cout << " Nullstelle = " << nullStelle<<endl;

// Verfahren nach Newton

cout<<"Nullstellensuche nach Newton "<<endl<<endl;


cout << "Eingabe einer geschaetzten Nullstell" << endl;
cin >> geschaetzteNullstelle;
cout << "geschaetzte Nullstelle = " \
<< geschaetzteNullstelle \
<< "\ Fehler= " << fehler;
nullStelle = newton(quadratischeFunktion,\
geschaetzteNullstelle,fehler);
cout << " berechnete Nullstell= " << nullStelle;
system ("PAUSE");
};

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Nullstellensuche Seite 61/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerische Nullstellensuche Seite 62/166

bung: 3.31-2

Implementieren Sie den Newton'schen Algorithmus in einem Projekt.

Verwenden Sie den Newton'schen Algorithmus, um die Nullstellen aus Bild 3-15
numerisch zu suchen.

Wann divergiert der Newtonsche Algorithmus

Demonstrieren Sie diese Divergenzproblematik anhand des obigen Beispiels

bung: 3.31-3

Gegeben ist folgender Funktionsgraph

y=f(x)
3

2.5

1.5

0.5
y

0
X1 X2
-0.5

-1

-1.5

-2
0 0.5 1 1.5 2 2.5 3 3.5 4
x

Berechnen Sie in einem Hauptprogramm die Flche unter der Kurve


float f(float x)
zwischen den Schnittpunkten mit der x-Achse in der Nhe der Punkte x1 und x2.
Benutzen Sie die Nherungen x1 und x2 als Startwerte zur Berechnung der
Nullstellen der Funktion f(x).
Benutzen Sie die Funktionen zur Integration und Nullstellensuche aus Kapitel 2.12
, 2.13 und 2.14.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerischen Lsung linearer Gleichungssysteme Seite 63/166

2.15 Numerischen Lsung linearer Gleichungssysteme

Lineare Gleichungssysteme werden oft in Matrixschreibweise notiert:



A x b . (3-13)

Was ausgedrckt in den Komponenten Aij der Matrix A bedeutet:


N

A
j 1
ij x j bi . (3-14)

Der Gauss'sche Eliminationsalgorithmus subtrahiert nun die Gleichungen

a11 x1 a12 x2 a1N x N b1


a21 x1 a22 x2 a2 N x N b2
(3-15)

a N 1 x1 a N 2 x2 a NN xN bN

so voneinander, dass ein quivalentes Gleichungssystem folgender Form entsteht:

a11 x1 a12 x2 a1N x N b1


a (2)
22 x2 a (2)
2N x N b2(2)
(3-16)

a N(2)2 x2 a NN
(2)
xN bN(2)

Falls a11 0 ist, dann kann man Gl. (3-15) in Gl. (3-16) mit Zeilenoperationen berfhren:

neue Zeile j = alte Zeile j - lj1 * alte Zeile 1, j= 2,3 N .

a j1
mit l j1 (3-17).
a11

Mit den Gleichungssystem (3-16) fhrt man nun analog fort und eliminiert alle vorangehen-
den
(N )
Elemente unterhalb der Diagonalen. Es bildet sich eine Diagonalmatrix A .
Die letzte Gleichung sieht dann folgendermaen aus:

(N )
(N )
AN , N x N b N . (3-18)

Die in Klammern geschriebenen Indices in Gleichung 3-16 bis 3-18 bedeuten dabei, die durch
die Rechenschritte j= 2, 3, .. N aufgebauten neuen Elemente.
Hierbei wird vorausgesetzt, dass alle Diagonalelemente aii( l ) 0 fr l=1,2N. Sollte dies

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerischen Lsung linearer Gleichungssysteme Seite 64/166

jedoch der Fall sein, dann versagt der Gau'sche Algorithmus, und die Matrix A ist singulr,
d.h. das Gleichungssystem ist linear abhngig und nicht eindeutig lsbar.
Der folgende Programmcode implementiert den Gau'schen Algorithmus fr ein 2x2-
Gleichungssystem.

(N )
(N )
Die Vorwrtselimination erzeugt die diagonale Matrix A N , N x N b N und die Rckwrt-

selimination berechnet mit dieser Matrix rckwrts den Lsungsvektor x mit den Elementen
xi.

#include <iostream>
#include<cstdlib>
using namespace std;
const int n = 2;

void gauss(double A[ ][n], double x[ ], double b[ ])


{

// vorwrts Elimination
for ( int i = 0; i < n; i ++ )

{
if ( !A[i][i] )
{
// wenn A[i][i]==0 dann entspricht das false
cout<<"Abbruch Matrix ist singulr!"<<endl;
return;
};
for ( int j = i + 1; j < n; j++ )
{
double d = A[j][i]/A[i][i];
for (int k=i+1;k<n;k++) A[j][k] -= d*A[i][k];
b[j] -= d*b[i];
};
};
if ( !A[n-1][n-1] )
//wenn A[i][i]==0 dann entspricht das "false"
{cout<<"Abbruch Matrix ist singulr!"<<endl;return;};
// rckwrts Substitution
for ( int i = n - 1; i >= 0; i-- )
{
x[i] = b[i];
for ( int j=i+1;j < n;j++ )x[i] -= A[i][j] * x[j];
x[i] /= A[i][i];
};
};
C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerischen Lsung linearer Gleichungssysteme Seite 65/166

void main()

double A[n][n], b[n];

double x[n];

for ( int i = 0; i < n; i ++ )

for ( int j = 0; j < n; j ++ )

cout<<" Eingabe A["<<i+1<<"]["<<j+1<<"]=";

cin>>A[i][j];

};

};

for (int i = 0; i < n; i ++ )

cout<<" Eingabe b["<<i+1<<"]=";

cin>>b[i];

};

gauss(A, x, b);

cout << x[0] << '\t' << x[1] << endl;

system ("PAUSE");

};

bung: 3.32-1

Implementieren Sie den Gaussschen Eliminationsalgorithmus in einem Projekt.

Wie lautet die Lsung des Gleichungssystems:

1 2 x1 2
?
3 8 x2 5

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerischen Lsung linearer Gleichungssysteme Seite 66/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Numerischen Lsung linearer Gleichungssysteme Seite 67/166

Erweitern Sie den Gausschen Algorithmus fr ein 3-dimensionales Problem:


1 2 3 x1 2

.5 1.7 0 x2 5 .
1 x 3
2 1.93 3
3


Wie sieht der Lsungsvektor x aus?

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassen Seite 68/166

2.16 Klassen
Die OOP (objektorientierte Programmierung) zielt vor allem darauf, den Code bersichtli-
cher und sicherer zu machen. Man erreicht dies, indem man - hnlich einer Datenstruktur -
Daten (Atribute) und zugehrige Funktionen (Methoden) in einem Objekt kapselt.
Der Begriff der Klasse bildet die Basis der objektorientierten Programmierung. Darauf bauen
weitere Konzepte wie Vererbung, Polymorphismus und Templates etc. auf.

2.16.1 NimmSpiel als Klasse


Das NimmSpiel als Klasse zu schreiben, ist - nachdem der alte Code vorliegt - recht einfach.
Die Klasse wird definiert durch den Befehl:

class Klassenname
{
};

In gescheiften Klammern steht dann die Klasse selbst mit Ihren Attributen und Methoden. Ein
obligatorisches Semikolon nach der schlieenden Klammer beendet die Klassendefinition.
Dabei bedeutet die Zeile

void zugRechner()

dass die zugRechner-Funktion keinen Rckgabewert hat. Sie soll also nichts ausrechnen, ganz
im Gegensatz zu den Funktionen, die wir bisher gesehen haben, sondern nur etwas ausfhren.
In anderen Sprachen heien solche Funktionen Prozeduren. In C++ sagt man void-Funktion.

private:

wehrt alle Versuche ab, Sachen zu verwenden, die private sind.

Generell gilt, dass alle Attribute privat sein sollten!

Dabei bedeutet privat nicht, dass keine anderen Objekte auf die Attribute eines Objektes
zugreifen knnen. Die Objekte aus derselben Klasse drfen sich gegenseitig in die Karten
sehen und die klasseneigenen Attribute auch ndern.

public:

Auf alles, was jetzt kommt, darf von auerhalb der Klasse zugegriffen werden.

Das Hauptprogramm muss jetzt keine Details mehr ber das Nimm-Spiel wissen. Man
braucht nur darauf zu achten, dass der Spielablauf korrekt ist. Und das schnste daran ist, dass
genau dieses Hauptprogramm fr sehr viele Spiele funktioniert, wenn man nur eine andere
Klasse einsetzt.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassen Seite 69/166

#include <iostream>
#include<cstdlib>
using namespace std;
class NimmSpiel
{
private:
int anzahlDerMuenzen;
public:
void zugRechner()
{
int wunschZug=anzahlDerMuenzen%4;
if(wunschZug==0)
anzahlDerMuenzen=anzahlDerMuenzen-1;
else
anzahlDerMuenzen=anzahlDerMuenzen-wunschZug;
};
void zugMensch()
{
int ergebnis;
cout<<"Jetzt liegen "<<anzahlDerMuenzen<<" Muenzen
auf dem Tisch."<<endl;
cout<<"Wieviele moechten Sie nehmen? ";
cin>>ergebnis;
anzahlDerMuenzen=anzahlDerMuenzen-ergebnis;
};
bool gewonnen()
{
return anzahlDerMuenzen==0;
};
void starteSpiel()
{
cout<<"Mit wievielen Muenzen fangen wir an? ";
cin>>anzahlDerMuenzen;
};
};

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassen Seite 70/166

void main()
{
NimmSpiel meinSpiel, deinSpiel; // Instanziierung zweier Spiele
meinSpiel.starteSpiel();
deinSpiel.starteSpiel();
while(true)
{ meinSpiel.zugRechner();
if(meinSpiel.gewonnen())
{ cout<<"Ich habe gewonnen!"<<endl; system ("PAUSE");
return;
};
meinSpiel.zugMensch();
if(meinSpiel.gewonnen())
{ cout<<"Sie haben gewonnen!"<<endl;
system ("PAUSE");
return;
};
};
};
Die einzelnen Methoden zugRechner, zugMensch, gewonnen und starteSpiel sind innerhalb
der Klassen-Definition deklariert und definiert, man sagt auch dazu, dass die Methoden inline
definiert sind. blich bei C++ ist das Trennen von Deklaration und Definition der Klassen
und Methoden in unterschiedlichen Dateien (s. weiter unten).

Im Hauptprogramm wird dann eine Instanz der Klasse NimmSpiel mit Namen
meinSpiel durch den Konstruktor:

NimmSpiel meinSpiel;
erzeugt.

Man knnte in einem Hauptprogramm auch mehrere Spiele gleichzeitig initiieren und spielen:

NimmSpiel meinSpiel, deinSpiel;

Ein Konstruktor einer Klasse besitzt den Gleichen Namen wie die Klasse, besitzt aber
keinen Ergebnistyp (auch nicht void):

klassenName instanzName;

Der Konstruktor wird i.d.R. im Public-Bereich der Klasse definiert. Er kann Parameter zur
Initialisierung von Attributen enthalten (s. u.).

Ein Konstruktor ohne Parameter ist ein sog. Default-Konstruktor. Besitzt die Klasse keine
Konstruktor-Definition, so erzeugt der Compiler eine Minimalversion eines Default-
Konstruktors.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassen Seite 71/166

Primre Aufgabe eines Konstruktors ist der ordnungsgeme Aufbau der Klasse und die
Initialisierung Ihrer Attribute.

Der Default- oder Standardkonstruktor wird immer ohne Klammern aufgerufen!

Auf die einzelnen Methoden - den in der Klasse NimmSpiel definierten Funktionen - kann
man ber

meinSpiel.Methode(parameter)

zugreifen.

Die Anzahl der Mnzen, die den Speilverlauf bestimmen, stellen Daten der Klasse dar, und
sind als private-Attribute definiert und damit auen nicht direkt zugnglich noch sichtbar.

2.16.2 Klasse Vektoren


Im folgenden Beispiel ist eine Klasse vektor definiert, deren Konstruktor auch die Initialisie-
rung des Vektors bernimmt

#include <iostream>
#include<cstdlib>
using namespace std;

class vektor
{
private :

double x, y;

public:
vektor() // Konstruktor
{
x=0.0;
y=0.0;
};
void ausgeben() // Methode
{
cout<<"("<<x<<","<<y<<")";
};
void addiereVektor(vektor) // Methode
{
// hier kommt der zugehrige Quellcode
};
};

Die Koordinatenwerte x und y sowie die zugehrigen Polarkoordinaten sind Daten, also Attri-
bute, die i.d.R. ffentlich nicht zugnglich gemacht werden sollten. Sie sollten als private
deklariert werden:

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassen Seite 72/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Konstante Elementfunktionen Seite 73/166

private :
double x, y;
Um dennoch die Koordinatenwerte in einem Programm verfgbar zu machen, mssen wir
wieder eine entsprechende Methode formulieren:

double get_x();
double get_y();
Sie werden wie folgt implementiert:
double get_x() { return x; };
double get_y() { return y; };
Der Rckgabewert der public-Methode get_x/y an das aufrufende Programm ist der
Attributwert der Vektorklasse. Mittels einer klasseneigenen Funktion haben wir auf die Attri-
bute zugegriffen.

2.17 Konstante Elementfunktionen


Setzt man einen Zusatz const hinter den Klassen-Methoden, dann kann die Methode die At-
tribute der Klasse nicht verndern. Im Klassenbeispiel vektor knnten - versehentlich durch
Programmfehler - die Koordinaten verndert werden. Daher ist es guter Programmierstil, den
Zugriff auf Klassenattribute gegen versehentlich nderungen abzufedern, indem man die
Methoden get_.. als konstante Elementfunktionen definiert:

double get_x()const;
double get_y()const;

Sollten durch Programmierfehler in diesen Methoden versucht werden, private Attribute zu


ndern, dann wrde der Compiler dies mit einer Fehlermeldung quittieren.

Man verwendet const wo immer mglich. D.h. man deklarieren Elementfunktionen, die den
Zustand des Objekts nicht ndern sollen, stets als const. Der Compiler kann dann die Feh-
lersuche erleichtern. Das geht schneller und ist weniger aufwendig, als wenn man es selbst
machen msste.

bung: 3.34-1

Ergnzen Sie sie Klassendefinition um die Methode

void addiereVektor(vektor v2).

Konstruieren Sie eine neue Methode zum Setzen der Koordinatenwerte vom main-
Modul aus

void setze_x(double x_wert);


void setze_y(double y_wert)

sowie die Methoden

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Konstante Elementfunktionen Seite 74/166

double get_laenge()const. // Berechnung der Vektorlnge


void einheitsVektor() // Definition eines Einheitsvektors

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Externe Methodendefinition Seite 75/166

2.18 Externe Methodendefinition


Man kann die Methoden auch auerhalb der Klasse definieren. Dazu muss man lediglich den
Klassenbezug ber folgende Konstruktion herstellen

void klasse::methodeFrKlasse(parameter)

Fr die Methode addiereVektor knnte also die Kopfzeile folgendermaen aussehen

void vektor::addiereVektor(vektor v2)

Wichtig ist dabei allerdings, dass innerhalb der Klasse der Prototyp der Methode dekla-
riert wird, sonst weist der Compiler eine externe Methodendefinition zurck.

2.19 Klassenkonstruktor
Wenn Sie keinen Konstruktor oder Destruktor deklarieren, erzeugt der Compiler einen sol-
chen selbstttig. Dieser Standardkonstruktor und Standarddestruktor bernimmt keine
Argumente und tut auch nichts.
Der Destruktor schliet eine Klasse, baut sie so zu sagen wieder ordentlich ab und gibt u.U.
belegte Speicherbereiche wieder frei.
Wenn man ein Objekt einer Klasse definiert, wird der Konstruktor aufgerufen.
Durch bergabe von Parametern an den Konstruktor kann man auch Attribute einer Klasse
initialisieren. Fr die oben definierte Vektor-Klasse knnte man also schreiben:

vektor::vektor(double x_wert, double y_wert)


{
x = x_wert;
y = y_wert;
laenge = sqrt(x*x + y*y);
}

An diesem Konstruktor ist bemerkenswert, dass er nicht nur die Koordinaten initialisiert
sondern auch gleichzeitig die Lnge, damit diese immer den aktuellen Wert behlt. Wenn
man dies vergisst, dann ist die Klasse schlecht oder falsch programmiert. Es liegt also in der
Verantwortung des Klassenprogrammierers hier keine Fehler zu machen. Der Anwender der
Klasse wei u.U. nicht genau, was hinter all den Klassenmethoden steckt und wrde Fehler
nicht oder nur sehr schwer finden

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassenkonstruktor Seite 76/166

bung: 3.36-1

Vervollstndigen Sie die Klasse Vektor mit dem initialisierenden Konstruktor und bin-
den Sie die Klasse in einem main-Modul ein, um sie auszuprobieren.

Ergnzen Sie die Klasse Vektor durch die Methoden

void vektor::subtrahieren(vektor v2)


void vektor::skalaresprodukt(double n)
double vektor::vektorprodukt(vektor v2)

Als skalares Produkt ist hier eine Dehnung des Vektors zu verstehen, und das Vektorprodukt
gibt den Betrag des Kreuzproduktes (z-Koordinate) an.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ berladen des Klassenkonstruktors Seite 77/166

2.20 berladen des Klassenkonstruktors

In einer Klassendefinition knnen verschieden Konstruktoren gleichzeitig definiert werden,


die sich durch die Anzahl oder Reihenfolge der Parameter unterscheiden mssen (Polymor-
phie). Man spricht dann von berladen einer Funktion - hier des Klassen-Konstruktors.

Zur Illustration der Nutzung mehrerer Konstruktoren stellen wir uns eine Klasse Rect vor, die
ein Rechteck kapselt (Rechtecke werden in der Windows-Programmierung hufig verwendet).

Diese Klasse knnte viele Konstruktoren besitzen, darunter auch einen Standardkonstruktor,
der alle Datenelemente auf 0 setzt, und einen anderen, mit dem man den Datenelementen
bestimmte Anfangswerte zuweisen kann:
class Rect
{
public:
Rect(); // Definition der Prototypen der Mezhoden
Rect(int _left, int _top, int _bottom, int _right);
int GetWidth();
int GetHeight();
void SetRect(int _left, int _top, int _bottom, int _right);
private:
int left;
int top;
int bottom;
int right;
};

Die Definitionen fr die Konstruktoren wrden dann etwa so aussehen:


Rect::Rect() // Implementierung der Methoden
{
left = 0;
top = 0;
bottom = 0;
right = 0;
}
Rect::Rect(int _left, int _top, int _bottom, int _right)
{
left = _left;
top = _top;
bottom = _bottom;
right = _right;

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Initialisierungslisten Seite 78/166

Der erste Konstruktor ist ein Standardkonstruktor, insofern als er keine Parameter besitzt. Der
zweite Konstruktor benutzt die ihm bergebenen Argumente, um die Datenelemente entspre-
chend zu initialisieren.
Die Variablen in der Parameterliste sind lokal. Alle beginnen mit einem Unterstrich, um sie
von den Datenelementen der Klasse zu unterscheiden. Damit htten wir ein Beispiel fr den
problemlosen Einsatz von Variablennamen mit vorangehendem Unterstrich.
Die Auswahl des Konstruktors erfolgt bei der Instanziierung der Klasse, also wenn Sie ein
Objekt der Klasse bilden. Zum Beispiel verwendet der folgende Quelltextauszug fr jede der
beiden Instanzen der Klasse Rect einen anderen Konstruktor:

Rect rect1; // Standardkonstruktor zur Bildung der


// Instanz rect1 der Klasse Rect
Rect rect2(0, 0, 100, 100);
// zweiter Konstruktor fr Instanz rect2

Man kann so viele Konstruktoren definieren, wie man will. Die Parameterlisten mssen aller-
dings voneinander verschieden sind (gem den Regeln fr das berladen von Funktionen).

2.21 Initialisierungslisten
In C++ knnen auch sogenannte Initialisierungslisten verwendet werden, um die Datenele-
mente der Klassen zu initialisieren.
Das folgende Beispiel zeigt, wie man auf saubere Art und Weise die Datenelemente einer
Klasse initialisieren kann. Nehmen wir wieder die Rect-Klasse als Beispiel. Mit Initialisie-
rungsliste sehen die Konstruktoren dann folgendermaen aus:

Rect::Rect() :
left(0),
top(0),
bottom(0),
right(0)
{
}

Rect::Rect(int _left, int _top, int _right , int _bottom) :


left(_left),
top(_top),
bottom(_bottom),
right(_right)
{
}

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Initialisierungslisten Seite 79/166

Zwei Dinge sind hier zu beachten. Zum einen geht der Liste ein Doppelpunkt voraus, und
zum anderen werden die einzelnen Variablen durch Kommata voneinander getrennt.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassendestruktor Seite 80/166

2.22 Klassendestruktor
Der Destruktor ist sozusagen das Gegenteil des Konstruktors. Er wird verwendet, um den
Speicherplatz (der vom Konstruktor reserviert wurde) wieder freizugeben, und sonstige Auf-
rumarbeiten zu verrichten.
Eine Klasse muss keinen Destruktor haben, wenn sie aber einen Destruktor definiert, dann
genau einen. Ein Destruktor besitzt keine Parameter und liefert auch keinen Wert zurck.
Der Name des Destruktors entspricht dem Klassennamen mit einer vorangestellten Tilde (~).
Der Destruktor wird vor der Auflsung eines Klassen-Objekts aufgerufen. Wurde das Objekt
auf dem Stack abgelegt, so wird es beim Verlassen des Gltigkeitsbereichs aufgelst. Befin-
det sich das Objekt auf dem Heap, kann es durch den Aufruf von delete gelscht werden. In
jedem Fall ist der Destruktor die letzte Methode, die eine Klasseninstanz aufruft.
Die Rect-Klasse sieht jetzt so aus:
class Rect
{
public:
Rect(); // Konstruktoren
Rect(int _left, int _top, int _bottom, int _right);
~Rect(); // hinzugefuegter Destruktor
int GetWidth();
int GetHeight();
void SetRect(int _left, int _top, int _bottom, \
int _right);
private:
int left;
int top;
int bottom;
int right;
float* daten; // neues Klassenelement
};
Rect::Rect() :
left(0),
top(0),
bottom(0),
right(0)
{
daten = new float[1000];
// ev. weiterer Code
}
Rect::~Rect()
// Destruktor gibt den vektor daten auf dem heap wieder frei

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassendeklaration und Methodendefinition Seite 81/166

{ delete[] daten; };

Diese modifizierte Version der Rect-Klasse reserviert im Konstruktor Speicherplatz fr das


float-Array daten. Dieser Speicherplatz wird im Destruktor wieder freigegeben.

bung: 3.39-1

Schreiben Sie die Methode


void SetRect(int _left, int _top, int _bottom, int _right)

und implementieren Sie die ganze Klasse Rect.

Schreiben Sie ein Hauptprogramm, dass mit Hilfe der Rect-Klasse ein Rechteck defi-
niert. Lesen Sie dazu die Rechteckkoordinaten ein, weisen Sie diese dem Rechteck zu
und lesen wieder mit den Klassenmethoden die Werte aus, um sie am Bildschirm auszu-
geben.

Berechnen mit Hilfe der Methoden GetWidth und GetHeight das Volumen des Recht-
eckes.

2.23 Klassendeklaration und Methodendefinition


Jede deklarierte Funktion muss eine Definition haben. Die Definition einer Funktion bezeich-
net man auch als Implementierung. Wie jede andere Funktion, hat auch die Definition einer
Klassenmethode einen Funktionskopf und einen Funktionsrumpf.
Die Definition muss in einer Datei stehen, die der Compiler finden kann. Die meisten C++-
Compiler erwarten, dass diese Datei auf .c oder .cpp endet.
Obwohl man durchaus die Deklaration in der gleichen Datei unterbringen kann wie die Defi-
nition, gehrt dieses Vorgehen nicht zum guten Programmierstil. Die von den meisten Pro-
grammierern anerkannte Konvention ist die Unterbringung der Deklaration in einer soge-
nannten Header-Datei, die gewhnlich den gleichen Namen hat, aber auf h, .hp oder .hpp
endet.

So schreibt man zum Beispiel die Deklaration der Klasse vektoren in eine Datei namens
vektoren.h und die Definition der Klassenmethoden in der Datei vektoren.cpp.

Die Header- Datei bindet man dann in die .cpp-Datei ein, indem man den folgenden Code
an den Beginn von vektor.cpp schreibt:
#include " vektoren.h "

Damit weist man den Compiler an, vektor.h in die Datei einzulesen, gerade so als htte
man ihren Inhalt an dieser Stelle eingetippt.
Man beachten, dass einige Compiler darauf bestehen, dass die Gro- und Kleinschreibung
zwischen der # include-Anweisung und dem Dateisystem bereinstimmt.
Die Deklaration einer Klasse sagt dem Compiler, um welche Klasse es sich handelt, welche
Daten sie aufnimmt und welche Funktionen sie ausfhrt. Die Deklaration der Klasse bezeich-

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassendeklaration und Methodendefinition Seite 82/166

net man als Schnittstelle (Interface), da der Benutzer hieraus die Einzelheiten zur Interaktion
mit der Klasse entnehmen kann.
Die Funktionsdefinition sagt dem Compiler, wie die Funktion arbeitet. Man bezeichnet die
Funktionsdefinition als Implementierung der Klassenmethode und legt sie in einer .cpp-
Datei ab. Die Implementierungsdetails der Klasse sind nur fr den Autor der Klasse von
Belang. Klienten der Klasse - das heit, die Teile des Programms, die die Klasse verwenden -
brauchen nicht zu wissen (und sich nicht darum zu kmmern), wie die Funktionen implemen-
tiert sind.
An dem Beispiel vektor soll das Vorgehen veranschaulicht werden:

// Datei vektor.h Klassendeklaration

class vektor
{
private:
double x, y,laenge;
public:
// Konstruktoren
vektor();
vektor(double _x, double _y);
// Methoden
void ausgeben()const ;
void addiereVektor(vektor v2);
void subtrahieren(vektor _2terVektor);
void setze_x(double _x);
void setze_y(double y_wert);
double get_x()const ;
double get_y()const ;
double get_laenge()const;
double get_winkel()const;
void skalaresprodukt(double n);
double vektorprodukt(vektor v2) ;
};

// Datei vektor.cpp Klassenimplementierung

#include<cmath>
#include"vektor.h" //Einbinden der Klassendeklaration
using namespace std;
/* Implementierung (Definition) der
Klassenmethoden und Konstruktoren*/
// Konstruktoren
vektor::vektor()
{

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassendeklaration und Methodendefinition Seite 83/166

x=0.0;
y=0.0;
laenge=0.0;
};
vektor::vektor(double _x, double _y)
{
x=_x; y=_y; laenge = sqrt(x*x +y*y);
};
// Methoden
void vektor::ausgeben()const
{
cout<<" Vektor("<<x<<","<<y<<")"\
<<" mit Laenge= "<<laenge<<endl ;
};
void vektor::setze_x(double _x)
{ x=_x;
laenge=sqrt(pow(x,2)+pow(y,2));
};
void vektor::setze_y(double y_wert)
{ y=y_wert;
laenge=sqrt(pow(x,2)+pow(y,2));
};
double vektor::get_x()const {return x;};
double vektor::get_y()const {return y;};
double vektor::get_laenge()const{return laenge;};
double vektor::get_winkel()const{return 180/3.1415*atan(y/x);}
void vektor::subtrahieren(vektor v_2terVektor)// Methode
{
x+= v_2terVektor.x;
y=y+v_2terVektor.y;
laenge=sqrt(pow(x,2)+pow(y,2));
};
void vektor::addiereVektor(vektor v2)
{
x-=v2.x; y-=v2.y;laenge=sqrt(pow(x,2)+pow(y,2));
};
void vektor::skalaresprodukt(double a)
{
x=x*a; y *=a; laenge*=a;
};
double vektor::vektorprodukt(vektor v2)
{

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassendeklaration und Methodendefinition Seite 84/166

return (x * v2.y) - (y * v2.x);


};

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassendeklaration und Methodendefinition Seite 85/166

// Anwenderprogramm

#include <iostream>
#include<cmath>
#include<cstdlib>
#include"vektor.h" // Einbinden der Klasse
using namespace std;
void main ()
{
vektor v1, meinVektor, deinVektor;
vektor v2(-2,3);
v1.setze_x(1.0);
v1.setze_y(2.0);
cout<<"Laenge meines Vektors v1= "<<v1.get_laenge()<<endl;
v1.ausgeben();
deinVektor.ausgeben();
cout<<"Winkel meines Vektors v1= "<<v1.get_winkel()<<endl;
v2.ausgeben();
v1.subtrahieren(meinVektor);
vektor neuerVektor(3.3, 6.6);
neuerVektor.ausgeben();
cout<<endl<<endl<<"Skalaresprodukt"<<endl;
v1.skalaresprodukt(2.0);
v1.ausgeben();
double z_komp=v1.vektorprodukt(v2);
cout<<endl<<"z-Komponente des Vektorproduktes ="\ <<z_komp<<endl;
system("PAUSE");

};

Klassendeklarationen werden in der Regel in einer .h-Datei


abgelegt, die dann mit #include in die verbundene
.cpp-Anwendung eingebunden wird.

In einem Anwenderprogramm (Modul main) wird dann eben-


falls die Klasse ber die Headerdatei der Klassendeklaration
eingebunden.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassendeklaration und Methodendefinition Seite 86/166

bung: 3.40-1

Definieren Sie eine Klasse Zylinder mit den Parametern hoehe und radius als float
Parameter.
Programmieren Sie einen Standardkonstruktor, der dem Zylinder jeweils den Radius
und die Hhe Null zuweist.
Implementieren Sie folgende Methoden:

float get_volume()const // Volumen des Zylinders


void set_radius(float radius)// Ein neuer Radius wird definiert
void set_hoehe (float hoehe) // Eine neue Hhe wird definiert

bung: 3.40-2

Im nachstehenden Programmtext wird die Klasse point deklariert.


Was gibt das untenstehende Programm aus?

#include <cmath>
#include <iostream>
#include <cstdlib>
using namespace std;
class point // Klassendefinition
{
public:
point(){};
point(float _x,float _y){x=_x;y=_y;}; // Konstruktoren
void set_point(float x_wert,float y_wert) // Methode
{ x=x_wert; y=y_wert;};
void ausgabe() // Methode
{ cout<<"("<<x<<","<<y<<")"<<endl;};
float abstandPoint(point p2); // Methode

private:
float x,y; // Attribute
};
void main()
{
point P1,P2,P4; point P3(3.0,3.0);
float p1_wert_x=1.0; float p1_wert_y=1.0;
P1.set_point(p1_wert_x,p1_wert_y);
P2.set_point(2.0,2.0);
float distance1=P1.abstandPoint(P2);
float distance2=P2.abstandPoint(P3);
cout<< "Abstand 12 = "<<distance1<<\

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassendeklaration und Methodendefinition Seite 87/166

" Abstand 23 = "<<distance2<<endl;


distance1=P2.abstandPoint(P1);
distance2=P3.abstandPoint(P1);
cout<< "Abstand 21 = "<<distance1<<\
" Abstand 31 = "<<distance2<<endl;
float distance3=P1.abstandPoint(P4);
cout<< "Abstand 14 = "<<distance3<<endl;
system ("PAUSE");
};
float point::abstandPoint(point p2)
{
return sqrt(pow(x-p2.x,2)+pow(y-p2.y,2));
};

bung: 3.40-3

Was gibt das nachfolgende Programm aus?

#include <cmath>
#include <iostream>
#include <cstdlib>
using namespace std;
class werte
{
private:
int wert[3];
public:
werte()
{ for (int i=0;i<=2;i++) wert[i]=0; };
werte(int _wert1,int _wert2,int _wert3)
{ wert[0]=_wert1;
wert[1]=_wert2;
wert[2]=_wert3; }
void addition(int summand)
{
for (int i=0;i<=2;i++)
wert[i]=wert[i]+summand;
}
void addition(int summand0,int summand1,int summand2)
{
int summand[3]={summand0,summand1,summand2};
for (int i=0;i<=2;i++)wert[i]=wert[i]+summand[i];
}

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassendeklaration und Methodendefinition Seite 88/166

void ausgabe()
{
for (int i=0;i<=2;i++)
cout<<"Wert "<<i<<": "<<wert[i]<<endl;}
};
void main()
{
//Objekt werte1 der Klasse werte wird initialisiert
werte werte1;
werte1.addition(2);
werte1.addition(1,2,3);
werte1.ausgabe();
system ("PAUSE");

};

bung: 3.40-4

Erstellen Sie eine Klasse Auto mit den Attributen:

Attribut Typ
farbe string
hubraum int
motorLaeuft bool Motor luft -> motorLaeuft=true
kmStand int
kmStandGesamt int
tankAnzeige bool Tank leer -> tankAnzeige = false

und den Methoden:

void fahren(int anzahlKm)


void starten()
void tanken()

sowie einen Konstruktor, der ein Auto mit vollen Tank und dem Km-Stand von 0 km er-
zeugt.

Beachten Sie, dass zum Fahren der Motor angelassen sein muss.
Man kann nur tanken, wenn man mindestens 100 km gefahren ist bzw. man muss tan-
ken, wenn man mehr als 500 km gefahren ist.
Das Tanken setzt den kmStand wieder auf Null zurck und kann nur bei ausgeschalte-
tem Motor erfolgen.

Schreiben Sie ein kleines Hauptprogramm, das eine Instanz meinAuto bildet
(meinAuto ist rot, vom Typ VW und hat 2000 ccm Hubraum).

Ich fahre mit meinem Auto 150 km, gehe tanken und fahre weitere 500 km.

Wie sehen danach die Attribute von meinAuto aus?

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassendeklaration und Methodendefinition Seite 89/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassendeklaration und Methodendefinition Seite 90/166

bung: 3.40-5

Erstellen Sie eine Klasse Roboter mit den Attributen:

Attribut Typ
x, y, z float Positionskoordinaten des Roboterarms
phi float Drehwinkel bezogen auf die x-Achse
motor bool Robotermotor eingeschaltet -> motor = true,
greifer int 0 = Greifer ist geschlossen, 100= Greifer ist ganz
geffnet
anzahlAchsen int
stop bool Roboter ausgeschaltet
start bool Roboter eingeschaltet
position_greifer bool true = Position erreicht, wird von einem Sensor erfasst
position_arm bool true = Position erreicht, wird von einem Sensor erfasst

und den Methoden:


void starten(),
void ausschalten(),
void drehen(float _wert),
bool greifer_oeffnung(int _wert) ffnet den Greifer auf einen Wert _wert, Rckga-
bewert= true, wenn der Greifer seine Position er-
reicht hat,
bool position_anfahren(float x_wert, floar y_wert, float _z_wert)
Rckgabewert=true, wenn der Roboter seine Po-
sition erreicht hat,
bool neue_position(float x_wert, floar y_wert, float _z_wert)
fhrt neue Position an, Rckgabewert=true, wenn
der Roboter seine Position erreicht hat

sowie einen Konstruktor, der einen Roboter mit 6 Achsen im ausgeschalteten Zustand
erzeugt. Der Greifer ist geschlossen und der Roboter steht im Koordinatenursprung in
Richtung y-Achse.

Beachten Sie, dass zum Anfahren einer neuen Position der entsprechenden Methode
nur die nderungen in den Positionswerten bergeben wird.

Schreiben Sie ein kleines Hauptprogramm, das eine Instanz Robo1 und Robo2 mit
jeweils 6 Achsen bildet. Dann wird der Roboter 1 eingeschaltet und auf die Position
(10,20,30) gesteuert. Hier wird der Greifer zu 50% geffnet und danach auf die Positi-
on (10,25,30) gefahren. Dort wird ein Teil aufgegriffen und der Roboter wieder auf den
Ursprung gefahren, wo er das gegriffene Stck loslsst. Der Roboter 2 wird eingeschal-
tet und um einen Winkel von 30 gedreht. Er greift dann ein Teil in der Position
(20,20,40) und transportiert es auf die Position (10,10,10), um es dort abzusetzen. Ro-
boter 1 wird ausgeschaltet.

Wie sehen nach Ablauf des Hauptprogramms die Attribute von Roboter 1 und 2 aus?

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Vererbung Seite 91/166

2.24 Vererbung
Ein wichtiges Konzept zur Untersttzung der Wiederverwendbarkeit von Programmcode ist die
Vererbung.

Vererbung zeichnet sich durch folgende Punkte aus:

Gemeinsame Attribute u./o. Methoden knnen von einem Objekt auf das andere vererbt
werden.
Es gibt i.d.R. geringe Unterschide zwischen den Objekten.
Die Vererbung beschreibt eine ist ein Beziehung.
Die Vererbung ist hierarchisch organisiert und ist eine gerichtete Beziehung.

Ein Auto ist ein Landfahrzeug, Ein Flugzeug ist ein Luftfahrzeug. Beide sind Fahrzeuge und kn-
nen demzufolge von einer Oberklasse Fahrzeuge Methoden (z.B. starten(), tanken() etc.) und Attri-
bute (z.B. farbe etc.) erben.

Das folgende Beispiel deklariert diese Klassen.

#include <string>
using namespace std;
class Fahrzeuge // Basisklasse
{
protected: // abgeleitete Klassen erben auch die Attribute im Modus
// protecetd
string farbe;
float tankvolumen;
int anzahlPassagiere;
public:
void starten();
void tanken();
};
class Landfahrzeuge: public Fahrzeuge // abgeleitete Klasse
{
private:
int Achsenzahl, motorstaerke;
public:
void lichtEinschalten();
void parken();
void fahren();
};
class Luftfahrzeuge: public Fahrzeuge // abgeleitet Klasse
{
private:

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Vererbung Seite 92/166

int anzahlDuesen;
int reichweite, maxFlughoehe;

public:
void landen();
void landeKlappenAusfahren();
};

bung: 3.41-5

Bilden Sie eine neue Klasse von sehenden Robotern auf Basis der Roboterklasse aus
Aufgabe 3.40-5.
Die sehenden Roboter haben smtliche Attribute und Methoden der allgemeinen Roboter
vererbt bekommen und haben noch zustzliche:
1. Attribute:
bool kameraEingeschaltet true, wenn Kamera eingeschaltet ist
bool kameraBereit true, wenn Kamera zur Aufnahme bereit ist
und

2. Methoden:
bool kameraEinschalten() liefert true, wenn Kamera eingeschaltet ist
(Rckmeldung der Kamera an den Roboter
durch ein Signal)
bool bildAufnehmen() liefert true, wenn ein Bild erfolgreich aufgenommen
wurde (Signal der Kamera)
Definieren Sie einen entsprechenden Konstruktor fr die sehenden Roboter.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassen als Datenelemente einer Klasse Seite 93/166

2.25 Klassen als Datenelemente einer Klasse


Es ist nicht unblich, komplexe Klassen aufzubauen, indem man einfachere Klassen dekla-
riert und sie in die Deklaration der komplexeren Klasse einbindet. Beispielsweise kann man
eine Klasse einRad, eine Klasse einMotor, eine Klasse einGetriebe usw. deklarieren und
dann zur Klasse einAuto kombinieren. Damit deklariert man eine Beziehung: Ein Auto hat
einen Motor, es hat Rder, es hat eine Kraftbertragung.
Diese Vorgehensweise soll an dem folgenden Beispiel einer Klasse fr Rechtecke verdeut-
licht werden.
Ein Rechteck setzt sich aus Linien zusammen. Eine Linie ist durch zwei Punkte definiert. Ein
Punkt ist durch eine X- und eine Y-Koordinate festgelegt. Das folgende Listing zeigt eine
vollstndige Deklaration einer Klasse Rectangle , wie sie in RECTANGLE.h stehen knnte.
Da ein Rechteck mit vier Linien definiert ist, die vier Punkte verbinden, und sich jeder Punkt
auf eine Koordinate in einem Diagramm bezieht, wird zuerst die Klasse Point deklariert, um
die X,Y-Koordinaten jedes Punkts aufzunehmen. Das Listing zeigt eine vollstndige Deklara-
tion beider Klassen.
Deklaration einer vollstndigen Klasse

// Beginn von rect.h

#include <iostream.h>

class Point // nimmt X,Y-Koordinaten auf

{// Kein Konstruktor, Standardkonstruktor verwenden

public:
void SetX(int x) { itsX = x; }
void SetY(int y) { itsY = y; }
int GetX()const { return itsX;} //konstanter Zugriff
int GetY()const { return itsY;}
private:
int itsX;
int itsY;
}; // Ende der Klassendeklaration von Point

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassen als Datenelemente einer Klasse Seite 94/166

class Rectangle // Keine Vererbung von Point !!


{
public:
Rectangle (int top, int left, int bottom, int right);
~Rectangle () {} // Destruktor
// Methoden
int GetTop() const { return itsTop; }
int GetLeft() const { return itsLeft; }
int GetBottom() const { return itsBottom; }
int GetRight() const { return itsRight; }
//zurckgegebener Typ ist Point
Point GetUpperLeft() const { return itsUpperLeft; }
Point GetLowerLeft() const { return itsLowerLeft; }
Point GetUpperRight() const { return itsUpperRight; }
Point GetLowerRight() const { return itsLowerRight; }
// bergabetyp = Point-Typ
void SetUpperLeft(Point Location ) {itsUpperLeft = Location;}
void SetLowerLeft(Point Location ) {itsLowerLeft = Location;}
void SetUpperRight(Point Location) {itsUpperRight = Location;}
void SetLowerRight(Point Location) {itsLowerRight = Location;}

void SetTop(int top) { itsTop = top; }


void SetLeft (int left) { itsLeft = left; }
void SetBottom (int bottom) { itsBottom = bottom; }
void SetRight (int right) { itsRight = right; }
int GetArea() const;

private:
Point itsUpperLeft;
Point itsUpperRight;
Point itsLowerLeft;
Point itsLowerRight;
int itsTop;
int itsLeft;
int itsBottom;
int itsRight;

};
// Ende von rect.h

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassen als Datenelemente einer Klasse Seite 95/166

RECT.CPP

// Beginn von rect.cpp

#include "rect.h"

Rectangle::Rectangle(int top, int left, int bottom, int right)

{
itsTop = top;
itsLeft = left;
itsBottom = bottom;
itsRight = right;
itsUpperLeft.SetX(left);
itsUpperLeft.SetY(top);

itsUpperRight.SetX(right);
itsUpperRight.SetY(top);

itsLowerLeft.SetX(left);
itsLowerLeft.SetY(bottom);

itsLowerRight.SetX(right);
itsLowerRight.SetY(bottom);

}
// Rechteckflaeche berechnen. Dazu Ecken bestimmen,
// Breite und Hoehe ermitteln, dann multiplizieren.

int Rectangle::GetArea() const


{
//hier kommt der entsprechende Code zur Rechtecksflchenberech-
nung
}

void main()
{
// Code eingeben
system ("PAUSE");
}

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Klassen als Datenelemente einer Klasse Seite 96/166

bung: 3.42-1

- Ergnzen Sie in der Rectangle-Klasse die Methode Umfangberechnung.


- Erzeugen Sie ein Projekt mit der Klasse Rectangle mit den Eckpunkten (0,0)-( 200,0)-
(0,100)-(200,100).
- Berechnen Sie in einem Hauptprogramm unter Nutzung der Rectangle-Klasse die
Flche und den Umfang des Rechteckes,
- Ersetzen Sie class durch struct in der Klassendeklaration und kompilieren Sie neu.
Welche nderungen ergeben sich?
- Schreiben Sie ein Hauptprogramm, das die Eckpunkte eines Rechteckes ber die Kon-
sole einliest und einem Rechteckobjekt zuweist. Dann sollen Umfang und Flchen-
inhalt des Rechteckes bestimmt werden.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Strings Seite 97/166

2.26 Strings
Microsoft bietet eine ganze Menge vordefinierter Klassen, die z.B. in der MFC (Microsoft
Foundation Class) zusammengefasst sind.

C++ selbst kennt die elementaren Datentypen bool, char, int, long, float, double. Alle anderen
Typen sind daraus abgeleitet als Arrays, structs oder Klassen.

2.26.1 C-Strings
C-Strings sind reine char-Vektoren. Ihnen steht nicht die Funktionalitt der String-Klasse
zur Verfgung.

char name[]="Hugo";

ist quivalent mit

char name[]={'H','u','g','o','\o'}.

Das Zeichen '\o' schliet den C-String ab! Es handelt sich damit um einen Null-terminierten
String.
Das letzte Zeichen, '\0', ist das Null-Zeichen, das viele Funktionen in C++ als Abschluss-
zeichen eines Strings erkennen. Obwohl diese zeichenweise Lsung funktioniert, ist sie um-
stndlich einzugeben und bietet viel Spielraum fr Fehler. C++ erlaubt daher die Verwendung
einer Kurzform fr die obige Codezeile:

char Gruss[] = "Hello World";

Bei dieser Syntax sind zwei Punkte zu beachten:


Statt der in Apostrophe eingeschlossenen, durch Kommata getrennten und von ge-
schweiften Klammern umgebenen Zeichen ist die gesamte Zeichenfolge in Anfh-
rungszeichen zu setzen und ohne Kommata sowie ohne geschweifte Klammern zu
schreiben.
Das Null-Zeichen braucht man nicht hinzuzufgen, da der Compiler dies automatisch
erledigt.

Der String Hello World hat eine Lnge von 12 Byte:


Hello mit 5 Byte, ein Leerzeichen mit 1 Byte, World mit 5 Byte und das abschlieende Null-
Zeichen mit 1 Byte.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Strings Seite 98/166

Wie bei allen Arrays darf man nur so viele Zeichen in den Puffer stellen, wie Platz dafr
reserviert ist.
#include <iostream>
void main()
{
char buffer[80];
cout << "Geben Sie den String ein: ";
cin >> buffer;
cout << "Inhalt des Puffers: " << buffer << endl;
system ("PAUSE");
}

Ausgabe des Programms:

Geben Sie den String ein: Hello World


Inhalt des Puffers: Hello

Das Programm deklariert einen Puffer fr 80 Zeichen. Diese Gre gengt, um eine Zeichen-
folge mit 79 Zeichen und dem abschlieenden Null-Zeichen aufzunehmen.
Dann wird der Anwender zur Eingabe einer Zeichenfolge aufgefordert, die das Programm in
den Puffer bernimmt. cin schreibt nach der eingegebenen Zeichenfolge ein abschlieendes
Null-Zeichen in den Puffer.

Das Programm weist zwei Probleme auf:


1. Wenn der Anwender mehr als 79 Zeichen eingibt, schreibt cin ber das Ende des Puffers
hinaus.

2. Wenn der Anwender ein Leerzeichen eingibt, nimmt cin das Ende des Strings an und
beendet die Eingabe in den Puffer.

Um diese Probleme zu lsen, muss man die cin-Methode get() aufrufen, die drei Parameter
bernimmt:
den zu fllenden Puffer,
die maximale Anzahl der zu bernehmenden Zeichen,
das Begrenzerzeichen, das die Eingabe abschliet.

Der Standardbegrenzer ist newline (Zeichen fr neue Zeile).

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Strings Seite 99/166

#include<iostream>
using namespace std;
void main()
{
char buffer[80];
cout << "Geben Sie den String ein: ";
cin.get(buffer, 79); //Maximal 79 Zeichen oder bis newline
//einlesen
cout << "Inhalt des Puffers: " << buffer << endl;
system ("PAUSE");
};

Ausgabe des Programms:

Geben Sie den String ein: Das ist mein String!


Inhalt des Puffers: Das ist mein String!

Die Methode get() von cin bergibt den deklarierten Puffer als erstes Argument. Das zweite
Argument gibt die maximal zu holenden Zeichen an. In diesem Fall muss dieser Wert gleich
79 sein, um Platz fr das abschlieende Null-Zeichen zu lassen. Auf die Angabe eines Zei-
chens fr das Ende der Eingabe kann man verzichten, da der Standardwert newline unseren
Ansprchen gengt.

2.26.2 strcpy-Funktion
Man kann zwei C-Strings nicht durch Zuweisung gleichsetzen sondern muss dazu dann die im
cstring-Header implementierte Copierfunktion strcpy nutzen:

char str1[20], str2[20]="Ein String";


str1=str2 // Fehler, da es Vektoren
// sind !!
strcpy(str1,str2); // ok!

Weiter Standardfunktionen zur C-Stringmanipulation sind strlen(), strcmp() etc.


Details findet man in der Hilfe.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Strings Seite 100/166

2.26.3 string-Klasse
Eine in vielen Programmen bentigte Klasse ist die String-Klasse.
Die Klasse string ist durch Einbinden des Headers <string> bzw. <cstring> im Programm
verfgbar, wie folgendes Beispiel zeigt.

#include<iostream>
#include<string>
using namespace std;
int main ()
{
string meinVorname, meinNachname;
cout<<"Geben Sie Ihren Vorname ein!"<<endl;
cin>>meinVorname; // Blank ist Terminierungszeichen!!!
cout<<"Geben Sie Ihren Nachname ein!"<<endl;
cin>>meinNachname;
cout<<"Ihr Vorname lautet: "<<meinVorname<<" und Ihr Nachname lau-
tet: "<<meinNachname<<endl;
string neuerString="Sehr geehrter Herr ";
cout<<neuerString<<meinVorname<<" "<<meinNachname;
system ("PAUSE");
}

Von der Header-Datei string wird die string-Klasse eingebunden.

Diese ist von der Header-Datei string.h oder cstring (das C++-Pendant) zu unterscheiden,
die die Basisfunktionen zur Manipulation von C-Strings einbinden.

Die string-Klasse implementiert im Gegensatz zu C-Strings eine ganze Reihe von Methoden,
die im Folgenden an Beispielen auszugsweise gezeigt werden sollen.

Man kann einzelne string's zusammenfassen durch den Additionsoperator:


#include<iostream>
#include<string>
using namespace std;
void main()
{
string str1 = "Der ";
string str2 ="Hoch";
string str3 = "sommer kommt bestimmt bald";
string str=str1+str2+str3;
cout<<str<<endl;
system ("PAUSE");
};

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Strings Seite 101/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Strings Seite 102/166

Auch ein Vergleich ist mglich:

while (Schalter == 'Ja'|| Schalter == 'ja') { }

Der Vergleich liefert einen bool- Typ. Es gilt dabei:

str1 = = str2 true, wenn beide Zeichenfolgen identisch sind. Damit sind auch beide
string-Lngen gleich

str1 < str2 true, wenn das erste unterschiedliche Zeichen von str1 kleiner als das von
str2 ist oder str2 eine Verlngerung von str1 ist.

Weitere string-Methoden sind das

Einfgen str1.insert(pos_str1,str2,pos1_str2,pos2_str2)
Lschen str1.erase(pos1,pos2)
Finden str1.find("xyz")
Ersetzen str1.replace(pos1_str1,pos2_str1,str2,pos1_str2,pos2_str2).

bung: 3.43-1

Implementieren Sie in einem Projekt die folgende String-Manipulation.

- Definieren Sie den String

Julia ist ein schner Mann und wohnt in einem roten Haus

- und verndern ihn mit Hilfe der Standard string-Methoden in

Julia ist eine schne Frau und wohnt in einem blauen Haus.

bung: 3.43-2

Der Funktion wordCount wird ein String als Argument bergeben. Die Funktion lie-
fert die Anzahl der im String enthaltenen Worte zurck.
Worte sind durch Leerzeichen getrennt.
Erstellen sie den Prototypen (Funktionskopf) und schreiben sie die Funktion!

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ I/O-Stream-Klassen Seite 103/166

2.27 I/O-Stream-Klassen
Eine uns schon oft begegnete Klasse ist die I/O-Stream-Klasse, die den Eingabe- und Ausga-
beverkehr mit Rechnerperipherie implementiert. Eingebunden werden diese Methoden der
Klasse I/O-Stream als Teil der C++-Laufzeitbibliothek durch den Header <iostream>.
Die klassischen Vertreter der I/O-Klasse zum Einlesen und Ausgeben auf die Standardkonso-
le sind die Methoden cin und cout:

cout<<"Geben Sie einen Wert fr x ein!"<<endl:


cin>>x;
cout <<"Sie haben den Wert "<<x<<" ausgegeben"
<<endl;

Man kann mit der Methode cout mehrere Strings und Variable gleichzeitig ausgeben. Tren-
nungszeichen ist der Operator <<.
Das Gleiche gilt auch fr die Eingabe

string name;
float wert;
cin>>wert>>name;

Trennungszeichen bei der Eingabe ist das Leerzeichen,


der Tabulator oder einen Zeilenumbruch!

2.27.1 Formatierte Ausgabe mit cout


Die Anzahl der Nachkommastellen wird durch die Methode

cout.precision(anzahlStellen).

Schickt man den Manipulator fixed an die Methode cout, dann beziehen sich die anzahlStel-
len nur auf die Nachkommastellen.

cout<<fixed;

Der Manipulator right oder left stellt die Ausgabe rechts- oder linksbndig dar.

cout<<right;
cout>>left;

Dabei kann die Breite der Darstellung fr ein auszugebendes Zeichen durch die Methode

width(gesamtAnzahlStellen).

Width gilt dabei immer nur fr die unmittelbar folgende Ausgabe und wird danach auf den
auszugebenden Inhalt automatisch angepasst.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ I/O-Stream-Klassen Seite 104/166

Leerzeichen werden standardmig durch Blanks augefllt, was sich aber durch die Methode
cout.fill(.);

z.B. in einen Punkt umwandeln lsst.

2.27.2 Nationale Sonderzeichen


In der Regel wird bei einer Ausgabe von Strings der Standard-ASCII-Datensatz verwendet.
Sonderzeichen wie , , und werden dabei nicht bercksichtigt. Sie mssen durch eine
sog. Lokalisierung explizite angesprochen werden.

Die Klasse locale kapselt nationalspezifische Sonderzeichen und Vereinbarungen, wie z.B.
die Darstellung von Uhrzeiten, Datum und Whrungen bzw. Zahlen. Die Klasse ist in der
namespace std enthalten und muss nicht extra in einem Header eingebunden werden.

Das folgende Programmbeispiel zeigt die Vorgehensweise:

#include <iostream>
#include<string>
void main( )
{
using namespace std;
setlocale (LC_ALL, "german");
string text;
cout<<""<<endl;
cin>>text;
cout<<text<<endl;
system ("PAUSE");
}
Durch die Angabe des Parameters LC_ALL im Aufruf setlocale werden alle nationalspezi-
fischen Besonderheiten auf Deutsch (german) gesetzt.
Man erkennt, dass die Eingabe von Umlauten aber nicht ermglicht ist

bung: 3.44-1

Erstellen Sie ein Projekt, dass eingelesen Temperaturwerte in C in Fahrenheit um-


rechnet. Dabei sollen die Fahrenheitwerte immer nur mit einer Nachkommastelle
rechtsbndig in Feldern zu 7 Zeichen ausgegeben werden.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ I/O-Stream-Klassen Seite 105/166

2.27.3 Umwandlung von Zahlen und Strings


Wenn die oben beschriebenen Formatierungsmglichkeiten noch nicht ausreichen, so muss
man auf die im Sprachumfang von C schon implementierten Funktionen prinf und scanf
ausweichen.
Sie sind in der Headerdatei <cstdio> deklariert.
Mit Hilfe dieser Funktionen knnen nun auch Zahlen in Strings gewandelt werden, wie fol-
gendes Beispiel demonstriert:

float zeitSpanne;
cout<<"Geben Sie die Zeitspanne ein: ";
cin>>zeitSpanne;
char zeit[40]; // gengend groes Zeichenfeld
sprintf(zeit,"%f",zeitSpanne);
string zeitString=zeit;
cout<<zeitString<<endl;

Zur Umwandlung von Zahlen in Strings nutzt man die Funktion sprintf(), die genauso
aufgerufen wird wie printf() aber im Unterschied dazu den String nicht auf der Konsole
ausgibt sondern in die im Argument bergebene Variable (hier zeitSpanne).
Die Platzhalter in der printf()- / sprintf()-Funktion ergeben sich aus dem Typ der Vari-
able:

%c einzelnes Zeichen
%d Integerzahl
%f Floatzahl
%e Exponentialzahl und
%s String.

Einfacher zu verwenden sind die Funktionen strtol() und strtod(), die einen String in
eine Long-Integer oder Double-Float-Zahl wandelt:

#include<iostream>
#include<string>
using namespace std;

void main()
{
char *string, *stopstring;
double x;
long l;
int base;
unsigned long ul;
string = "3.1415926This stopped it";
x = strtod( string, &stopstring );
printf( "string = %s\n", string );

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ I/O-Stream-Klassen Seite 106/166

printf(" strtod = %f\n", x );


printf(" Stopped scan at: %s\n\n", stopstring );
string = "-10110134932This stopped it";
l = strtol( string, &stopstring, 10 );
printf( "string = %s\n", string );
printf(" strtol = %ld\n", l );
printf(" Stopped scan at: %s\n\n", stopstring );
string = "10110134932";
printf( "string = %s\n", string );
/* Convert string using base 2, 4, and 8: */
for( base = 2; base <= 8; base *= 2 )
{
/* Convert the string: */
ul = strtoul( string, &stopstring, base );
printf( " strtol = %ld (base %d)\n", ul, base );
printf( " Stopped scan at: %s\n", stopstring );
}
system ("PAUSE");
}

Die Umwandlung von Strings in Integer oder Double ist genauso einfach:

#include<iostream>

#include<string>

using namespace std;

void main()

string str = "123";

int intZahl;

intZahl=atoi(str.c_str()); // alphanumeric to integer

cout<<"intZahl= "<<intZahl<<endl;

str="123.456";

double doubleZahl;

doubleZahl=atof(str.c_str()); // alphanumeric to float

cout<<"doubleZahl= "<<doubleZahl<<endl;

system ("PAUSE");

Die Funktionen arbeiten mit C-Strings, die man durch Anwendung der Methode c_str() auf
einen String aus der String-Klasse transformieren kann.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ I/O-Stream-Klassen Seite 107/166

bung: 3.44-2

Erstellen Sie ein Programm, das von der Konsole Werte und Strings einliest, diese jeweils in
Strings und Werte umwandelt und sie wieder an der Konsole ausgibt.

2.27.4 I/O-Verkehr mit Dateien


Jeder E/A-Verkehr mit den unterschiedlichsten Gerten an einem Rechner basiert in C++ auf
der Basis von Streams.
Je nachdem wie Daten in einer Datei gespeichert werden unterscheidet man zwischen Text-
und Binrdateien.
Erstere enthalten ganz normalen ASCII-Text, den man mit jedem Texteditor betrachten und
bearbeiten kann.
Binre Dateien enthalten allerdings nur binr codiert Informationen, die nur durch den ent-
sprechenden Editor gelesen und fr den Nutzer zugnglich gemacht werden knnen.

Im Folgenden werden die Befehle zum E/A_Verkehr mit Textdateien behandelt. Die Erweite-
rung zum binren Datenverkehr kann leicht anhand der Hilfen im Visual-Studio nachvollzo-
gen werden.
Um die Funktionalitt der Datei-Stream-Klassen zugnglich zu machen, muss man den
Header <fstream> (file stream) einbinden.
Zur Erzeugung einer Ausgabe in eine Datei muss man eine Instanz der Klasse ofstream (out
file stream) erzeugen

ofstream daten_Ausgabe;

Soll die Datei nun geffnet werden, so nutzt man die Methode open der ofstream-Klasse

daten_Ausgabe.open(dateiName.c_str(),ios_base::out).

Der open-Methode wird der Dateiname als String bergeben, der mit der Methode c_str() in
einen C-String ( ein char-Array) umgewandelt werden muss.

Die weitere Parameter ios_base::out steuert den E/A-Modus - hier ffnen der Datei. Wenn
die Datei bereits existiert wird sie berschrieben, wenn sie noch nicht existiert, dann wird sie
neu angelegt.

Durch Kombination des Steuerparameters

ios_base::out | ios_base::app

erreicht man, dass der Ausgabetext an eine bestehende Datei angehngt wird. Besteht die
Datei noch nicht, so wird sie ebenfalls neu angelegt.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ I/O-Stream-Klassen Seite 108/166

Im Fehlerfall, wenn open() scheitert, erhlt daten_Ausgabe danach einen Nullwert. Man
kann das Stream-Objekt abfragen durch (!daten_Ausgabe ist dann true) und gegebenenfalls
eine Fehlermeldung ausgeben.
Das folgende Programm ffnet eine Datei und gibt Datenstrings in eine Datei aus.

#include <iostream>
#include <fstream>
#include <string>
#include <cstdio>
using namespace std;

int main()
{
ofstream dat_aus;
string dateiname;

cout << "Geben Sie den Namen der Datei ein: ";
cin >> dateiname;
cout << endl;

dat_aus.open(dateiname.c_str(), ios_base::out);

if(!dat_aus)
{
cout << "Datei konnte nicht geoeffnet werden!";
cout << endl; system ("PAUSE");
return -1;
}

// Verschiedene Daten zum Testen in die Datei


// schreiben
string text1 = "Dies ist ein Text";
int var1 = 1000;
string text2 = "Dies ist ein weiterer Text";
double var2 = 555.111;

dat_aus << text1 << endl;


dat_aus << var1 << endl;
dat_aus << text2 << endl;
dat_aus << var2 << endl;

dat_aus.close();
fflush(stdin);

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ I/O-Stream-Klassen Seite 109/166

getchar();system ("PAUSE");
return 0;
}
Im Folgenden wird nun die Datei wieder geffnet und die Daten eingelesen.
Hierzu wird eine Instanz eines Stream-Objekts mit dem Namen dat_ein erzeugt

ifstream dat_ein .

Durch die Befehlsfolge

dat_ein.open(dateiname.c_str(), ios_base::in);

wird der Stream mit der Datei dateiname verbunden und diese zum Lesen geffnet.

Das folgende Programm zeigt eine Implementierung zum ffnen einer Datei, die zuvor be-
schrieben wurde (s.o.), und dann jedes einzelne Zeichen ausliest bis das eof (end of file)
erreicht ist.

#include <iostream>
#include <fstream>
#include <string>
#include <cstdio>
using namespace std;
int main()
{
ifstream dat_ein;
string dateiname;
cout << "Geben Sie den Namen der Datei ein: ";
cin >> dateiname;
cout << endl;

dat_ein.open(dateiname.c_str(), ios_base::in);

if(!dat_ein)
{
cout << "Datei konnte nicht geoeffnet werden!";
cout << endl; system ("PAUSE");
return -1;
}
char zeichen;
while (!dat_ein.eof())
{
dat_ein.get(zeichen);
cout << zeichen;
}

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ I/O-Stream-Klassen Seite 110/166

dat_ein.close();
fflush(stdin);
getchar();system ("PAUSE");
return 0; }

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ I/O-Stream-Klassen Seite 111/166

bung: 3.44-3

- Erstellen Sie ein Projekt, dass die obigen Programmteile implementiert, und probie-
ren Sie den E/A-Verkehr mit einer eigenen Datei aus.

- Versuchen Sie anschlieend durch ein Textverarbeitungsprogramm die geschriebene


Datei zu ffnen und zu lesen.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ I/O-Stream-Klassen Seite 112/166

3 Computeralgebra mit MATLAB


MATLAB ist ein modernes und sich in der Industrie zunehmend etablierendes Computeralge-
bara-System.

Die Computeralgebra-Systeme sind aufgrund der Fortschritte in der Rechen- und Software-
technik heute benutzerfreundlich und sehr einfach zu bedienen. Dadurch werden Berechnun-
gen, die noch vor Jahren zeitraubend und schwierig waren, den Ingenieuren in Forschung und
Entwicklung schnell und anschaulich zugnglich.
In diesem Zusammenhang spielt die Anschaulichkeit eine groe Rolle, da dadurch die fr den
Ingenieur technische relevanten Zusammenhnge und Plausibilitten markant darstellbar
werden.
MATLAB erreicht diese Mglichkeiten durch vielfltige Plot-Funktionen, mit deren Hilfe die
mathematischen Ergebnisse graphisch veranschaulicht werden knnen.

MATLAB ist in erster Linie eine numerisch rechnendes Computeralgebra-System. Das


bedeutet, dass die in der Aufgabenstellung definierten Algorithmen in einer Session mit kon-
kreten Werten durchgerechnet werden, das Endergebnis ist numerisch, es besitzt einen kon-
kreten Wert oder Wertevektor.

Durch viele in MATLAB integrierte sogenannte Toolboxen wird jedoch immer mehr Funkti-
onalitt in MATLAB realisiert so unter anderem auch die Mglichkeit des symbolischen
Rechnens. Sie basiert auf Mapel, einem anderen rein symbolisch rechnenden Computeralgeb-
ra-System.

Die funktionale Vielfalt, die in MATLAB integriert ist, wird durch ein sehr bersichtliches
und mit vielen Beispielen unterlegtes Hilfesystem untersttzt. Man kann sich hier ber ganze
Toolboxen und ihren Funktionen eine berblick verschaffen, wie auch konkret nach der
Syntax eines einzelnen Befehles suchen. Umfangreiche Beispiele verdeutlichen die Zusam-
menhnge.
Die Hilfe sowie das gesamte Programm haben eine Englischsprachige Oberflche.

Der Name MATLAB rhrt von MATrix LABoratory her und gibt einen Hinweis auf die
Matrix-Datenstruktur, die MATLAB unterlagert ist. Alle Werte und Variablen sind in
MATLAB als Matrix vereinbart. Hierdurch ergeben sich komfortable Mglichkeiten der
Behandlungen von ganzen Zahlenreihen z.B. Messwertreihen, die dann mit MATLAB wei-
terverarbeitet werden knnen. Eine einzelne Zahl hingegen lsst sich als 1x1-Matrix darstel-
len und behandeln.
Ab MATLAB Version 6 sind auch komplexere Datenstrukturen wie STRUCT (C/C++) mg-
lich, wodurch sich MATLAB allmhlich zu einer eigenen Hochsprache hin entwickelt, zumal
im Programmiermode else-if-Abfragen u.. mglich sind.

In den folgenden Kapitel werden nun die Grundbegriffe von MATLAB vorgestellt und an
Beispielen vertieft.

In einem abschlieenden Teil wird Simulink eine Toolbox von MATLAB vorgestellt, mit
dessen Hilfe technische, dynamische Systeme simuliert werden knnen. Die kurze Einfhrung
wird wieder mit Hilfe einfacher Beispiele vertieft.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Benutzeroberflche von MATLAB Seite 113/166

3.1 Benutzeroberflche von MATLAB


Bild 4.1 zeigt die Menoberflche von MATLAB nach Programmstart

Bild 4.1 : Erffnungsmen von MATLAB

Man erkennt 3 Abschnitte die Command History, in dem alle Befehle gespeichert werden
und spter durch Doppelklick wieder aktiviert werden knnen, dem Workspace, in dem alle
aktuellen Variablen aufgelistet werden, und die durch Doppelklick in einem separaten Fenster
mit ihren aktuellen Werten dargestellt werden knnen und schlielich dem Command
Window, in das nach dem Doppelpfeil-Prompt die jeweiligen MATLAB- Befehle eingetippt
werden.
Oberhalb des Command Windows kann man ber die Registerkarte Current Directory den
Workspace ausblenden und dafr die aktuellen Verzeichnispfade, die MATLAB benutzen
soll, einblenden und gegebenenfalls hinzufgen oder abndern.
ber das Men Help gelangt man zur MATLAB-Hilfe, die im Bild 4.2 gezeigt wird und eine
umfangreiche Auswahl von Hilfs- und Suchmglichkeiten ffnet.

Bild 4.2 :
MATLAB-
Hilfsfunktionen

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Benutzeroberflche von MATLAB Seite 114/166

Die rechte Hlfte des Bildschirms gibt den Hilfeinhalt wieder, whrend in der linken Hlfte
die einzelnen Themen ausgewhlt bzw. nach einzelnen Begriffen gesucht werden kann.

Um beispielsweise die oben erwhnten Programmsyntaxelemente nher kennen zu lernen,


kann man unter der Registerkarte SEARCH nach den Funktionen (functions) suchen und man
erhlt eine Liste von programming constructs, mit weiteren Links zu den einzelnen Elemen-
ten (Bild 4.3).

Bild 4.3 : Hilfsdokumemtation fr functions

Will man sich ber Syntax und Anwendung der Sinusfunktion orientieren, so muss man sin
eingeben und erhlt eine Antwort, wie sie in Bild 4.4 dargestellt ist.

Bild 4.4 :
Hilfsdokumentation fr
die Sinus-Funktion

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Benutzeroberflche von MATLAB Seite 115/166

Das Help-Beispiel zeigt ber die Erluterung der Sinus-Funktion hinaus - durch ein Beispiel
verdeutlicht - die Sinus-Anwendung auch auf komplexe Zahlen. MATLAB rechnet also auch
mit beliebig komplexen Zahlen.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 116/166

3.2 Elementare MATLAB-Operationen


Der elementare Funktionsumfang von MATLAB umfasst in etwa fnf Kategorien:
(1) Arithmetische Operationen
(2) Logische Operationen
(3) Mathematische Funktionen
(4) I/O-Funktionen zum Datenaustausch
(5) Grafikfunktionen.

Daneben gibt es einige Funktionen und Kommandos, die die Arbeit mit MATLAB steuern
und anpassen.

3.2.1 Variablendefinitionen
Zur Ausfhrung von Operationen sind Variablen ntig, die wie schon weiter oben erwhnt als
Matrizen in MATLAB gespeichert werden. Die Definition einer Variablen geschieht durch
Eingabe der folgenden Syntax im Command Window:
a= 2.8e-3
X= 0.3
oder bei Vektoren
Vektor1=[1 2 3]
Vektor2=[1;2;3].
Matrizen lassen sich analog erzeugen:
Matrix1=[1.2 2.4+i ; 3.6i 6.7].
Im Anschluss an die Eingabe antwortet MATLAB mit der besttigenden Wiedergabe der defi-
nierten Variablenwerte:
Matrix1 =

1.2000 2.4000 + 1.0000i


0 + 3.6000i 6.7000

Mit dem Kommando whos kann


man sich nun einen berblick ber
die definierten Variablen verschaf-
fen, die zustzlich wenn ange-
zeigt im Workspace zugnglich
sind
(Bild 4.5).

Bild 4.5 :
Workspace und
Command Window
nach Variablendefini-
tion

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 117/166

Ein Doppelklick auf das Matri-


xelement ffnet einen Array-
Editor, in dem einzelne Elemente
der Matrix verndert werden knn-
ten.

Unterbleibt eine Eingabe eines


Variablennamen, so speichert
MATLAB die Eingabe unter dem
Namen ans (answer).

Die linke Spalte der Bedienober-


flche enthlt alle bis jetzt einge-
gebenen Befehle. Diese lassen sich
durch die Pfeiltasten () zurck-
holen oder aber durch Doppelklick
mit dem Mauszeiger auf den ent-
sprechenden Befehl in der Com-
mand History.
Bild 4.6 : Array-Editor

3.2.2 Matrixoperationen
Die Definition von Variablen kann auch aus der Zusammensetzung einzelner Variablen ge-
schehen:
NeueMatrix=[Matrix1,Matrix1],
oder durch
Mat=[1,2,3;3,4,5]
Vek=[11 22]
MatNeu =[Mat,Vek] .

Man beachte das Transpositionszeichen ( ), das aus dem Zeilenvektor einen Spaltenvektor
macht, der als 3. Spalte an die Matrix Mat angefgt werden kann.
MatNeu =
1 2 3 11
3 4 5 22.
Aus dieser neuen Matrix kann man nun mit dem Kommando
MatNeu(:,2)=[]
die 2. Spalte durch eine leere Spalte ersetzen, d.h. lschen.

MatNeu =
1 3 11
3 5 22 .

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 118/166

Die Dimensionen einer Matrix bekommt ber das Kommando


M=
1 2 3 4
5 6 7 8
9 10 11 12
>> size(M)
ans =
3 4
oder
>> [M1,M2]=size(M)
M1 =
3
M2 =
4
Die Determinante einer Matrix kann man ebenfalls durch ein einfaches Kommando berech-
nen:
>> D=det(M)
??? Error using ==> det
Matrix must be square.

Natrlich kann man eine Determinante nur bei quadratischen Matrizen berechnen:
>> M1[1 3 2;5 4 7;8 6 9];
??? M1[1 3 2;5 4 7;8 6 9];
|
Error: Unbalanced or misused parentheses or brackets.

>> M1=[1 3 2;5 4 7;8 6 9];


>> D=det(M1)
D=
23
Ist die Determinante einer Matrix Null, so spricht man von einer singulren Matrix, andern-
falls handelt es sich um einen nicht singulre Matrix, von der man dann auch eine Inverse
bilden kann

Bei sehr groen Matrizen kann es vorkommen, das die Zeilenbreite zur Eingabe nicht aus-
reicht. Durch Eingabe dreier Punkte (...) kann man die Eingabe in der nchsten Command-
Zeile fortsetzen.
>> MatMat=[1 2 3 4 5 6 7 1 2 3 4 5 6 7 8 9 ...
11 22 33 44 55 66 77 ]
MatMat =
1 2 3 4 5 6 7 1 2 3 4 5 6 7 8 9 11 22 33 44 55 66
77 .

Es gibt weitere Mglichkeiten Variablen vereinfacht zu definieren:


>> MatNull=zeros(3,4)

MatNull =
0 0 0 0
0 0 0 0
0 0 0 0

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 119/166

>> MatEins=ones(4,4)
MatEins =

1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1.

Vektoren und Matrizen kann man auch automatisch durch eine Rechenvorschrift fllen:
>> Vektor=[0:0.5:10]

Vektor =
0 0.5000 1.0000 1.5000 2.0000 2.5000 3.0000 3.5000 4.0000 4.5000 5.0000
5.5000 6.0000 6.5000 7.0000 7.5000 8.0000 8.5000 9.0000 9.5000 10.0000 .

Man kann auch aus einer greren eine kleinere Matrix bilden, indem man von der greren
nur bestimmte Zeilen oder Spalten in die neu zu bildende Matrix bernimmt:
>> M=[1 2 3 4 5;6 7 8 9 10; ...
11 12 13 14 15;16 17 18 19 20 ...
]
M=
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
>> M1=M([1:2 4],[1:2 4:5])
M1 =
1 2 4 5
6 7 9 10
16 17 19 20

bung: 4.2-1

Gegeben ist die Matrix M

1.2 2.3 4i 17.9 4 / 4.988



5.3 9.6 18i 23.2 19.7
221 46 80 99.6

22 / 7 81 3
78.3 36 .3

- Definieren Sie die Matrix in MATLAB, eliminieren Sie die 4. Spalte und substituieren
Sie die 3 Zeile mit einem 1er Vektor.

Beachten Sie dabei, dass das Exponentenzeichen durch ^ gegeben ist.

- Was kann man mit der Eingabe eye erreichen

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 120/166

3.2.3 Matrixarithmetik
Matrizen knnen miteinander multipliziert, addiert oder voneinander subtrahiert werden.
>> Mat1=[1 2 3; 4 5 6]

Mat1 =
1 2 3
4 5 6
>> Mat2=[1 2 ; 3 4 ; 5 6]

Mat2 =
1 2
3 4
5 6

>> MatMul=Mat1*Mat2
MatMul =

22 28
49 64 .
Bei der Multiplikation solcher Matrizen mssen die entsprechende Spalten- und Zeilenzahlen
bereinstimmen:
>> Mat3=[3 3;4 4]

Mat3 =
3 3
4 4

>> MatMul1=Mat3*Mat1

MatMul1 =
15 21 27
20 28 36

>> MatMul1=Mat1*Mat3
??? Error using ==> *
Inner matrix dimensions must agree.

Mit MATLAB lassen sich jedoch auch einzelne arithmetische Operationen auf Komponen-
tenebene durchfhren, hierzu wird ein Dezimalpunkt angefgt:
>> Mat4=[2 2;4 4]

Mat4 =
2 2
4 4
>> MatMul=Mat3. * Mat4
??? MatMul=Mat3. * Mat4
|
Error: "identifier" expected, "*" found.

>> MatMul=Mat3.*Mat4
MatMul =

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 121/166

6 6
16 16 .
Man erkennt an diesem Beispiel auch schn, dass MATLAB nicht formatfrei arbeitet.
Blanks sind normalerweise nicht signifikant, hier trennt der Blank aber den Operator .*
fr die elementweise Multiplikation.

Mit der komponentenweisen Multiplikation lsst sich auch das folgende Produkt
Mat1.*Mat2 bilden:

>> Mat1=[1 2 3; 4 5 6]
Mat1 =
1 2 3
4 5 6
>> Mat2=[2 3 4; 4 5 6]
Mat2 =
2 3 4
4 5 6

>> MatMul = Mat1.*Mat2


MatMul =
2 6 12
16 25 36 .

Entsprechend der elementweisen Multiplikation gibt es auch eine komponentenweise Additi-


on, Subtraktion oder Division von Matrizen.

Eine normale Matrixmultiplikation zwischen den Matrizen Mat1 und Mat2 ist nicht definiert:
>> MatMul = Mat1*Mat2
??? Error using ==> *
Inner matrix dimensions must agree.
Die Division wird bei MATLAB zwischen rechter und linker Division unterschieden.
Wir definieren zunchst die Matrizen A und B :
>> A=[1 2;2 2]

A=
1 2
2 2
>> B=[1 -1 ; 2 -4]

B=
1 -1
2 -4
und deren inverse Matrizen durch die mathematische Funktion inv (informieren sich ber
diese Funktion durch die MATLAB-Hilfe) soweit die Matrizen regulr sind:
>> Ainv=inv(A)
Ainv =
-1.0000 1.0000
1.0000 -0.5000

>> Binv=inv(B)
Binv =
2.0000 -0.5000

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 122/166

1.0000 -0.5000

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 123/166

Die unterschiedliche Wirkung der rechten und linken Division (/ und \) zeigt folgendes
Beispielrechnung:
>> X=A/B
X=

4.0000 -1.5000
6.0000 -2.0000
>> X=A*Binv
X=

4.0000 -1.5000
6.0000 -2.0000
>> X=A\B
X=

1 -3
0 1
>> X=Ainv*B
X=

1 -3
0 1

bung: 4.2-2

Gegeben sind die Matrizen A und B


A= B=

1 2 3 1.0000 0 1.0000
3 4 5 - 2.5000 2.0000 -4.5000
5 6 7 1.0000 2.0000 1.0000

- Berechnen Sie das Produkt der beiden Matrizen A und B.

- Bilden Sie aus dem Produkt eine neue Matrix D, die nur aus den Diagonalelementen
der Produktmatrix besteht

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 124/166

3.2.4 Vektorarithmetik

3.2.4.1 Vektornorm

Jeder Vektor hat eine Lnge, die definiert ist durch Gl 4.1

x [ x1 xn ]
(4-1)
x x12 xn 2

und stellt die sog. Norm des Vektors dar. MATLAB berechnet die Norm wie folgt:
>> a=[1 2 3]
a=
1 2 3
>> b=[2 4 6]
b=
2 4 6
>> x=norm(a)
x=
3.7417
>> y=norm(b)
y=
7.4833
>> c=a-b
c=
-1 -2 -3
>> z=norm(c)
z=
3.7417
Anhand der Aufgabenstellung aus Bild 4-7 (s. /14/) soll das Arbeiten und Rechnen mit Vekto-
ren demonstriert werden.

3 s3
B
2

1
A s2
0
z 4
s1
F3
3 4
D 2
2
0 F1
1 F2
-2
G= mg x
0 -4
y

Bild 4-7 : Berechnung von Reaktionskrften

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 125/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 126/166

Bild 4-7 zeigt eine Trgerkonstruktion aus drei an einer Wand gelenkig gelagerten Stben s1,
s2, s3 , an denen

eine Masse

m mit der Gewichtskraft von 100 N hngt. Es sollen die Reakti-
onskrfte f 1 , f 2 und f 3 sowie die Betrge der Reaktionskrfte F1, F2 und F3 in den Stben
berechnet werden.
Aus dem Krftegleichgewicht kann man schreiben:

f1 f2 f3g 0
0 0
. (4-2)
mit g 0 0

G 100

Die Krfte F1, F2 und F3 sind Druckkrfte und wirken in Trgerrichtung. Man kann die Kraft-

vektoren f 1 , f 2 und f 3 demzufolge proportional zu den Trgervektoren si ansetzen:

3

s1 1 f 1 1 AD 1 4
0
3

s 2 2 f 2 2 BD 2 4 . (4-3)
0
0

s 3 3 f 3 3 DC 3 4
3

Gl. (4-3) eingesetzt in Gl. (4-2) liefert dann ein Gleichungssystem fr die unbekannten i :

3 3 0 1
1
S s1 s2 s 3 2 4 4 4 2 g . (4-4)
3 0 0 3 3

In MATLAB lsst sich diese Gleichungssystem mit Vektorarithmetik lsen:

>> g=[0 0 ,-100]';


>> s1=[-3 4 0]';s2=[3 4 0]';s3=[0 4 3]';
>> S=[s1 s2 s3] >> Alpha=inv(S)*(-g)
S= Alpha =
-3 3 0 -16.6667
4 4 4 oder -16.6667
0 0 3 33.3333
>> Alpha=S^(-1)*(-g) >> Alpha=S\(-g)
Alpha = Alpha =
-16.6667 -16.6667
-16.6667 -16.6667
33.3333 33.3333

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 127/166

>> f1=Alpha(1)*S(:,1)

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 128/166

f1 =
50.0000
- 66.6667
0
>> f2=Alpha(2)*S(:,2)
f2 =
-50.0000
-66.6667
0
>> f3=Alpha(3)*S(:,3)
f3 =
0
133.3333
100.0000
>> F1=norm(f1)
F1 =
83.3333
>> F2=norm(f2)
F2 =
83.3333
>> F3=norm(f3)
F3 =
166.6667

D.h. die Reaktionskrfte in den Stben aufgrund des angehngten Gewichts betragen:
F1 = 83,33 N, F2 = 83,33 N und F3 = 166,67 N .

bung: 4.2-3
Wie gro sind die Reaktionskrfte, wenn ein Gewicht von 90 N an den Stben hngt?
Berechnen Sie diese Krfte mit der Vektorarithmetik von Matlab.

3.2.4.2 Skalarprodukt von Vektoren

Das Skalarprodukt zweier Vektoren ist wie folgt definiert:


n
a b a b cos( (a, b) ai bi
i 1

a1 b1 . (4-5)
mit und

an bn

Der dazugehrige MATLA-Befehl heit dot. Z.B. dot(v1,v2)!

Der Winkel zwischen den beiden Vektoren ergibt sich zu:

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 129/166


a b
cos( ( a, b) . (4-6)
ab

>> a=[1 2 3];b=[3 6 9];


>> norm(a)
ans =
3.7417
>> norm(b)
ans =
11.2250
>> phi=acos(dot(a,b)/norm(a)/norm(b))
phi =
0 Vektoren sind gleichgerichtet haben aber unterschiedliche Norm
>> b=[4 -7 10];
>> phi=acos(dot(a,b)/norm(a)/norm(b))
phi =
1.1416
>> Phi=phi*180/pi
Phi =
65.4098

3.2.4.3 Vektorprodukt

Das Vektorprodukt zweier Vektoren a und b ergibt sich zu

c a b
. (4-7)
c a b a b sin( ( a , b))

Der dazugehrige MATLA-Befehl heit c=cross(a,b).


Es bildet einen neuen Vektor, der senkrecht auf der von a und b aufgespannten Ebene steht.
Alle drei Vektoren bilden ein Rechtssystem.

bung: 4.2-4

- Berechnen Sie mit Hilfe des Vektorproduktes den Momentenvektor m aus Bild 4-8.
- Wie gro ist das Moment, wenn man fr die Kraft F= 50 N annimmt?

P2
24
18 f
z-Achse

12
Kraft
6
0 m= fxr
5 P1
r resultierendes
4 Drehmoment 3
3 Hebelarm P0 2
1
y-Achse 2 0
1 C++-1Programming
-2
x-Achse Bild 4-8 :
Prof. Dr.-Ing. Hans-Werner Dorschner
0 -3 Drehmomentberechnung
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 130/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 131/166

3.2.5 Polynome

3.2.5.1 Polynomdefinition

Polynome haben die allgemeine Form:


n
P( x ) ai x i . (4-8)
i 0

Diese Polynome knnen im Command Window von Matlab direkt eingegeben werden:
>> p=[2 4 8]
p=
2 4 8
>> np=length(p)
np =
3
Der Grad des Polynoms ist dann length(p) - 1
>> x=[1 2 3]
x=
1 2 3
>> y=[2 3 4]
y=
2 3 4

3.2.5.2 Polynomprodukt und Wurzeln

Man kann zwei Polynome auch multiplizieren (Polynomprodukt) und die Wurzel des Poly-
nomproduktes berechnen:
>> z=conv(x,y)
z=
2 7 16 17 12
>> w=roots(z)
w=
-1.0000 + 1.4142i
-1.0000 - 1.4142i
-0.7500 + 1.1990i
-0.7500 - 1.1990i

Das Produkt der beiden Polynome 2 Grades ergibt ein Polynom 4. Grades mit 2 konjugiert
komplexen Wurzeln.
Komplexe Wurzeln kommen nur als konjugiert komplexes Paar vor, wenn die Koeffizienten
des Polynoms reelwertig sind.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 132/166

bung: 4.2-5
- Berechnen Sie die Wurzel des Produktpolynoms

f12 (x) f1 (x) f 2 (x) mit


-
f1 (x) 3x 2 5, f 2 (x) 11x 4 8x 3 22

3.2.5.3 Polynomdivision

Die Quotient aus zwei Polynomen kann man darstellen als:


m
Z ( x) i0 ai xi
r ( x)
q ( x) n c . (4-9)
N ( x) N ( x)
i i
b y
i0

c ist eine Konstante und r(x) gibt den Rest der Division an. r(x) wird Null, wenn gilt
Z ( x) c N ( x) .
In MATLAB kann man solche Polynomdivisionen sehr schnell und einfach berechnen:
1

a
j 0
j xj
x2 2x 3 0.5 x 1
z ( x) 0.5 2
2
2 x 3x 4
2
2 x 3x 4
b x
i 0
i
i

>> x=[1 2 3]
x=
1 2 3
>> y=[2 3 4]
y=
2 3 4

>> [c,r]=deconv(x,y)
c=
0.5000
r=
0 0.5000 1.0000

Da beide Polynome von gleichem Grade sind ergibt sich ein c 0 . Mit anderen Werten erhlt
man z.B.
>> x=[1 2]
x=
1 2
>> [c,r]=deconv(x,y)
c=
0
r=
1 2

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 133/166

Da x ein Polynom 1. und y ein Polynom 2. Grades ist, ergibt sich c zu 0 und man erhlt nur
1

a x i i
x2
den Rest z ( x) i 0
mit r ( x ) x 2
2
2 x 3x 4
2

b y
i 0
i i

Kommen einige Exponenten im Polynom nicht vor, so muss man den Wert 0 fr den entspre-
chenden Koeffizienten eingeben. Das gilt auch fr a0 0 .
Umgekehrt kann man aus den Nullstellen eines Polynoms auch die Koeffizientendarstellung
berechnen:
Im Falle einfacher Nullstellen noi und Pole poi kann man schreiben:
m m

a x i
i
xn oi
i 0
n
i 0
n
. (4-10)
bi xi
i 0
x p
i 0
oi

MATLAB berechnet diese Koeffizienten durch:

>> NP1=[1 2 3]
NP1 =
1 2 3
>> NP2=[-7 -5]
NP2 =
-7 -5
>> P1=poly(NP1)
P1 =
1 -6 11 -6
P1 ( x 1)( x 2)( x 3)

>> NNP1=roots(P1) x 3 6 x 2 11x 6


NNP1 =
3.0000
2.0000
1.0000
>> P2=poly(NP2)
P2 =
1 12 35 P1 ( x 7)( x 5)
>> NNP2=roots(P2)
NNP2 = x 2 12 x 35
-7
-5
m
>> [P,r]=deconv(P1,P2) a x i
i
x 3 6 x 2 11x 6
P= P( x) i 0

n
x 2 12 x 35
r=
1 -18
b x
i 0
i
i

0 0 192 624 192 x 624


x 18
x 2 12 x 35

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 134/166

bung: 4.2-6

- Bestimmen Sie die Nullstellen der Polynome f1 und f2.


f ( x)
- Berechnen Sie den Polynomquotienten y ( x ) 1 mit
f2 ( x)

f1 ( x) ( x 1) ( x 2) ( x 3) ( x 4) und
f 2 ( x) ( x 1) ( x 2) ( x 3) ( x 4)

3.2.6 Mathematische Funktionen


In der MATLAB-Hilfe kann man
ber die Registerkarte Content
schnell die richtige Stelle finden
(s. Bild 4.9).
In verschiedenen Toolboxen sind
spezielle mathematische Funktio-
nen hinterlegt.
Die elementaren Funktionen wie
Sinus-, Kosinus- und Exponential-
funktion werden dann fr die
Matrixelemente komponentenwei-
sen ausgewertet.

Hierzu dient folgendes Beispiel:

Bild 4.9 : Fenster der MATLAB-Hilfe


>> t=[0:.25:2]*pi
t=
0 0.7854 1.5708 2.3562 3.1416 3.9270 4.7124 5.4978 6.2832
>> Vektor=sin(t)
Vektor =
0 0.7071 1.0000 0.7071 0.0000 -0.7071 -1.0000 -0.7071 -0.0000

Gegeben sind verschiedene gemessene Punkte in einem Koordinatensystem durch die


Matrix Punkte:
Punkte =
1.0000 2.5000
3.3000 5.0000
16.0000 0
8.0000 2.1000
29.0000 16.0000 .
Mit Hilfe der elementaren mathematischen Operationen sollen diese kartesischen Koordinaten
in Polarkoordinaten gewandelt werden:

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 135/166

>> Punkte=[1 2.5;3.3 5; 16 0; 8 2.1; 29 16]


Punkte =
1.0000 2.5000
3.3000 5.0000
16.0000 0
8.0000 2.1000
29.0000 16.0000

>> Radius=sqrt(Punkte(:,1).^2+Punkte(:,2).^2)
Radius =
2.6926
5.9908
16.0000
8.2710
33.1210

>> Phase=atan(Punkte(:,2) ./ Punkte(:,1))


Phase =
1.1903
0.9874
0
0.2567
0.5042

>> Polarkoordinaten=[Radius,Phase]

Polarkoordinaten =

2.6926 1.1903
5.9908 0.9874
16.0000 0
8.2710 0.2567
33.1210 0.5042

bung: 4.2-7

Berechnen Sie einen Vektor, dessen Komponenten aus den Werten der Funktion
y ( t ) sin( 2 * * 5 * t ) * cos( 2 * * 3 * t ) * e 0 .5*t
zu den normierten Zeitpunkten 0 bis 5 in Schritten von 0.1 .

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 136/166

3.2.7 Graphikfunktionen
MATLAB stellt eine Vielzahl von Graphikfunktionen zur Verfgung, die sowohl zweidimen-
sionale oder - perspektivisch dargestellte als Plot von 3 Variablen - dreidimensionale Zusam-
menhnge darstellen knnen.

Die wichtigste Funktion ist plot.


Man kann sich ber diese Plotfunktion durch Eingabe von help plot informieren.
An Hand eines Beispiels wird die Funktionsweise schnell deutlich:

>> t=[0:0.01:2]*pi

>> y=sin(t)

>> plot(t,y,'r.')

Das Ergebnis ist in Bild 4.10


dargestellt und wurde mit dem
Befehl
Edit->Copy -> Figure aus der
Zwischenablage bernommen.
MATLAB bietet noch eine ganze
Reihe von zustzlichen Funktionen
zur Formatierung der Graphiken,
die aus der Hilfe leicht recherchiert
Bild 4.10 : Plotergebnis aus MATLAB
werden knnen und hier nicht
vertieft behandelt werden brau-
chen.
Sollen mehrere Funktionen in einen Graphen gezeichnet werden, so fasst man die verschiedenen
Funktionen in einem Vektor zusammen, der dann geplottet wird.
Interessant und anschaulich sind 3-dimensionale Plots von zwei Funktionen einer Variablen.
Auch hierbei dient das folgende Beispiel zur Erluterung:

>> x=[-3:.1:3]; % Definition des x-Intervalls

>> y=[-3:.1:3]'; % Definition des y-Intervalls

>> Eins=ones(length(x),1); % Definition eines 1-er Vektors

>> X=Eins*x; % Matrix mit x-Wert Kopien

>> Y=y*Eins'; % transponierte Matrix mit y-Wert Kopien

>> fkt=sin(X.^2+Y.^2).*exp(-0.25*(X.^2+Y.^2)); % Definition der mathem. Funktion

>> mesh(x,y,fkt) % Plot-Befehl mesh

>> mxf=max(max(fkt)) % Berechnung des maximalen und minimalen Funktionswertes


mxf =

0.6962

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 137/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 138/166

>> mif=min(min(fkt))
mif =
-0.3175
>> figure % neuer Plot

>> mesh(x,y,fkt) % plotten

>> axis([-3,3,-3,3,mif,mxf]) % Festlegung der Achsen-Wertbereiche

>> xlabel('x-Achse') % x- und

>> ylabel('y-Achse') % y-Achsen Beschriftung

In Bild 4.11 ist der entsprechende Plot abgebildet.

Bild 4.11 :
3D-Plot mit dem
mesh-Befehl

Mit Hilfe der in MATLAB vordefinierten Funktion peaks kann man ein weiteres Beispiel
fr ein Plotergebnis in Bild 4.12 begutachten.

>> fkt=peaks;

>> mesh(fkt)

Bild 4.12 :
3D-Plot der Funkton
peaks

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 139/166

Eine weitere Plot-Option ist surf, der ein Kachelnetz zur Darstellung der Oberflche benutzt
(surface). Bild 4.13 zeigt das Ergebnis.

surf(fkt)

Bild 4.13 .
Plotten mit
dem
surf-Befehl

Aus diesem Plot kann man die Hhenlinien in 2- oder 3-dimensionaler Darstellung extrahie-
ren (Bild 4.14 und 4.15).:

Mit den folgenden Befehlen erhlt man eine 2-dimensionale Hhenlinie:

[X,Y,Z]=peaks;

>> contour(X,Y,Z,20)

Whrend die nachfolgenden Befehle 40 Hhenlinien im 3D-Plot anzeigt (Bild 4.15).

contour3(X,Y,Z,40)

Die dargestellt peaks-Funktion ist bri- Bild 4.14 : 2D-Hhenlinien


gens aus einer Gauss-Verteilung hervor-
gegangen und lsst sich mathematisch wie
folgt darstellen:
z = 3*(1-x).^2.*exp(-(x.^2) - (y+1).^2) ...

- 10*(x/5 - x.^3 - y.^5).*exp(-x.^2-y.^2) ...

- 1/3*exp(-(x+1).^2 - y.^2)

Bild 4.15 : 3D-Hhenlinien Plot


C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Symbolic Toolbox Seite 140/166

bung: 4.2-8

- Machen Sie sich durch die help-Funktion ber die verschiedenen Mglichkeiten des
- 2D- und 3D-Plots kundig.
- Was bedeutet subplot ?
- Was kann man mit dem Befehl hold bewerkstelligen?
- Plotten Sie die Funktion:
2
y2 )
z x * sin( x * y ) * e ( x fr das Interval : [-2,(x,y),2]
- Erzeugen Sie das Maschennetz der x,y-Werte mit der Funktion meshgrid(x,y).

3.3 Symbolic Toolbox


Wie schon oben erwhnt, kann MATLAB auch symbolisch rechnen. Dazu mssen die Vari-
ablen aber auch als Symbole vereinbart werden, was mit dem Befehl syms geschieht:
>> syms x y z
Das Kommando whos listet nun alle definierten Variablen auf:
>> whos
Name Size Bytes Class

x 1x1 126 sym object


y 1x1 126 sym object
z 1x1 126 sym object

Grand total is 6 elements using 378 bytes .


Die unten stehende Tabelle stellt einen Ausschnitt aus der Hilfe der Symbolic Toolbox von
MATALB R2006a dar.
Schauen Sie unter der Matlab Hilfe nach und folgen den Links zu den einzelnen Funktionen
fr weitere Details.

Tabelle 4.1 : Symbolic Toolbox


Funktionen

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Symbolic Toolbox Seite 141/166

Man kann nun eine Funktion f definieren:

>> f=x*exp(-x^2-y^2)*sin(x*y)
f=
x*exp(-x^2-y^2)*sin(x*y)
>> pretty(f)
2 2
x exp(- x - y ) sin(x y)
>> whos
Name Size Bytes Class
f 1x1 172 sym object
x 1x1 126 sym object
y 1x1 126 sym object
z 1x1 126 sym object

Grand total is 31 elements using 550 bytes

Das Kommando pretty verschnt die Darstellung der mathematischen Funktion zur besseren
Leserlichkeit. Nach der Definition ist f nun auch eine symbolische Variable, was der whos-
Ausdruck belegt.
Mit dieser Funktion lassen sich nun z.B. die Differentiale nach x und y bilden.

>> dfx=diff(f,'x') % 1. Ableitung nach x

dfx =

exp(-x^2-y^2)*sin(x*y)-2*x^2*exp(-x^2-y^2)*sin(x*y)+x*exp(-x^2-y^2)*cos(x*y)*y

>> pretty(dfx)

2 2 2 2 2
exp(-x - y ) sin(x y) - 2 x exp(-x - y ) sin(x y)

2 2
+ x exp(-x - y ) cos(x y) y
>> dfy=diff(f,'y')

dfy =

-2*x*y*exp(-x^2-y^2)*sin(x*y)+x^2*exp(-x^2-y^2)*cos(x*y)

>> pretty(dfy)

2 2 2 2 2
-2 x y exp(-x - y ) sin(x y) + x exp(-x - y ) cos(x y)

Die 2. Ableitungen bilden sich analog:


dfxy=diff(dfx,'y')
dfxy =

-2*y*exp(-x^2-y^2)*sin(x*y)+2*exp(-x^2-y^2)*cos(x*y)*x+3*x^2*y*exp(-x^2-y^2)*sin(x*y)-
2*x^3*exp(-x^2-y^2)*cos(x*y)-2*x*y^2*exp(-x^2-y^2)*cos(x*y)

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Symbolic Toolbox Seite 142/166

>> pretty(dfxy)

2 2 2 2
-2 y exp(-x - y ) sin(x y) + 2 exp(-x - y ) cos(x y) x

2 2 2 3 2 2
+ 3 x y exp(-x - y ) sin(x y) - 2 x exp(-x - y ) cos(x y)

2 2 2
- 2 x y exp(-x - y ) cos(x y)

>> dfyx=diff(dfy,'x')

dfyx =

-2*y*exp(-x^2-y^2)*sin(x*y)+2*exp(-x^2-y^2)*cos(x*y)*x+3*x^2*y*exp(-x^2-y^2)*sin(x*y)-
2*x^3*exp(-x^2-y^2)*cos(x*y)-2*x*y^2*exp(-x^2-y^2)*cos(x*y)

>> pretty(dfyx)

2 2 2 2
-2 y exp(-x - y ) sin(x y) + 2 exp(-x - y ) cos(x y) x

2 2 2 3 2 2
+ 3 x y exp(-x - y ) sin(x y) - 2 x exp(-x - y ) cos(x y)

2 2 2
- 2 x y exp(-x - y ) cos(x y)

Man erkennt, dass die partiellen Ableitungen nach x und y gleich der Ableitung nach y und x
sind, wie es bei Funktionen mit einer stetigen 1. Ableitung der Fall sein muss.

Ein Integral lsst sich genauso einfach errechen:

>> f=exp(-x-y^2)*sin(x)
f=
exp(-x-y^2)*sin(x)

>> I=int(f,x) % unbestimmtes Integral nach x


I=
-1/2*exp(-x-y^2)*cos(x)-1/2*exp(-x-y^2)*sin(x)

>> I=int(f,y) % unbestimmtes Integral nach y


I=
1/2*sin(x)/exp(x)*pi^(1/2)*erf(y)

Mit der Funktion solve lassen sich Gleichungen lsen.


So ergibt die Eingabe von

solve('a*x^2 + b*x + c') wobei man die Klammern auch weglasssen kann !!

das Ergebnis:

[ 1/2/a*(-b+(b^2-4*a*c)^(1/2)),
1/2/a*(-b-(b^2-4*a*c)^(1/2))]

solve('a*x^2 + b*x + c','b') gibt

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Symbolic Toolbox Seite 143/166

-(a*x^2+c)/x

S = solve('x + y = 1','x - 11*y = 5') ergibt eine Struktur S mit

S.y = -1/3, S.x = 4/3

A = solve('a*u^2 + v^2', 'u - v = 1', 'a^2 - 5*a + 6')


gibt

A= mit
A .a =
[ 2] A .u = A .v =
a: [4x1 sym] [ 1/3+1/3*i*2^(1/2)] [ -2/3+1/3*i*2^(1/2)]
[ 2]
u: [4x1 sym] [ 3] [ 1/3-1/3*i*2^(1/2)] [ -2/3-1/3*i*2^(1/2)]
[ 3] [ 1/4+1/4*i*3^(1/2)] [ -3/4+1/4*i*3^(1/2)]
v: [4x1 sym] [ 1/4-1/4*i*3^(1/2)] [ -3/4-1/4*i*3^(1/2)]

Zur weiteren Vertiefung der Benutzung der Symbolic Toolbox soll nun folgendes Beispiel
dienen.
Der Effektivwert einer elektrischen Spannung ist definiert durch :

T
1 2
T 0
U eff u (t ) dt . (4-11)

Dieser Wer soll nun mit Hilfe von MATLAB unter Benutzung symbolischer Formeln berech-
net werden.
>> T=2*pi; % Definition der Konstanten

>> t=[0:0.05:T];

>> syms x P % Definition der symbolischen Variablen

>> F=sin(x) % Definition der zu integrierenden Funktion


F=
sin(x)

>> UeInt=int(1/P*F^2,x,0,P) % symbolische Integration ber x im Intervall


UeInt =
1/2*(-cos(P)*sin(P)+P)/P

>> Ue=sqrt(UeInt) % Bildung der Wurzelfunktion


Ue =
1/2*2^(1/2)*((-cos(P)*sin(P)+P)/P)^(1/2)

>> pretty(Ue) % geschnte Darstellung

1/2 /-cos(P) sin(P) + P\ 1/2


1/2 2 |-----------------------|
\ P /
>> Ueff=subs(Ue,P,T) % Substitution der symbolischen Werte

Ueff =

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ MATLAB-Programmierung Seite 144/166

0.7071

bung: 4.3-1

Berechnen Sie das Integral der Funktion


2
f ( x) sin( x) 2 0.5 * e x

symbolisch im Interval [-x0,x0]. Weisen Sie anschlieend einer Variablen den Wert des be-
stimmten Integrals fr x0=10.0 zu

3.4 MATLAB-Programmierung
Um komplexere Algorithmen berechnen zu knnen, stehen in MATLAB auch die bliche
Sprachkonstrukte zur Verfgung, die den Berechnungsablauf in Abhngigkeit von Rechener-
gebnissen steuern knnen. Eine Zusammenfassung der verfgbaren Elemente erhlt man ber
help language und 'M language preferences'. Wir werden im Folgenden nicht nher auf die
einzelnen Elemente eingehen knnen und beschrnken uns auf die formale Erstellung von
Funktionen und Prozeduren in MATLAB.

3.4.1 Funktionen und Prozeduren


Um wiederkehrende Befehlsfolgen zur Berechnung eines Algorithmus effizient zur Hand zu
haben, kann diese Befehlsfolge in einem sog. m-File abgespeichert werden. ber die Regis-
terkarte File -> New -> m-File gelangt man in den Editormodus zur Erzeugung des m-
Files.

Wir wollen den oben berechneten Effektivwert der Sinusschwingung in eine Funktion ueff
auslagern. Dazu wird in den m-File die gleiche Befehlsfolge geschrieben, die zuvor direkt ins
Command Window eingegeben wurde. Abgespeichert werden muss das File unter dem Funk-
tionsnamen, also ueff.m, und zwar bietet MATLAB direkt das Verzeichnis WORK an, in dem
es nach vordefinierten Funktionen sucht.

Bild 4.16 zeigt das geffnet Editor-Fenster zur Erstellung des m-Files.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Bild 4.16 :Editorfenster fr m-File
WS 2010/11
Vietnam German University
Sprachsyntax von C/C++ MATLAB-Programmierung Seite 145/166

Der Funktionskopf enthlt in runden Klammern nach dem Funktionsnamen die bergebenen
Parameter (hier T) und liefert in eckigen Klammern den oder die berechneten Werte zurck
(hier Ueff).

Fehlen die Parameterbergaben, dann hat man es lediglich mit einer Prozedur zu tun, die ge-
nauso wie Funktionen in gleichnamige m-Files gespeichert werden. Sie stellen im Endeffekt
eine Befehlsfolge dar, die bei Prozeduraufruf abgearbeitet wird. Dies ist dann sinnvoll, wenn
gleichartige Befehlsfolgen immer wieder bentigt werden, z.B. bei Plotten o..

Wenn man die einzelnen Befehlszeilen in einer Funktionsdefinition nicht mit einem Semiko-
lon abschliet, dann wird beim Funktionsaufruf im Command Window die Ausfhrung der
einzelnen Funktionsbefehle sichtbar, das Semikolon unterdrckt die Ausgabe im Command
Window:

>> Ueff=ueff(2*pi)

F=
sin(x)

Ueff =
1/2*2^(1/2)*((-cos(P)*sin(P)+P)/P)^(1/2)

1/2 / -cos(P) sin(P) + P \ 1/2


1/2 2 |--------------------------|
\ P /

Ueffektiv =

0.7071

Ueff = Abarbeitung
des m-Files
1/2*2^(1/2)*((-cos(P)*sin(P)+P)/P)^(1/2)

>>

Um komplexere Algorithmen berechnen zu knnen, wird des notwendig sein, einer Funktion
selbst eine Funktion als Parameter zu bergeben.

Dies geschieht mit Hilfe der MATLAB-Funktion feval.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ MATLAB-Programmierung Seite 146/166

3.4.2 MATLAB-Funktion feval


Ein Beispiel soll diese Verschachtelung verdeutlichen. Zuerst definieren wir einen m-File mit
der Cosinus-Funktion und speichern diese Funktion unter dem Namen fktBsp.m ab.

% Beispielfunktion fr feval
% Aufruf fktBsp(x)
function[y]=fktBsp(x);
y=cos(x);

Nun definieren wir eine zweite Funktion, die eine bergebene Funktion numerisch in dem
Interval [a,b] nach der Simpson-Regel integriert und dabei N Sttzstellen benutzt. Die zu
integrierende Funktion wird ihr dabei ebenfalls als Parameter bergeben.

Sie wird unter dem m-File SimpsonInt abgespeichert:


function [Integral]= SimpsonInt(a, b, F, N)
%
% Funktion SimpsonInt : numerische Integration nach der Simpson-Regel
%
% Aufrufbeispiel: IntegralWert = SimpsonInt(2, 4, @Fname, 3)
%
% Beispiel fr den Umgang mit feval-Funktionen
%
h=(b-a)/(2*N); % Teilintervalllnge
intval=(a:h:a+2*N*h); % Sttzstellen
Integral = feval(F,a)+feval(F,b); % F an den Intervallgrenzen
for i=3:2:2*N % F an den Sttzstellen mit den ungeraden Indizes
Integral = Integral+2*feval(F,intval(i));
end;
for i=2:2:2*N % F an den Sttzstellen mit den geraden Indizes
Integral = Integral+4*feval(F,intval(i));
end;
Integral = Integral*h/3; % Normierung mit h/3

Nun kann aus dem Command Window heraus die Integration angestoen werden. Mit dem
Befehl

>> SimpsonIntegralWert=SimpsonInt(2,4,@fktBsp,3)

SimpsonIntegralWert =

-1.6662

wird das Integral ber unsere fktBsp (s. oben) im Interval von 2 bis 4 nach dem Algorithmus
in der Funktion SimpsonInt fr 3 Doppelintervalle, d.h. 7 Sttzstellen, berechnet.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ MATLAB-Programmierung Seite 147/166

bung: 4.4-1

- Berechnen Sie aus dem obigen Beispiel das bestimmte Integral mit unterschiedlichen
Anzahlen von Sttzstellen. Welche nderungen im Ergebnis machen sich bemerkbar?

- Berechnen Sie nach der Simpson-Regel das bestimmte Integral der Sinusfunktion im
Interval [2,4] mit 6 Doppelintervalle

- Berechnen Sie das Integral der Funktion


2
f ( x) sin( x) 2 0.5 * e x
symbolisch im Interval [-x0,+x0] und weisen Sie danach einer numerischen
Variablen den Wert des bestimmten Integrals fr x0= 10.0 zu.

3.4.3 Differentialgleichungen

Mit Hilfe verschiedener Lsungsalgorithmen, die auf das Runge-Kutta-Verfahren hinauslau-


fen, kann MATLAB Differentialgleichungen lsen.

bung: 4.4-2
Informieren Sie sich in der MATLAB-Hilfe ber diese Verfahren und ihre Anwendung (ode)

Im Folgenden werden wir beispielhaft die Lsung von gewhnlichen Differentialgleichungen


betrachten. Als Anwendung dient ein mathematisches Pendel der Lnge L, das aus seiner
Ruhelage um den Winkel ausgelenkt wird. Gesucht ist die Bewegungsgleichung (t). Auf
die physikalische Herleitung der Differentialgleichung wird an dieser Stelle verzichtet und
auf die einschlgige Literatur verwiesen (z.B. Gerthsen, Physik, Springer Verlag, 22. Aufla-
ge).

Fr das mathematische Pendel gilt folgende Differentialgleichung:


g
(t ) * sin( (t )) mit g=9,81 m/sec2 . (4-12)
L

Zur Lsung der DGL 2. Ordnung sind zwei Anfangsbedingungen ntig.

Es sei:

(0) (0) 0 (4-13)

Die unter MATLAB nutzbaren Funktionen zur Lsung von gewhnlichen Differentialglei-
chungen (z.B. ode23) setzen nun voraus, dass aus der DGL ein System von DGLs 1. Ord-
nung geformt wird, das dann dem Lsungsalgorithmus bergeben wird:

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ MATLAB-Programmierung Seite 148/166

1 (t ) (t )
.
2 (t ) (t ) (4-14)

Damit lsst sich fr die DGL schreiben:

2 (0)
1 (t ) g mit der Anfangsbedingung : 1 0
* sin( 1 (t )
2 (t ) L 2 (0)

Dieses System von DGLn ist in einer eigenen Funktion (m-File:PendelDgl.m) ausgelagert
und definiert:

function[AlphaPunkt]=PendelDgl(t,Alpha,Laenge)

% Funktion der Pendeldifferentialgleichung

% Aufruf [AlphaPunkt]=PendelDgl(t,Alpha,Laenge)

g=9.81; % Erdbeschleunigung

AlphaPunkt=[0;0]; % Anfangsbedingung

AlphaPunkt(1) = Alpha(2); % 1. DGL des DGL-Systems 1.Ordnung

AlphaPunkt(2) = -g/Laenge*sin(Alpha(1)); % 2. DGL

Nun kann man mit den folgenden Befehlen die entsprechenden Lsungen fr zwei unter-
schiedliche Pendellngen (20 und 5) im Interval [0,5] fr die Anfangsbedingungen [pi/4,0]
berechnen. Man beachte, dass die Zeit als unabhngiger Parameter in beiden Lsungen anders
bezeichnet werden muss, da die Lsungsvektoren je nach Konvergenz unterschiedlich lang
sind. Es wre ein gemeinsames Plotten mit gleichen Parameter t somit nicht mglich.

>> [t1,Loesung1]=ode23(@PendelDgl,[0,5],[pi/4,0],[],20);
>> [t2,Loesung2]=ode23(@PendelDgl,[0,5],[pi/4,0],[],5);
>> plot(t1,Loesung1(:,1),'r-',t2,Loesung2(:,1),'b-');

Der entsprechende Plot der zwei Pendelauslenkungen Alpha ((t) ) ist in Bild 4.17 dargestellt.

Bild 4.17 :
Lsung der Differentialglei-
chung des mathematischen
Pendels fr zwei unterschie-
dliche Pendellngen

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ MATLAB-Programmierung Seite 149/166

Man erkennt an der Lsung, dass mit zunehmender Pendellnge auch die Periodendauer
zunimmt (proportional L ).

bung: 4.4-3

Betrachten Sie einen RC-Tiefpass (Bild 4.18) und berechnen Sie das Ausgangssignal ua(t) bei
einer Erregung mit dem Einheitssprung (t) fr die Zeitkonstante R * C 1 m sec .

(t) R
ua(t)
C
Bild 4.18 : RC-Tiefpass

3.4.4 Graphik-Animation
Mit MATLAB kann man auch bewegte Bilder erzeugen. Dazu wird eine Folge von Bildern
berechnet und hintereinander in ein Graphikfenster geplottet. Man kann damit die gleiche
Wirkung wie in einem Film erzeugen, in dem auch die einzelnen Aufnahmen hintereinander
abgespielt werden.

Als Beispiel soll eine Federoszillation dienen.


Die Feder wird im Ruhezustand durch folgende Gleichungen beschrieben:

x A * cos t (4-15)

y A * sin t (4-16)

z t , normiertes Zeitintervall [0 , 8*] (4-17)

Im Falle der Oszillation in z-Richtung ergibt sich fr die z-Auslenkung:

z t * (1 B * cos( (T 1)) (4-18)

t = 0 : pi/60 : 10*pi; % Zeitvektor


A = 1; % Amplitude
B = 0.3; % Amplitude
Omega=2*pi/3; % Frequenz der Oszillation
for T=1:10 % Zeitschleife fr Oszillation

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ MATLAB-Programmierung Seite 150/166

x=A*cos(t);
y=A*sin(t);
z=(1+B*cos(Omega*(T-1)))*t;
plot3(x,y,z);
axis([-A A -A A 0 20*pi]);
M(T) = getframe; % Abspeichern der Bilder
end
movie(M,5) % 5-mal anspielen lassen

In Bild 4.19 ist der Plot nach dem obigen Algorithmus gezeigt und zwar zu einem festen Zeit-
punkt.

60

50

40

30
Bild 4.19 :
20
Plot der Schraubenfederoszillation
10

0
1

0.5 1
0.5
0
0
-0.5
-0.5
-1 -1

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Simulink-Toolboxen Seite 151/166

3.5 Simulink-Toolboxen
Simulink ist eine separate Toolbox von MATLAB und stellt ein Simulationswerkzeug insbe-
sondere zur Simulation dynamischer Systeme dar.
Simulink wird durch Eingabe des Befehls:

simulink3 ( oder simulink ) gestartet.

Dadurch erscheint ein Fenster mit den graphischen Symbolen der Simulink-Bibliotheken
(Bild 4.20).

Bild 4.20 :
Pop-Up Fenster
von Simulink

Ein Doppelklick auf eines der Symbole ffnet ein weiteres


Fenster, das die graphischen Elemente dieser Unterbiblio-
thek zeigt (Bild 4.21).

Man erkennt schon an der Prsentation der Biblio-


theksinhalte, dass es sich bei Simulink um ein graphisch
orientiertes Simulationswerkzeug handelt.
Die einzelnen Elemente knnen nun in ein eigenes Simu-
lationsmodel bertragen werden, indem man ber
File -> New -> Model
ein spezifisches, neues Blatt ffnet.
Durch drag & drop lassen sich nun die einzelnen Model-
Elemente aus den verschiedenen Bibliotheken in das
Modellblatt einfgen.

Zum Einstieg vollen wir ein einfaches Sinus-Signal integ-


rieren und als Simulationsergebnis darstellen.
Bild 4.22 zeigt das Model. Bild 4.21 : Bibliothek mathematischer
Elemente von Simulink

Bild 4.22 :
Simulation (Berech-
nung) des Integrals
einer Sinusfunktion
C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Simulink-Toolboxen Seite 152/166

Der Integrator (hier dargestellt als Laplace-Transformationssymbol (1/s) ) entnimmt man der
Library Continuous, das Eingangssignal aus Sources, der Multiplexer aus Signal&Systems
und letztendlich zur Darstellung der Ergebnisse ein Scope aus der Sublibrary Sinks.
Durch Anklicken des einzelnen Elementes und Auswahl der Hilfe, kann zu jedem Block
detaillierte Informationen ber dessen Wirkung, Parameter o.. abgerufen werden.
Die Signal- oder Wirkungslinienverbindung wird mit der Maus realisiert, entweder durch
Anklicken des Elementes, wodurch sich der Cursor zu einem Kreuz wandelt und man mit der
Maus die Verbindung ziehen kann. Man kann aber auch Simulink die Verbindung selbst
ziehen lassen. Dazu wird das Quellelement angeklickt; mit gepresster STRG-Taste wird das
Zielelement mit der rechten Maustaste identifiziert und Simulink verbindet die beiden Ele-
mente.

Die einzelnen Elemente knnen parametriert werden,


indem man sie doppelt anklickt. Dadurch ffnet sich ein
Fenster, das die mglichen Parameter fr Vernderungen
zugnglich macht.
In Bild 4.23 ist das Parameterfenster der Sinus-
Schwingung dargestellt. Die einzelnen Felder sind selbst-
erklrend und knnen fr jeden Simulationslauf verndert
werden.

Um nun die eigentliche Simulation zu starten, wird im


Modellfenster unter der Rubrik Simulationsparameter
die fr die Signalberechnungen relevanten Eintrge vern-
dert (Bild 4.24).

Bild 4.23 : Parametermen der Sinus-


Schwingung

Die verschiedenen solver options sind schon aus


MATLAB bekannt und stellen die mglichen L-
sungsalgorithmen der Differentialgleichungen dar.
Man kann die Lsung mit festen oder variablen
Schrittweiten berechnen.

Bild 4.24 : Simulationsparameter

Um die eigentliche Simulation zu


starten ffnet man die Registerkarte
Simulation->Start (CTRL T).
Die Simulation, d.h. hier die Berech-
nung der Signale beginnt.

Ein Doppelklick auf das Ausgangsele-


ment (Scope) ffnet dessen Fenster und
stellt die berechneten Signale dar (Bild
4.25).

Bild 4.25 : Simulationsergebnis Sinus-Integral

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Simulink-Toolboxen Seite 153/166

Das Eingangssignal mit der Amplitude


2 und der Frequenz 1, d.h. der Perio-
dendauer 2 (s. Bild 4.23) ist als blaue
Linie erkenntlich; das Integral der
Cosinus ist entsprechend gelb ge-
kennzeichnet.

Aus Bild 4.26 wird ersichtlich, dass die


Signale des Scopes ber ein Array mit
dem Namen Testsignal im Workspace
von MATLAB zur Verfgung gestellt
werden. Mit dem Befehl whos kann
man das verifizieren:

>> whos
Name Size Bytes Class
Bild 4.26 : Scope-Parameter und MATLAB-
TestSignal 1001x3 24024 double array
tout 1000x1 8000 double array Variable

Grand total is 4003 elements using 32024 bytes


MATLAB hat also einer 1001x3-Matrix die Werte gespeichert, je 1001 Werte fr die Zeit
(feste Schrittweite war eingestellt) und die beiden Ausgangssignale.
Das zustzliche Signal tout ist entsprechend den Simulationsparametern (unter der Register-
karte Workspace I/O) noch als weiterer Ausgabevektor fr die Zeit ausgewhlt worden.

3.5.1 Lsung von Differentialgleichungen


Mit Hilfe eines Simulationsmodels kann man auch Differentialgleichungen lsen. Am Bei-
spiel eines Differentialgleichungssystems soll dies Mglichkeit erlutert werden.
Hierzu betrachten wir das folgende Differentialgleichungssystem:

y1 (t) 3 y1 (t) 2 y 2 (t)

mit den Anfangsbedingungen
y 2 (t) 4 y1 (t) 2 y 2 (t)

y1 (0) 1
y 2 (0) 1 . (4-19)

In Bild 4.27 ist das entsprechende Model zur Lsung von y1(t) und y2(t) dargestellt.

Bild 4.27 :
Simulink-Model zur
Lsung des Differen-
tialgleichungssystems 1.
Ordnung nach Gl. 4-19

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Simulink-Toolboxen Seite 154/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Simulink-Toolboxen Seite 155/166

Die graphische Lsung lsst sich nun durch Doppel-


klicken auf die Scope-Blcke sichtbar machen (Bild
4.28).
Da wir im Model zustzlich die berechnete L-
sungsvektoren in das Workspace abgespeichert
haben, stehen diese mit den Arrays y1 und y2 sowie
t zur weiteren Verwendung zur Verfgung
(Bild 4.29).

Bild 4. 29 : Workspace von MATLAB mit den Simula-


tionslsungswerten

Das Differentialgleichungssystem nach Gl. 4-19 ist


aber auch geschlossen lsbar in MATLAB. Dazu
werden folgende Kommandos eingegeben: Bild 4.28 : Graphische Anzeige
der Simulationsergebnisse

>> syms y1 y2

>> Loesg=dsolve('Dy1=-3*y1-2*y2', 'Dy2=4*y1+2*y2', 'y1(0)=1', 'y2(0)=1')

Loesg =

y1: [1x1 sym]


y2: [1x1 sym]

>> Y1=Loesg.y1

Y1 =
-1/7*exp(-1/2*t)*(-7*cos(1/2*t*7^(1/2))+9*7^(1/2)*sin(1/2*t*7^(1/2)))

>> Y2=Loesg.y2
Y2 =

1/7*exp(-1/2*t)*(13*7^(1/2)*sin(1/2*t*7^(1/2))+7*cos(1/2*t*7^(1/2)))

>> pretty (Y1)


1/2 1/2 1/2
- 1/7 exp(- 1/2 t) (-7 cos(1/2 t 7 ) + 9 7 sin(1/2 t 7 ))
>> pretty (Y2)

1/2 1/2 1/2


1/7 exp(- 1/2 t) (13 7 sin(1/2 t 7 ) + 7 cos(1/2 t 7 ))
>>

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Simulink-Toolboxen Seite 156/166

Im Workspace sind nun nach der analytischen und numerischen Berechnung folgende Werte
vorhanden:

>> whos

Name Size Bytes Class

Loesg 1x1 770 struct array


Y1 1x1 262 sym object
Y2 1x1 260 sym object
t 901x1 7208 double array
y1 901x1 7208 double array
y2 901x1 7208 double array

Grand total is 2983 elements using 22916 bytes

Man kann nun die exakte mit der numerisch durch Simulink berechnete Lsung vergleichen,
indem man die beiden Kurven zusammen plottet:

>> plot(zeit,Lsg1,'-r',zeit,y1,'-b')

Das Ergebnis in Bild 4.30 zeigt jedoch


keinen Unterschied im Rahmen der norma-
len Plot-Genauigkeit. Erst eine starke Ver-
grerung zeitigt die feinen numerischen
Unterschiede (Bild 4.31).
An den Plotproperties erkennt man die
numerischen Unterschiede in den
y-Achsenwerten (Bild 4.32).

Bild 4.30 : Plot der simulierten (numerischen)


und exakten Ergebnisse aus Gl. 4-9.

Bild 4.32 : Plot Properties zu Bild 4.29


Bild 4.31 : Starke Vergrerung des Plots
in Bild 4.30

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Simulink-Toolboxen Seite 157/166

3.5.2 Simulation dynamischer, linearer, zeitinvarianter Systeme


Zum Abschluss der Betrachtungen der Simulink Toolbox soll ein dynamisches System 2.
Ordnung betrachtet werden.
Lassen sich die Systeme als linear und zeitinvariant betrachten, kann die mathematische
Beschreibung sehr vereinfacht werden. Diese Systeme knnen durch eine sog. Systember-
tragungsfunktion G(s) beschrieben werden, wobei s wieder die oben schon erwhnte Laplace-
Variable darstellt. Auf die Einzelheiten einer Systembeschreibung durch die Laplacetrans-
formation kann an dieser Stelle nicht eingegangen werden. Hierfr sei auf die Spezialliteratur
(s. Literaturverzeichnis am Ende des Scripts) verwiesen.

Wir wollen als einfaches System eine fremderregte Gleichstrommaschine betrachten, die in
vielen Maschinen als Antrieb Verwendung findet. In Bild 4.33 ist das Blockschaltbild der
Maschine dargestellt. Die Ankerspannung UA stellt die Eingangsgre dar, die Zeitkonstante
TA ist durch die Induktivitt und den ohmschen Widerstand im Anker gegeben. Dieser Kreis
bildet ein sog. VZ1- Glied, ein Verzgerungsglied 1. Ordnung, das durch die Laplace-
bertragungsfunktion G(s) im Blockschaltbild dargestellt und beschrieben wird. Der Motor
erzeugt aufgrund seiner Eingangsspannung UA ein inneres Moment MMi , das die Maschine
gegen das Widerstandsmoment MW antreibt. Es resultiert eine Vernderung der Drehzahl
(Winkelbeschleunigung), die integriert die Drehzahl N ergibt.

Bild 4.33 : Blockschaltbid der fremderregten Gleichstrom-

Die bertragung des Models in ein Simulink-Model zeigt Bild 4.34 .

Bild 4.34 : Simulink-Model der fremderregten GL-Motors

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Simulink-Toolboxen Seite 158/166

Die fr die Parametrisierung des Models ntigen Parameterwerte kann man zweckmiger-
weise in einem m-File speichern, dass dann unter MATLAB aufgerufen wird (Bild 4.35).

Bild 4.35 : Simulationsparame-


ter fr die fremderregte GM

Im Simulink-Model kann man unter der Registerkarte Tools -> Linear analysis den sog.
LTI-Viewer starten. LTI steht dabei fr linear time invariant. Dieses Werkzeug erlaubt die
Auswertung der Daten zwischen Input und Output Point (Bild 4.34) zu analysieren und dar-
zustellen (Bild 4.36). ber die Registerkarte Simulink -> Get Linearized Model kann man
die Darstellung erzeugen.

Die Mglichkeiten der Auswertung dynamischer Systeme sind sehr vielfltig und knnen hier
nicht weiter beschrieben werden.

Weiterfhrende Anleitungen findet man aber im Internet unter http:www.mathworks.com .

Bild 4.36 : LTIU-Viewer


Darstellung der
Sprungantwort der
fremderregten GM

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Simulink-Toolboxen Seite 159/166

An der Sprungantwort (Bild 4.36) des Systems erkennt man das fr ein System 2. Ordnung
typische Einschwingverhalten - hier mit einem krftigen berschwinger des noch ungeregel-
ten Systems. In einem weiteren Schritt kann man nun Simulink nutzen, um einen passenden
Regler fr die GM zu entwerfen, die den berschwinger, der fr den praktischen Einsatz
i.d.R. unbrauchbar ist, auszuschalten.

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Anhang MATLAB Funktionen Seite 160/166

3.6 Anhang MATLAB Funktionen

3.6.1 Steuerfunktionen fr MATLAB:

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Anhang MATLAB Funktionen Seite 161/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Anhang MATLAB Funktionen Seite 162/166

3.6.2 Mathematische Funktionen

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Sprachsyntax von C/C++ Anhang MATLAB Funktionen Seite 163/166

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Literaturverzeichnis Seite - 1 -

Literaturverzeichnis

I. Informatik, OOP, C++ :

1. Claussen, Objektorientiertes Programmieren,


Springer Verlag, ISBN 3-540-57937-0

2. P. Levi, U. Rembold, Einfhrung in die Informatik


Hanser Verlag ,ISBN 3-446-21932-3
Grundlegende Einfhrung, umfangreich

3. Kchlin, Weber, Einfhrung in die Informatik,


Springer Verlag, ISBN 3-540-43608-1
Einfhrung anhand von Java Beispielen

4. G. Kveler, D. Schwoch, Informatik fr Ingenieure,


Vieweg Verlag, ISBN 3-528-34952-2
Fokus auf C/C++ und Mikrorechner und Netzen

5. D. Herrmann, Grundkurs C++ in Beispielen,


Vieweg Verlag ISBN 3-528-54655-7
Gute und knappe Einfhrung anhand vieler Beispiele

6. J. Tempelman, A. Olsen, Visual C++. NET


Microsoft Press, ISBN 3-86063-785-1
Nachschlagewerk

7. K. Gregory, Visual C++.NET,


Verlag Markt+Technik, ISBN 3-8272-6459-6
Nachschlagewerk

8. D. Chapman, VisualC++.NET in 21 Tagen


Verlag Markt+Technik, ISBN 3-8272-6320-4
Zum Selbststudium, gute Gliederung und Beispiele

9. T. Zwolsky, Das Einsteigerseminar Visual C++.NET


bhv-Verlag, ISBN 3-8266-7167-8
kurze und einfache Einfhrung in die IDE .NET

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Literaturverzeichnis Seite - 2 -

II. Matlab/Simulink :

10. Otmar Beucher, Matlab/Simulink,


Pearson Studium, Addison-Wesley, ISBN 3-8273-7042-6
Kurze und grundlegende Einfhrung mit vielen guten Beispielen, zum Selbststudium geeignet

11. Dieter Schott, Ingenieurmathematik mit Matlab,


Fachbuchverlag Leipzig, ISBN 3-446-22043-7
Algebra und Analysis fr Ingenieure mit Matlab-Kurs
Matlab-Kurs und Mathematik-Buch in einem, viele Beispiele, umfangreich

12. Gnter Gramlich, Wilhelm Werner, Numerische Mathematik mit Matlab,


dpunkt Verlag, ISBN 3-932588-55 X,
Matlab-Einfhrung am Beispiel numerischer Problemstellungen aus der Mathematik, umfangreich mit
vielen Beispielen

13. Gnter Gramlich, Anwendungen der linearen Algebra mit Matlab


Fachbuchverlag Leipzig, ISBN 3-446-22655-9
Kurz aber umfassend

14. Helmut Bode, Matlab-Simulink, Analyse dynamischer Systeme


Teubner, ISBN 3-8351-0050-5

15. Wolf Dieter Pietruszka, Matlab und Simulink in der Ingenieurpraxis, Modellbildung, Berechnung und
Simulation
Teubner Verlag, ISBN 978-3-8351-0100-5

16. Ulrich Stein, Programmieren mit Matlab, Hanser Verlag, ISBN 978-3-446-41009-1

17. Angermann, M. Beuschel, M. Rau, U. Wohlfarth, Matlab-Simulink-Stateflow,


Oldenbourg-Verlag, ISBN 3-486-27602-6

Weiterfhrende Literatur:

18. Martin Werner, Digitale Signalverarbeitung mit Matlab,


Vieweg Verlag, ISBN 3-528-13930-7, 2. Auflage 2003

19. Forst, Hoffmann, Funktionentheorie erkunden mit Matlab,


Springer Verlag, ISBN 3-540-42543-8

III. Systemtheorie und Systembeschreibung linearer, zeitinvarianter Systeme:

20. Katsuhiko Ogata, System Dynamics, Prentice Hall, ISBN 0-13-124714-X

21. Unbehauen, Systemtheorie, Oldenbourg Verlag, 1977

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11
Literaturverzeichnis Seite - 3 -

22. Girod, Rabenstein, Stenger, Einfhrung in die Systemtheorie, Teubner Verlag, ISBN 3-519-16194-X

IV. Numerische Mathematik :

23. Robert Plato, Numerische Mathematik, Vieweg Verlag , ISBN 3-528-13153-5

24. Robert Plato, bungsbuch zur Numerische Mathematik, Vieweg Verlag , ISBN 3-528-03209-X

C++ Programming
Prof. Dr.-Ing. Hans-Werner Dorschner
Vietnam German University WS 2010/11