C++ - Vgu 2010-11

September 2009 Fakultt fr Maschinenbau u. Mechatronik Prof. Dr.-Ing.
Hans-Werner Dorschner
Hochschule Karlsruhe Technik und Wirtschaft

Computer Science
and Programming
for Engineer

Fakulty for mechanical Engineering and

Prof. Dr.-Ing. Hans-Werner Dorschner
WS 2010/11

Contents Seite II/166

Vietnam German University
C++ Programming
WS 2010/11
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
Contents Seite III/166

C++ Programming
WS 2010/11
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

Contents C++ - Character Set Seite 4/166

C++ Programming
WS 2010/11

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

Lecture Outline C++ - Character Set Seite 5/166

C++ Programming
WS 2010/11
1 Lecture Outline

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

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.

Those who see the computer more than a tool,
underestimates himself !

The man knows what he is doing,
the computer does what he knows.
Lecture Outline C++ - Character Set Seite 6/166

C++ Programming
WS 2010/11

Sprachsyntax von C/C++ C++ - Character Set Seite 7/166

C++ Programming
WS 2010/11
2 Sprachsyntax von C/C++
Sprachsyntax von C/C++ C++ - Character Set Seite 8/166

C++ Programming
WS 2010/11
2.1 C++ - Character Set
Der C-Zeichensatz umfasst die folgenden Zeichen:

Numbers:

Alphanumericals:

Special Symbols:

+ plus
- hyphen or minus
* asterisk
% percent
/ slash
\ backslash
" double quote
' apostrophe
# number sign
! exclamation pt.
= equal
< less than
> greater than
: colon
; semicolon
, comma
. period
? question mark
| vertical bar
& ampersand

^ circumflex
~ tilde
_ underscore
( left parenthesis
) right parenthesis
[ left bracket
] right bracket
{ left brace
} right brace

Leerzeichen,
Tabulator,
Seitenwechselzeichen (whitespaces)

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

0 1 2 3 4 5 6 7 8 9
Sprachsyntax von C/C++ Variables Seite 9/166

C++ Programming
WS 2010/11
2.2 Variables
A = 1000; A hast he value of 1000
x=x+1; x
new
= x
old
+ 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
WS 2010/11
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
WS 2010/11
2.2.2.2 Comparison Operators

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

Operator Beschreibung
== equal
!= unequal
> biger
< smaler
>= biger or equal
<= smaler or equal
Sprachsyntax von C/C++ Characters Seite 12/166

C++ Programming
WS 2010/11
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");
};

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++ does not distinguish between charackters and numbers -
its ASCII-Code.
Sprachsyntax von C/C++ Data Structures Seite 13/166

C++ Programming
WS 2010/11
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>
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;
Sprachsyntax von C/C++ Arrays Seite 14/166

C++ Programming
WS 2010/11
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>

#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
WS 2010/11
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:

x
3
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
WS 2010/11

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>
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
WS 2010/11

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
WS 2010/11
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
WS 2010/11
#include <iostream>
#include <cstdlib>
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
WS 2010/11


C++ Programming
WS 2010/11
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>
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>
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);
system ("PAUSE");
return 0;
}

C++ Programming
WS 2010/11

Sprachsyntax von C/C++ Mathematische Funktionen Seite 23/166

C++ Programming
WS 2010/11
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
x e 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 .

Die wichtigsten Funktionen, die in der math.h bzw cmath implementiert sind, finden sie in
L
Vektor (10,15,20)
x
y
z


C++ Programming
WS 2010/11
der untenstehenden Tabelle 3-12 bzw. 3-13.

C++ Programming
WS 2010/11
#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;
using ::ldexpf;
using ::ldexpl;
using ::log;
using ::log10;
using ::log10f;
using ::log10l;
using ::logf;
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;

Durch das Einbinden des cmath-Headers
werden die Namen der mathematischen
Funktionen im Standard Namespace definiert
und dadurch zugnglich. Die Funktionen
selber sind in der Standard C++-Library
implementiert.

C++ Programming
WS 2010/11
Tabelle 3-12 : cmath-Header
using ::tanhl;
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.

Rout i ne Use . NET Fr amew or k equi v al ent
abs Ret urn absolut e value of
i nt
Syst em: : Mat h: : Abs
acos, acosf Calculat e arccosine Syst em: : Mat h: : Acos
asin, asinf Calculat e arcsine Syst em: : Mat h: : Asin
at an, at anf, at an2, at an2f Calculat e arct angent Syst em: : Mat h: : At an, Sys-
t em: : Mat h: : At an2
at of, _at of_l, _wt of,
_wt of_l
Convert charact er st ring t o
double- precision float ing-
point value
Syst em: : Convert : : ToSingle, Sys-
t em: : Convert : : ToDouble
Bessel funct ions Calculat e Bessel funct ions
_j 0, _j 1, _j n, _y0, _y1,
_yn
Not applicable. To call t he st andard C
funct ion, use PI nvok e. For more
informat ion, see Plat form I nvoke
Examples.
_cabs Find absolut e value of
complex number
Not applicable.
ceil, ceilf Find int eger ceiling Syst em: : Mat h: : Ceiling
_chgsign, _chgsignl Reverse sign of double-
precision float ing- point or
long double- precision
float ing- point argument
Not applicable.
_clear87, _clearfp Get and clear float ing- point
st at us word
Not applicable.
_cont rol87, _cont rolfp,
__cont rol87_2,
_cont rolfp_s
Get old float ing- point
cont rol word and set new
cont rol- word value
Not applicable.
_copysign, _copysignl Ret urn one value wit h sign
of anot her
Not applicable.
cos, cosf, cosh, coshf Calculat e cosine Syst em: : Mat h: : Cos, Sys-
t em: : Mat h: : Cosh
difft ime Comput e difference
bet ween t wo specified t ime
values
Syst em: : Dat eTime: : Subt ract
div Divide one int eger by
anot her, ret urning quot ient
and remainder
Not applicable.

C++ Programming
WS 2010/11
_ecvt , _ecvt _s Convert doubl e t o charac-
t er st ring of specified
lengt h
Syst em: : Convert : : ToSt ring
exp, expf Calculat e exponent ial
funct ion
Syst em: : Mat h: : Exp
fabs, fabsf Find absolut e value Syst em: : Mat h: : Abs
_fcvt , _fcvt _s Convert doubl e t o st ring
wit h specified number of
digit s following decimal
point
_finit e Det ermine whet her given
point value is finit e
Syst em: : Double: : I sI nfinit y
floor, floorf Find largest int eger less
t han or equal t o argument
Syst em: : Mat h: : Floor
fmod, fmodf Find float ing- point remain-
der
Syst em: : Mat h: : I EEERemainder
_fpclass Ret urn st at us word cont ain-
ing informat ion on float ing-
point class
Syst em: : Double: : I sI nfinit y, Sys-
t em: : Double: : I sNegat iveI nfinit y,
Syst em: : Double: : I sPosit iveI nfinit y,
Syst em: : Double: : I sNan
_fpieee_flt I nvoke user- defined t rap
handler for I EEE float ing-
point except ions
Not applicable.
_fpreset Reinit ialize float ing- point
mat h package

frexp Calculat e exponent ial value Not applicable.
_gcvt , _gcvt _s Convert float ing- point
value t o charact er st ring
_hypot , hypot f Calculat e hypot enuse of
right t riangle
Not applicable.
_isnan Check given double-
precision float ing- point
value for not a number
( NaN)
Syst em: : Double: : I sNan
labs Ret urn absolut e value of
l ong
Syst em: : Mat h: : Abs
ldexp Calculat e product of
argument and 2 t o speci-
fied power
Syst em: : Mat h: : Pow
ldiv Divide one l ong int eger by
anot her, ret urning quot ient
and remainder
Not applicable.

C++ Programming
WS 2010/11
log, logf, log10, log10f Calculat e nat ural or base-
10 logarit hm.
Syst em: : Mat h: : Log, Sys-
t em: : Mat h: : Log10
_logb Ext ract exponent ial value of
point argument
Not applicable.
_lrot l, _lrot r Shift unsi gned l ong i nt
left ( _l r ot l ) or right
( _l r ot r )
Not applicable.
_mat herr Handle mat h errors Not applicable.
__max Ret urn larger of t wo values Syst em: : Mat h: : Max
__min Ret urn smaller of t wo
values
Syst em: : Mat h: : Min
modf, modff Split argument int o int eger
and fract ional part s
Not applicable.
_next aft er Ret urn next represent able
neighbor
Not applicable.
pow, powf Calculat e value raised t o a
power
Syst em: : Mat h: : Pow
print f, _print f_l, wprint f,
_wprint f_l, print f_s,
_print f_s_l, wprint f_s,
_wprint f_s_l
Writ e dat a t o st dout
according t o specified
format
Syst em: : Console: : Writ e, Sys-
t em: : Console: : Writ eLine
rand, rand_s Get pseudorandom number Syst em: : Random Class
_rot l, _rot r Shift unsi gned i nt left
( _r ot l ) or right ( _r ot r )
Not applicable.
_scalb Scale argument by power
of 2
Not applicable.
scanf, wscanf, scanf_s,
_scanf_s_l, wscanf_s,
_wscanf_s_l
Read dat a from st di n
according t o specified
format and writ e dat a t o
specified locat ion
Syst em: : Console: : Read, Sys-
t em: : Console: : ReadLine
_set _cont rolfp set new cont rol- word value Not applicable.
sin, sinf, sinh, sinhf Calculat e sine or hyperbolic
sine
Syst em: : Mat h: : Sin, Sys-
t em: : Mat h: : Sinh
sqrt Find square root Syst em: : Mat h: : Sqrt
srand I nit ialize pseudorandom
series
Syst em: : Random Class
_st at us87, _st at usfp,
_st at usfp2
Get float ing- point st at us
word
Not applicable.
st rt od, _st rt od_l, wcst od,
_wcst od_l
Convert charact er st ring t o
double- precision value
Syst em: : Convert : : ToDouble

C++ Programming
WS 2010/11
t an, t anf, t anh, t anhf Calculat e t angent or
hyperbolic t angent
Syst em: : Mat h: : Tan, Sys-
t em: : Mat h: : Tanh

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

Sprachsyntax von C/C++ Zeiger Seite 30/166

C++ Programming
WS 2010/11
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-
halt
Adresse

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.
Sprachsyntax von C/C++ Zeiger Seite 31/166

C++ Programming
WS 2010/11

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>
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;
pb=&b; // pb ist Adresse von b
system ("PAUSE")
};

Sprachsyntax von C/C++ Call-by-reference Seite 32/166

C++ Programming
WS 2010/11
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>
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>
void swap(int a,int b)
{
int tmp=a;
a=b;
b=tmp;
};
void main()
{

C++ Programming
WS 2010/11
int a=1;
int b=2;
swap(a,b);
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.

#include <iostream>
#include <cstdlib>
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
Man bergibt statt der Werte die Adressen der beiden Variablen (call-by-reference)
und vertauscht die Inhalte, auf die die beiden Adressen hinzeigen.

C++ Programming
WS 2010/11
*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<<"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 */
Sprachsyntax von C/C++ Adressierung von Arrays Seite 35/166

C++ Programming
WS 2010/11
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.

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>
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( )
{
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.

C++ Programming
WS 2010/11
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);
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
2
1 2 3
0 a x a x a + + =

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

2
2 2 1 3
01,02
1
4
2
a a a a
x
a

= .

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 a
i
sind unter der Adresse von a abgelegt und werden der Funktion ber-
geben.


C++ Programming
WS 2010/11
bung: 3.26-3
Welchen Ausdruck erhlt man durch folgenden Code und was bedeuten die einzelnen
Zeilen?
#include<iostream>
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>
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
WS 2010/11
};

C++ Programming
WS 2010/11
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>
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}

x
y
x
1
x
2

y
1

y
2


C++ Programming
WS 2010/11
bung: 3.26-7

Was gibt dieses Programm aus?

#include<iostream>
#include<cmath>
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>
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
WS 2010/11
};

C++ Programming
WS 2010/11
bung: 3.26-9

Gegeben ist das Projekt

#include <iostream>
#include <limits>
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>

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;};

Sprachsyntax von C/C++ Referenz als Konstante Seite 43/166

C++ Programming
WS 2010/11
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:

Sprachsyntax von C/C++ Referenz als Konstante Seite 44/166

C++ Programming
WS 2010/11
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.

Sprachsyntax von C/C++ Speicherplatzbelegung (new, delete) Seite 45/166

C++ Programming
WS 2010/11
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.

#include <iostream>
#include <cstdlib>
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.
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.

C++ Programming
WS 2010/11

#include<iostream>
#include <cmath>
#include <cstdlib>
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-
Werte auf dem heap eingelesen werden und anschlieend der Mittelwert
1
1
n
i
i
X X
n
=
=

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
WS 2010/11
2
1
1
( )
n
i
i
X X
n
o
=
=
, hierbei ist
i
X Messwerte
X Mittelwert der Messwerte

Sprachsyntax von C/C++ Numerische Integration Seite 48/166

C++ Programming
WS 2010/11
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:
{ } { }
1
0
( ) ( ) ( )
x
n
a a
n k
k
a
I f x f d I f x a x c c

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

Der so erzeugte Integrationsalgorithmus nennt man den Rechteckalgorithmus, wie er im
folgenden Programm implementiert ist.

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

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;
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;
};

C++ Programming
WS 2010/11
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:

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);

double integrieren(double linkeGrenze, double rechteGrenze,
int anzahlIntervalle, double integrand(double)
).

C++ Programming
WS 2010/11
Den Fehler durch die diskrete Approximation kann man abschtzen:

| |
1
0
( ) ( )
k
k
x x
k n
rec k
k
x
F f x f x dx
+A
=
=
=

. (3-3)
Wenn die Funktion im Intervall | | ,
k k
x x x + A , dann kann man die Funktion mittels einer Tay-
lorentwicklung darstellen. Daraus errechnet sich dann der Fehler zu:
( )
1
' 2
0
( ) ( )
k
k
x x
k n
rec k k
k
x
F f x x x dx x
+A
=
=
= + O A

. (3-4)
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 = A das Integrationsintervall
darstellt:

'
2
( )
2 2
k
k
x x
x
rec
f x M
M n x M x I
F
+A
<
A A
< =
.
(3-5)
Der Fehler ist also proportional
2
x A , jedoch ist x n I A = konstant, sodass man - abgesehen
von einem auergewhnlichen Eliminieren positiver und negativer Fehleranteile - von einer
linearen Abhngigkeit des numerischen Fehlers vom Interpolationsintervall x A ausgehen
kann.

bung: 3.29-1

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

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

1
1
1
0
( ) ( ) 4 ( ) ( )
6 2
R
n
i i
i i
i
L
x x x
f x dx f x f f x
+
+
=
+ A
+ +

~ . (3-6)
Sprachsyntax von C/C++ Numerische Ableitung Seite 51/166

C++ Programming
WS 2010/11
2.13 Numerische Ableitung
hnlich wie bei der numerischen Integration wird auch die Ableitung durch eine Differenz
approximiert:

0
( ) ( ) ( )
lim
x
df x f x x f x
dx x
A
+ A
| |
=
|
A
\ .
. (3-7)

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

2 2
2
( ) ( ) ( )
( ) ( )
2!
df x x d f x
f x x f x x
dx dx
A
+ A = + A + +.. (3-8)
Benutzt man diese Entwicklung und setzt sie in Gl. (3-7) ein, so erhlt man:

2
2
( )
( ( )) ( )
( )
( )
2
x
df x
D f x x
dx
x d f x
x
dx
A
= + O A
A
O A =
. (3-9)

Hinsichtlich der Fehleranalyse mssen aber zwei Dinge bercksichtigt werde:

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

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


C++ Programming
WS 2010/11
Das folgende Programm realisiert den Algorithmus fr zwei Beispielfunktionen.

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

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";
double ableiten(double f(double),double X, double Del)
{
return (f(X + Del) - f(X) ) / Del;
};

C++ Programming
WS 2010/11
};
system ("PAUSE"); };

bung: 3.30-1

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

- Ab welchem x A wird die Berechnung falsch?

- Berechnen Sie die Ableitung der Funktion
2
( ) 2.0
x
f x e
= an der Stelle
x = 1 und x = 0
Sprachsyntax von C/C++ Numerische Nullstellensuche Seite 54/166

C++ Programming
WS 2010/11
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 ( ) ( ) 0 f a f b < , 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 ( ) ( ) 0 f a f b < erfllt ist.
In Bild 3-22 wird dieser Zusammenhang deutlich mit den Intervallgrenzen [-2,0].

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

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

-4 -2 0 2 4 6 8 10
-10
0
10
20
30
40
50
f(x)=x
2
-5x-3
x-Werte
f
(
x
)
f(-2)>0
f(0)<0
f(-1)>0
gesuchte 1. Nullstelle
Bild 3-22 : Nullstellensuche durch lineare Interpolation

C++ Programming
WS 2010/11
Ist ( ) ( ) 0 f b f c > , 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>

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
WS 2010/11


C++ Programming
WS 2010/11
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
WS 2010/11
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.

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

( )
( )
1
1
0 1 1 0
1 1 0
( )
( ) ( )
( )
( )
Taylor
x
x
df x
f x f x x x
dx
f x
f x x x
x
= +
A
+
A
~
. (3-10)
Aus der numerischen Nherung lsst sich ein Schtzwert fr die Nullstelle x
0
berechnen:

1
0 1
1
( )
( )
f x
x x
f x
x
=
A
A
. (3-11)
Gleichung 3-11 wird nun sooft angewandt, bis der Abstand zwischen zwei Werten unterhalb
einer vorgegebenen Fehlergrenze c fllt:

1 i i
x x c
+
< . (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);
Bild 3-23 : Nullstellensuche nach dem Nherungsverfahren nach New-

C++ Programming
WS 2010/11
}

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

#include <iostream>
#include <cmath>
#include<cstdlib>
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);
};
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
}

C++ Programming
WS 2010/11

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
WS 2010/11


C++ Programming
WS 2010/11
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

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.

0 0.5 1 1.5 2 2.5 3 3.5 4
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
2.5
3
x
y
y=f(x)
X2
X1
Sprachsyntax von C/C++ Numerischen Lsung linearer Gleichungssysteme Seite 63/166

C++ Programming
WS 2010/11
2.15 Numerischen Lsung linearer Gleichungssysteme

Lineare Gleichungssysteme werden oft in Matrixschreibweise notiert:
A x b =

. (3-13)
Was ausgedrckt in den Komponenten A
ij
der Matrix A bedeutet:

1
N
ij j i
j
A x b
=
=
. (3-14)
Der Gauss'sche Eliminationsalgorithmus subtrahiert nun die Gleichungen

11 1 12 2 1 1
21 1 22 2 2 2
1 1 2 2
N N
N N
N N NN N N
a x a x a x b
a x a x a x b
a x a x a x b
+ + + =
+ + + =
+ + + =
(3-15)
so voneinander, dass ein quivalentes Gleichungssystem folgender Form entsteht:

11 1 12 2 1 1
(2) (2) (2)
22 2 2 2
(2) (2) (2)
2 2
N N
N N
N NN N N
a x a x a x b
a x a x b
a x a x b
+ + + =
+ + =
+ + =
(3-16)
Falls
11
0 a = ist, dann kann man Gl. (3-15) in Gl. (3-16) mit Zeilenoperationen berfhren:
neue Zeile j = alte Zeile j - l
j1
* alte Zeile 1, j= 2,3 N .
mit
1
1
11
j
j
a
l
a
= (3-17).

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

( )
( )
,
N
N
N N
N N
A x b =

. (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
( )
0
l
ii
a = fr l=1,2N. Sollte dies

C++ Programming
WS 2010/11
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.

Die Vorwrtselimination erzeugt die diagonale Matrix
( )
( )
,
N
N
N N
N N
A x b =

und die Rckwrt-
selimination berechnet mit dieser Matrix rckwrts den Lsungsvektor x
mit den Elementen

x
i
.

#include <iostream>
#include<cstdlib>
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
WS 2010/11
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
1 2 2
3 8 5
x
x
| | | | | |
=
| | |
\ . \ . \ .
?


C++ Programming
WS 2010/11


C++ Programming
WS 2010/11
- Erweitern Sie den Gausschen Algorithmus fr ein 3-dimensionales Problem:

1
2
3
3
1 2 3 2
.5 1.7 0 5
1 3
2 1.9
3
x
x
x
| |
|
| | | |
|
| |
=
|
| |
| | |

\ . \ .
|
\ .
.

Wie sieht der Lsungsvektor x
aus?
Sprachsyntax von C/C++ Klassen Seite 68/166

C++ Programming
WS 2010/11
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
WS 2010/11
#include <iostream>
#include<cstdlib>
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
WS 2010/11
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 ohne Parameter ist ein sog. Default-Konstruktor. Besitzt die Klasse keine
Konstruktor-Definition, so erzeugt der Compiler eine Minimalversion eines Default-
Konstruktors.
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.).

C++ Programming
WS 2010/11
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>

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
WS 2010/11

Sprachsyntax von C/C++ Konstante Elementfunktionen Seite 73/166

C++ Programming
WS 2010/11
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

Sprachsyntax von C/C++ Konstante Elementfunktionen Seite 74/166

C++ Programming
WS 2010/11
double get_laenge()const. // Berechnung der Vektorlnge
void einheitsVektor() // Definition eines Einheitsvektors
Sprachsyntax von C/C++ Externe Methodendefinition Seite 75/166

C++ Programming
WS 2010/11
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
Sprachsyntax von C/C++ Klassenkonstruktor Seite 76/166

C++ Programming
WS 2010/11
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.
Sprachsyntax von C/C++ berladen des Klassenkonstruktors Seite 77/166

C++ Programming
WS 2010/11
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;
Sprachsyntax von C/C++ Initialisierungslisten Seite 78/166

C++ Programming
WS 2010/11
}
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)
{
}
Sprachsyntax von C/C++ Initialisierungslisten Seite 79/166

C++ Programming
WS 2010/11
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.
Sprachsyntax von C/C++ Klassendestruktor Seite 80/166

C++ Programming
WS 2010/11
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
Sprachsyntax von C/C++ Klassendeklaration und Methodendefinition Seite 81/166

C++ Programming
WS 2010/11
{ 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
WS 2010/11
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
/* Implementierung (Definition) der
Klassenmethoden und Konstruktoren*/
// Konstruktoren
vektor::vektor()
{

C++ Programming
WS 2010/11
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;
};
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;
};
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
WS 2010/11
return (x * v2.y) - (y * v2.x);
};


C++ Programming
WS 2010/11
// Anwenderprogramm

#include <iostream>
#include<cmath>
#include<cstdlib>
#include"vektor.h" // Einbinden der Klasse
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
WS 2010/11
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>
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);
cout<< "Abstand 12 = "<<distance1<<\

C++ Programming
WS 2010/11
" Abstand 23 = "<<distance2<<endl;
distance1=P2.abstandPoint(P1);
distance2=P3.abstandPoint(P1);
cout<< "Abstand 21 = "<<distance1<<\
" Abstand 31 = "<<distance2<<endl;
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>
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
WS 2010/11
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
WS 2010/11


C++ Programming
WS 2010/11
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?

Sprachsyntax von C/C++ Vererbung Seite 91/166

C++ Programming
WS 2010/11
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>
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:
Sprachsyntax von C/C++ Vererbung Seite 92/166

C++ Programming
WS 2010/11
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.
Sprachsyntax von C/C++ Klassen als Datenelemente einer Klasse Seite 93/166

C++ Programming
WS 2010/11
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
WS 2010/11
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
WS 2010/11
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
WS 2010/11
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.

Sprachsyntax von C/C++ Strings Seite 97/166

C++ Programming
WS 2010/11
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
WS 2010/11
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
WS 2010/11
#include<iostream>
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
WS 2010/11
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>
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>
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
WS 2010/11


C++ Programming
WS 2010/11
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!

Sprachsyntax von C/C++ I/O-Stream-Klassen Seite 103/166

C++ Programming
WS 2010/11
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
WS 2010/11
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( )
{
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
WS 2010/11
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>

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
WS 2010/11
printf(" strtod = %f\n", x );
printf(" Stopped scan at: %s\n\n", stopstring );
string = "-10110134932This stopped it";
l = strtol( string, &stopstring, 10 );
printf(" strtol = %ld\n", l );
printf(" Stopped scan at: %s\n\n", stopstring );
string = "10110134932";
/* 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>
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
WS 2010/11
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
WS 2010/11
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>

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
WS 2010/11
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>
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
WS 2010/11
dat_ein.close();
fflush(stdin);
getchar();system ("PAUSE");
return 0; }

C++ Programming
WS 2010/11
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
WS 2010/11
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.

Sprachsyntax von C/C++ Benutzeroberflche von MATLAB Seite 113/166

C++ Programming
WS 2010/11
3.1 Benutzeroberflche von MATLAB
Bild 4.1 zeigt die Menoberflche von MATLAB nach Programmstart

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.1 : Erffnungsmen von MATLAB
Bild 4.2 :
MATLAB-
Hilfsfunktionen

C++ Programming
WS 2010/11
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).

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.3 : Hilfsdokumemtation fr functions
Bild 4.4 :
Hilfsdokumentation fr
die Sinus-Funktion

C++ Programming
WS 2010/11
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.
Sprachsyntax von C/C++ Elementare MATLAB-Operationen Seite 116/166

C++ Programming
WS 2010/11
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
WS 2010/11

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.

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 .
Bild 4.6 : Array-Editor

C++ Programming
WS 2010/11
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
WS 2010/11
>> 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

- 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

|
|
|
|
|
.
|
\
|
+
+
3 . 36 3 . 78 81 7 / 22
6 . 99 80 46 221
7 . 19 2 . 23 18 6 . 9 3 . 5
988 . 4 / 4 9 . 17 4 3 . 2 2 . 1
3
i
i

C++ Programming
WS 2010/11
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
WS 2010/11
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
WS 2010/11
1.0000 -0.5000


C++ Programming
WS 2010/11
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

- 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

B =

1.0000 0 1.0000
- 2.5000 2.0000 -4.5000
1.0000 2.0000 1.0000
A =

1 2 3
3 4 5
5 6 7

C++ Programming
WS 2010/11
3.2.4 Vektorarithmetik
3.2.4.1 Vektornorm

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

1
2 2
1
[ ]
n
n
x x x
x x x
=
= +
(4-1)
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.

-4
-2
0
2
4
0
1
2
3
4
0
1
2
3
F
1
F
2
G = m g
D
F
3
s
2
B
s
1
s
3
C
A
x
y
z
Bild 4-7 : Berechnung von Reaktionskrften

C++ Programming
WS 2010/11


C++ Programming
WS 2010/11
Bild 4-7 zeigt eine Trgerkonstruktion aus drei an einer Wand gelenkig gelagerten Stben s
1
,
s
2
, s
3
, an denen eine Masse m mit der Gewichtskraft von 100 N hngt. Es sollen die Reakti-
onskrfte
1 2 3
, f f und f

sowie die Betrge der Reaktionskrfte F
1
, F
2
und F
3
in den Stben
berechnet werden.
Aus dem Krftegleichgewicht kann man schreiben:

1 2 3
0
0 0
0 0
100
f f f g
mit g
G
+ + + =

= =

. (4-2)
Die Krfte F
1
, F
2
und F
3
sind Druckkrfte und wirken in Trgerrichtung. Man kann die Kraft-
vektoren
1 2 3
, f f und f

demzufolge proportional zu den Trgervektoren s
i
ansetzen:

1
1 1 1 1
2
2 2 2 2
3
3 3 3 3
3
4
0
3
4
0
0
4
3

= = =

= = =

= = =

s f AD
s f BD
s f DC
o o o
o o o
o o o
. (4-3)
Gl. (4-3) eingesetzt in Gl. (4-2) liefert dann ein Gleichungssystem fr die unbekannten o
i
:

1 1
1 2 3
2 2
3 3
3 3 0
4 4 4
0 0 3
S s s s g
o o
o o o
o o

= = =

. (4-4)
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]
S =
-3 3 0
4 4 4
0 0 3
>> Alpha=S^(-1)*(-g)
Alpha =
-16.6667
-16.6667
33.3333
>> Alpha=inv(S)*(-g)
Alpha =
-16.6667
-16.6667
33.3333
>> Alpha=S\(-g)
Alpha =
-16.6667
-16.6667
33.3333
oder

C++ Programming
WS 2010/11
>> f1=Alpha(1)*S(:,1)

C++ Programming
WS 2010/11
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:

1
1 1
cos( ( , )
n
i i
i
n n
a b a b a b a b
a b
mit und
a b
=
- = =

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

Der Winkel zwischen den beiden Vektoren ergibt sich zu:

C++ Programming
WS 2010/11
cos( ( , )
a b
a b
a b
-
=

X . (4-6)
>> 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

sin( ( , ))
c a b
c a b a b a b
=
= =

- - X
. (4-7)
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?

-3
-2
-1
0
1
2
3
0
1
2
3
4
5
0
6
12
18
24
r
f
P
0
P
1
P
2
m = f x r
-3
-2
-1
0
1
2
3
0
1
2
3
4
5
0
6
12
18
24
r
f
P
0
P
1
P
2
m = f x r
z
-
A
c
h
s
e
x-Achse
y-Achse
Kraft
Hebelarm
resultierendes
Drehmoment
Bild 4-8 :
Drehmomentberechnung

C++ Programming
WS 2010/11


C++ Programming
WS 2010/11
3.2.5 Polynome
3.2.5.1 Polynomdefinition

Polynome haben die allgemeine Form:

0
( )
n
i
i
i
P x a x
=
=
. (4-8)
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
WS 2010/11
bung: 4.2-5
- Berechnen Sie die Wurzel des Produktpolynoms

-

3.2.5.3 Polynomdivision

Die Quotient aus zwei Polynomen kann man darstellen als:

0
0
( ) ( )
( )
( ) ( )
m
i i
i
n
i i
i
a x
b y
Z x r x
q x c
N x N x
=
=
= = = +
. (4-9)
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
2
0
2 2 2
0
2 3 0.5 1
( ) 0.5
2 3 4 2 3 4
j
j
j
i
i
i
a x
x x x
z x
x x x x
b x
=
=
+ + +
= = = +
+ + + +

>> 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 0 c = . Mit anderen Werten erhlt
man z.B.
>> x=[1 2]
x =
1 2
>> [c,r]=deconv(x,y)
c =
0
r =
1 2
12 1 2
2 4 3
1 2
f (x) f (x) f (x) mit
f (x) 3x 5, f (x) 11x 8x 22
=
= + =

C++ Programming
WS 2010/11

Da x ein Polynom 1. und y ein Polynom 2. Grades ist, ergibt sich c zu 0 und man erhlt nur
den Rest
1
0
2 2
0
2
( )
2 3 4
i i
i
i i
i
a x
x
z x
x x
b y
=
=
+
= =
+ +
mit ( ) 2 r x x = +

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

0 0
0 0
m m
i
oi i
i i
n n
i
i oi
i i
x n a x
b x x p
= =
= =

=

I
I
. (4-10)
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

>> NNP1=roots(P1)
NNP1 =
3.0000
2.0000
1.0000
>> P2=poly(NP2)
P2 =
1 12 35
>> NNP2=roots(P2)
NNP2 =
-7
-5

>> [P,r]=deconv(P1,P2)
P =
1 -18
r =
0 0 192 624

3 2
0
2
0
2
6 11 6
( )
12 35
192 624
18
12 35
m
i
i
i
n
i
i
i
a x
x x x
P x
x x
b x
x
x
x x
=
=
+
= =
+ +
+
= +
+ +
2
1 ( 7)( 5)
12 35
P x x
x x
= + +
= + +
3 2
1 ( 1)( 2)( 3)
6 11 6
P x x x
x x x
=
= +

C++ Programming
WS 2010/11
bung: 4.2-6

- Bestimmen Sie die Nullstellen der Polynome f
1
und f
2
.
- Berechnen Sie den Polynomquotienten
1
2
( )
( )
( )
f x
y x
f x
= mit

1
2
( ) ( 1) ( 2) ( 3) ( 4)
( ) ( 1) ( 2) ( 3) ( 4)
=
= + + + +
f x x x x x und
f x x x x x

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:

>> 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:
Bild 4.9 : Fenster der MATLAB-Hilfe

C++ Programming
WS 2010/11
>> 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

zu den normierten Zeitpunkten 0 bis 5 in Schritten von 0.1 .

t
e t t t y
* 5 . 0
* ) * 3 * * 2 cos( * ) * 5 * * 2 sin( ) (

= t t

C++ Programming
WS 2010/11
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
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

Bild 4.10 : Plotergebnis aus MATLAB

C++ Programming
WS 2010/11

C++ Programming
WS 2010/11
>> 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.

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.11 :
3D-Plot mit dem
mesh-Befehl
Bild 4.12 :
3D-Plot der Funkton
peaks

C++ Programming
WS 2010/11

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

surf(fkt)

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-
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.13 .
Plotten mit
dem
surf-Befehl
Bild 4.14 : 2D-Hhenlinien
Bild 4.15 : 3D-Hhenlinien Plot
Sprachsyntax von C/C++ Symbolic Toolbox Seite 140/166

C++ Programming
WS 2010/11
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 2
* ) * sin( *
y x
e y x x z
+
= 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
WS 2010/11
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
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
WS 2010/11
>> 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
WS 2010/11
-(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 =

a: [4x1 sym]
u: [4x1 sym]
v: [4x1 sym]

Zur weiteren Vertiefung der Benutzung der Symbolic Toolbox soll nun folgendes Beispiel
dienen.
Der Effektivwert einer elektrischen Spannung ist definiert durch :

=
T
eff
dt t u
T
U
0
2
) (
1
. (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 =
mit
A .a =
[ 2]
[ 2]
[ 3]
[ 3]
A .u =
[ 1/3+1/3*i*2^(1/2)]
[ 1/3-1/3*i*2^(1/2)]
[ 1/4+1/4*i*3^(1/2)]
[ 1/4-1/4*i*3^(1/2)]
A .v =
[ -2/3+1/3*i*2^(1/2)]
[ -2/3-1/3*i*2^(1/2)]
[ -3/4+1/4*i*3^(1/2)]
[ -3/4-1/4*i*3^(1/2)]
Sprachsyntax von C/C++ MATLAB-Programmierung Seite 144/166

C++ Programming
WS 2010/11

0.7071

bung: 4.3-1

Berechnen Sie das Integral der Funktion

2
* 5 . 0 ) sin( ) (
2 x
e x x f

+ =

symbolisch im Interval [-x
0
,x
0
]. Weisen Sie anschlieend einer Variablen den Wert des be-
stimmten Integrals fr x
0
=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.

Bild 4.16 :Editorfenster fr m-File

C++ Programming
WS 2010/11

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 =

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.
Abarbeitung
des m-Files

C++ Programming
WS 2010/11
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
WS 2010/11
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
* 5 . 0 ) sin( ) (
2 x
e x x f

+ =
symbolisch im Interval [-x
0
,+x
0
] und weisen Sie danach einer numerischen
Variablen den Wert des bestimmten Integrals fr x
0
= 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:

)) ( sin( * ) ( t
L
g
t o o =
- -

mit g=9,81 m/sec2 .

(4-12)
Zur Lsung der DGL 2. Ordnung sind zwei Anfangsbedingungen ntig.
Es sei:
0 ) 0 ( ) 0 ( = =
-
o o (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
WS 2010/11

) ( ) (
) ( ) (
.
2
1
t t
t t
-
=
=
o o
o o
(4-14)
Damit lsst sich fr die DGL schreiben:
|
|
.
|
\
|
=
|
|
.
|
\
|
-
-
) ( sin( *
) (
) (
1
2
2
1
t
L
g
t
t
o
o
o
o
mit der Anfangsbedingung :
0
) 0 (
) 0 (
2
1

=
|
|
.
|
\
|
o
o

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
WS 2010/11

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 u
a
(t) bei
einer Erregung mit dem Einheitssprung (t) fr die Zeitkonstante sec 1 * m C R = = t .

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:

t A x cos * = (4-15)
t A y sin * = (4-16)
t z = , normiertes Zeitintervall [0 , 8*t] (4-17)

Im Falle der Oszillation in z-Richtung ergibt sich fr die z-Auslenkung:
)) 1 ( cos( * 1 ( * + = T B t z e (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
u
a
(t) (t)
R
C
Bild 4.18 : RC-Tiefpass

C++ Programming
WS 2010/11
-1
-0.5
0
0.5
1
-1
-0.5
0
0.5
1
0
10
20
30
40
50
60
Bild 4.19 :
Plot der Schraubenfederoszillation
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.

Sprachsyntax von C/C++ Simulink-Toolboxen Seite 151/166

C++ Programming
WS 2010/11
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).

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.20 :
Pop-Up Fenster
von Simulink
Bild 4.21 : Bibliothek mathematischer
Elemente von Simulink
Bild 4.22 :
Simulation (Berech-
nung) des Integrals
einer Sinusfunktion

C++ Programming
WS 2010/11

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).

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.

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.23 : Parametermen der Sinus-
Schwingung
Bild 4.24 : Simulationsparameter
Bild 4.25 : Simulationsergebnis Sinus-Integral

C++ Programming
WS 2010/11
Bild 4.27 :
Simulink-Model zur
Lsung des Differen-
tialgleichungssystems 1.
Ordnung nach Gl. 4-19
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

TestSignal 1001x3 24024 double array
tout 1000x1 8000 double array

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:

1 2 1
1 2 2
y (t) 3 y (t) 2 y (t)
y (t) 4 y (t) 2 y (t)
-
-
= - -
= - + -
mit den Anfangsbedingungen

1
2
y (0) 1
y (0) 1
=
=
. (4-19)
In Bild 4.27 ist das entsprechende Model zur Lsung von y
1
(t) und y
2
(t) dargestellt.

Bild 4.26 : Scope-Parameter und MATLAB-
Variable

C++ Programming
WS 2010/11


C++ Programming
WS 2010/11
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).

Das Differentialgleichungssystem nach Gl. 4-19 ist
aber auch geschlossen lsbar in MATLAB. Dazu
werden folgende Kommandos eingegeben:

>> 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 ))
>>

Bild 4. 29 : Workspace von MATLAB mit den Simula-
tionslsungswerten
Bild 4.28 : Graphische Anzeige
der Simulationsergebnisse

C++ Programming
WS 2010/11
Im Workspace sind nun nach der analytischen und numerischen Berechnung folgende Werte
vorhanden:

>> whos


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


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.31 : Starke Vergrerung des Plots
in Bild 4.30
Bild 4.32 : Plot Properties zu Bild 4.29

C++ Programming
WS 2010/11
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 U
A
stellt die Eingangsgre dar, die Zeitkonstante
T
A
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 U
A
ein inneres Moment M
Mi
, das die Maschine
gegen das Widerstandsmoment M
W
antreibt. Es resultiert eine Vernderung der Drehzahl
(Winkelbeschleunigung), die integriert die Drehzahl N ergibt.

Die bertragung des Models in ein Simulink-Model zeigt Bild 4.34 .

Bild 4.34 : Simulink-Model der fremderregten GL-Motors
Bild 4.33 : Blockschaltbid der fremderregten Gleichstrom-

C++ Programming
WS 2010/11
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).

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.35 : Simulationsparame-
ter fr die fremderregte GM
Bild 4.36 : LTIU-Viewer
Darstellung der
Sprungantwort der
fremderregten GM

C++ Programming
WS 2010/11
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.
Sprachsyntax von C/C++ Anhang MATLAB Funktionen Seite 160/166

C++ Programming
WS 2010/11
3.6 Anhang MATLAB Funktionen

3.6.1 Steuerfunktionen fr MATLAB:


C++ Programming
WS 2010/11


C++ Programming
WS 2010/11
3.6.2 Mathematische Funktionen


C++ Programming
WS 2010/11

Literaturverzeichnis Seite - 1 -

C++ Programming
WS 2010/11
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,
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
WS 2010/11

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,

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
WS 2010/11
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++ - Vgu 2010-11

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

C++ - Vgu 2010-11

Transféré par

Droits d'auteur :

Formats disponibles

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

mit den Elementen

aus Bild 4-8.

Vous aimerez peut-être aussi