Meine Informatik II Zusammenfassung ()

Zusammenfassung – C++
1
Programmaufbau
Importliste: #include<iostream.h> bzw.:
#include<iostream>
using namespace std;
Programmteil: void main (void) { Anweisungsfolge }
2
Variablen und Konstanten
2.1
Variablendeklaration und -initialisierung
double v, t, s;
int j, k = 2; f = 0;
char c = ’abc’ ; [Achtung: “abc“ geht nicht!!]
2.2
Variablentypen:
int
Ganzzahl (im 32-Bit-System: -231 – 231)
float
Gleitkommazahl 4 Byte
double Gleitkommazahl 8 Byte
char
1 Zeichen, Bsp.: ’A’ + 10 = ’J’
bool
true / false, 1/0
3
Operatoren
3.1
Typen von Operatoren
3.1.1 Binäre Operatoren
+ , - , * , / , % (Rest der Division)
3.1.2 Unäre Operatoren
i++ (i = i + 1) , i-- (i = i - 1)
3.1.3 Logische Verknüpfungen
&& (logisches UND), || (ODER), ! (NEGATION)
3.1.4 Vergleichsoperatoren:
< , > , <= , >= , == , != (ungleich)
3.2
Abkürzende Schreibweisen
i += 5 :
i=i +5
x = y * (i++) : x = y * i; i++ ;
x = y * (++i) : i++ ; x = y * i;
a = *(p++) :
a = *p ; p++ ; (Alternative: *p++)
a = *(++p) :
p++ ; a = *p ; (Alternative: *++p)
a = (*p)++ :
a = *p ; (*p)++ ;
a = ++(*p) :
(*p)++; a = *p ; (Alternative: ++*p)
6
Funktionen
6.1
Normale Funktionen, Deklaration, Aufruf
Definition (Implementierung):
int MyFunkt (int i, int k, bool s) { .. return a; };
Prozeduren sind Funktionen mit Rückgabetyp void.
Funktion kann als Rückgabetyp auch eine Referenz haben: int
&MyFunkt (int i, int k, bool s) { ... };
6.2
Call by Value / Call by Reference
Call by Value: int MyFkt (int i, int k) { … };
 Veränderungen an den übergebenen Parametern im
Funktionsrumpf wirken sich nicht nach außen aus!
Call by Reference: int MyFkt (int &i, int &k) { … };
 Veränderungen an den übergebenen Parametern im
Funktionsrumpf wirken sich nach außen aus!
6.3
Überladen von Funktionen (function overloading)
Function overloading: Eine Funktion kann mehrmals mit
verschiedenen Parameterlisten deklariert und definiert werden.
Beim Aufruf wird je nach übergebener Parameterliste die
entsprechende Definition ausgewählt.
6.4
Generische (generic) Funktionen
Eine Funktion für beliebige Datentypen:
template <class Type_x>
void MyFkt (int i, Type_x a) { … };
oder
template <class Type_x, class Type_y>
Type_x MyFkt (Type_x a, Type_y b) { … }
Je nachdem, mit welchen Datentypen die Funktion aufgerufen
wird, werden entsprechende spezifische Instanzen der
Funktion vom Compiler (erst dann) erzeugt. Generische
Funktionen funktionieren auch für (eigene) Datentypen, die erst
später definiert werden.
6.5
Rekursion
Funktionen können sich auch selbst wieder aufrufen. Dabei ist
eine Abbruchbedingung nötig.
int FFakultaet (int n) { if (n == 0) return 1;
return n * FFakultaet ( n – 1 ); }
7
Referenzen und Pointer
7.1
Referenzen
Referenzen sind andere Namen für ein und dasselbe Objekt.
Eine Referenz verweist auf dieselbe Speicherzelle wie der
4.1
If-Anweisung
if (Bedingung ) { Anweisungsblock } else { Anweisungsblock } ursprüngliche Name und kann deshalb als Synonym verwendet
werden. Referenzen sind nicht dynamisch.
4.2
Switch-Anweisung
Referenzen müssen bei der Deklarat. initialisiert werden.
switch ( Ausdruck ) {
int n;
case Wert1 : Anweisung1; break;
int& r = n ; oder int &r = n ;
case Wert2 : Anweisung2; break;
7.2
Pointer
default : Anweisung-Sonst; }
In einem Pointer auf einen Datentyp kann die Adresse einer
4.3
Schleifen
Speicherzelle dieses Datentyps gespeichert werden.
for ( Initialisierung ; Bedingung ; Anhang ) Anweisungsblock ; Pointer sind dynamisch, d.h. man kann die zugewiesene
Bsp.: for (int i = 0 ; i < 5 ; i++) { cout << i << endl; }
Adresse ändern und eine Initialisierung ist nicht nötig.
while ( Bedingung ) Anweisungslock ;
int* p; oder int *p;
do Anweisungsblock while ( Bedingung ) ;
p hat jetzt den Typ „Pointer auf den Basistyp int“.
break
verlässt die (innerste) Schleife unmittelbar.
Null-Pointer: int* p = NULL;
4
Kontrollstrukturen
7.3
Zugriff auf Daten und Adressen mit Pointern
Zugriff auf den Inhalt einer Adresse (Dereferenzierung):
5.1
Arrays
*p , also i = *p; oder auch *p = i;
int a[3] = {1,2,3,4}; const : Array von 0 bis const –1.
Jetzt bekommt i den Wert der Zellen, auf die p verweist bzw.
umgekehrt.
5.2
Structs (Eigene Typen)
Def eines Struct:struct Punkt { int x , y ; double Farbe } ; Zugriff auf Adresse einer Variablen:
&x , also int* p = &x;
(Wichtig : “;” am Ende, sonst Fehler im Folgenden!!!)
Definition und Deklaration zusammen:
Dem Pointer p wird die Adresse von x zugewiesen.
struct Punkt { int x, y ; double Farbe } p,q;
Einfache Schreibweise (*p).next entspr. p->next (p=Pointer)
Zugriff : p.x = 3 ; p.Farbe = 0.4532 ;
Call by reference über Pointer:void Funktion (int* x) { …}
1
5
Abgeleitete Typen
Methoden können und werden meist innerhalb der
Klassendeklaration nur als Signatur deklariert und außerhalb
mittels des Scope-Operators :: definiert.
Innerhalb dieser Definition kann auch auf private-Elemente
zugegriffen werden.
Konstruktoren sind Methoden in der Elementliste mit
gleichem Namen wie die Klasse. Sie werden bei Deklaration
7.4
Arrays als Pointer:
einer Instanz der Klasse aufgerufen. Es sind mehrere
Alle Arrays sind nur Pointer:p[6] heißt: *( p + 6 )
Konstruktoren möglich. (Overloading, d.h. gleiche Namen, aber
int a[10]; Deklariert a als Pointer und reserviert die 10
unterschiedliche Parameterlisten)
folgenden Speicherplätze.
Konstruktoren müssen im public-Bereich stehen!
Der Destruktor ~MyClass ( ) {...}; wird am Ende des
8 Dynamische Speicherbehandlung
Gültigkeitsbereiches (oder beim Löschen mit delete) einer
Instanz aufgerufen.
8.1
New- und Delete-Operatoren
Copy-Konstruktor ermöglicht tiefe Kopien bei Initialisierung.
Speicher allozieren:
Deklaration in der Klasse:
new Typ [n] belegt (alloziert) n Speicherzellen (d.h. ein
Array) für eine Variable des Typs Typ und liefert einen Pointer Klassenname (const Klassenname &);
„Konstante“ Member-Funktionen:
auf die erste Zelle zurück:
int MyClass::MyFkt (bool k) const { … };
int* p = new int[10];
Die Variablen der Klasse können so im Funktionsrumpf nicht
int* p = new int; (belegt nur eine Speicherzelle)
Mit if-Abfrage überprüfen: (ob genug Platz, sonst Null-Pointer) verändert werden.
p = new int(10); if (!p) { cout << “no memory”; }
9.2
Vererbung (inheritance), Sub-/ Baseclasses:
Direkte Initialisierung:
Eine Basisklasse (baseclass) kann ihre members an eine
p = new int(10); heißt: p = new int; *p = 10;
abgeleitete Klasse (subclass) vererben. Jedes Objekt einer
Speicher freigeben:
abgeleiteten Klasse kann wie ein Objekt der zugehörigen
delete p;
Gibt die zu p gehörige Speicherzelle wieder frei. Basisklasse behandelt werden.
delete [ ] p; Gibt die zu p gehörige und alle mit ihr
Deklaration einer abgeleiteten Klasse:
zusammen dynamisch allozierten Speicherzellen class MySubclass : public MyBaseclass {
wieder frei.
private:
Mit delete dürfen nur Pointer gelöscht werden, die vorher
int c, d ;
auch dynamisch mit new angelegt wurden!
public:
Klassen-Instanzen dynamisch anlegen:
MyBaseclass ( ) : c(0), d(0) { }; //Default-Konstr.
p = new MyClass(Konstruktor-Argumente);
// Zugriff auf Basiskonstruktor im Konstruktor:
Beim Löschen mit delete wird der Destruktor aufgerufen.
MySubclass (int n) : MyBaseclass (n) , c(0) { … };
// Zugriff auf member function der Basisklasse:
8.2
Beispiel: Listen, Suchbäume
void MySubFkt ( ) {
Verkettete Listen
c = 1; ...
struct SElement (double Eintrag; SElement *PNext;);
...
MyBaseclass
:: MyBaseFkt( ); ... };
Binäre Suchbäume
}
;
struct SElement (double Eintrag; SElement *PLeft,
(Wichtig : “;” am Ende, sonst Fehler im Folgenden!!!)
*PRight;);
Ein Subclass kann nicht auf die private –members ihrer
Baseclass zugreifen.
9 Klassen
Existiert in Basis- und Subklasse eine Funktion mit identischer
9.1
Deklaration
Deklaration (Name und Parameterliste), so wird bei Aufruf
class MyClass {
dieser Funktion aus der Subklasse (sub_obj . fkt( );) die
private:
Implementierung aus der Subklasse verwendet!
int i;
//private Variablen..
Die entsprechende Implementierung aus der Basisklasse kann
bool b;
explizit wie folgt aufgerufen werden:
public:
sub_obj . MyBaseclass :: fkt( );
MyClass( );
//Default-Konstruktor
9.3
Base-Class-Pointers
MyClass(int j) ;
//Weiterer Konstruktor
Ein Base class pointer ist ein Pointer auf eine Basisklasse.
//Konstruktor mit direkter Initialisierung:
Deklaration: MyBaseclass *p;
MyClass(int j, bool k) : i(j), b(k) { } ;
Base class pointer kann zeigen auf:
~MyClass( );
//Destruktor
a) Objekte der Basisklasse
void Show_I( ) ;
//Public Member-Fkt.
b) Objekte von abgeleiteten Klassen
int MyFkt (bool) ;
// …
Bei abgeleiteten Klassen kann über den Base class pointer nur
protected: (hier nicht)
auf aus der Basisklasse vererbte Elemente zugegriffen
};
werden, nicht auf solche, die für die abgeleitete Klasse
(Wichtig : “;” am Ende, sonst Fehler im Folgenden!!!)
spezifisch sind.
//Definitionen:
MyClass :: MyClass( ) { i = 0; b = true; } ;
9.4
Virtuelle Funktionen, abstrakte Basisklassen
…
9.4.1 Virtual functions – polymorphic classes
MyClass :: ~MyClass( ) { delete i; } ; (hier eig. Unnötig)
Ist eine Fkt in der Basisklasse als virtuell deklariert, so kann
...
jede abgeleitete Klasse ihre eigene Implementierung (mit
int MyClass :: MyFkt (bool k) { ... return a; } ;
exakt der gleichen Deklaration, d.h. Name und
Methoden (members):Variablen (data members) und
Parameterliste) dieser Fkt haben. Dies heißt overriding.
Elementfunktionen (member functions) der Klasse
Basisklassen, die virt Fkten enthalten, und deren Subklassen
Instanz ist Variable eines Klassentyps
heißen polymorphic.
Es wird ein Pointer als Parameter übergeben. (Wichtig bei
Funktionsaufruf: Pointer und nicht Wert übergeben.)
Zugriff auf den Wert von x im Rumpf: *x
7.3.1 Beispiele
int i = *p ; int* p = &x;
(*p)++;
(Verändert den Inhalt der Zelle, auf die p verweist.)
2
Deklaration in Basisklasse:
virtual void Fkt ( ) { Deklaration in Basisklasse };
Deklaration in abgeleiteter Klasse:
void Fkt ( ) { Deklaration in Subklasse }; //ohne virtual
Anwendung: Werden virtuelle Funktionen durch Base class
pointer aufgerufen, so wird immer die Implementierung der
Subklasse verwendet, auf die der Base class pointer zeigt.
Eigenschaften:
- Virtuelle Funktionen müssen Methoden einer Klasse sein,
d.h. sie können nicht einzeln stehen.
- Damit die Funktion virtuell bleibt, muss in der Subklasse
die identische Deklaration vorliegen.
9.4.2 Pure virtual functions – abstract base classes
Pure virtual functions sind virtuelle Funktionen, die keine
Definition in der Basisklasse haben. Alle abgeleiteten
Funktionen müssen eine Implementierung dieser Funktionen
enthalten. (Sonst kein Kompilieren)
Basisklassen, die pure virtual functions enthalten, heißen
abstrakte Basisklassen.
Deklaration in Basisklasse: virtual void fkt ( ) = 0 ;
10 Exception handeling
Code-Teile, in denen Laufzeitfehler auftreten könnten, können
in einem try-Block überwacht werden. Tritt eine exception
auf, so wird diese per throw an einen folgenden catch-Block
übergeben, wo sie entsprechend behandelt wird.
try {
//Block, z.B. main, oder nur ein Teil
...
throw 33 ;}
catch (double d) { … }
catch (int i) {
cout << „Fehler Nr.“ << i ; }
catch (...) { ... }
// universeller catch-Block
Vorlesungsstoff
1
Computer
!!! 8bits = 1byte !!!
Computer: Control, Datapath, Memory, In- und Output
MIPS
Register/word: 32 bits, MIPS-Prozessor: 32 register
Bsp: add $s1,$s2,s$2
9.5
Generische Klassen
sub, lw, sw, beq, bne,
Generische Klassen können für ihre data members und
lb(load byte), sb (store),
member functions variable Datentypen verwenden.
lui (load upper imm.), slt
Deklaration:
template<class Typ_x, class Typ_y> class MyClass { … }; (set less than), slti, j, jr
(jump register),jal(&link)
Instantiierung: MyClass <int , double> obj_myclass ;
 Die Deklaration einer generischen Klasse kann nicht wie
üblich von der Implementation getrennt werden. (.c& .h Files)
Bei Funktionendeklaration außerhalb des Klassenrumpfes:
MyClass<Typ_x> :: MyFkt( ) { … };
9.6
Operator overloading
Operator overloading passt Operatoren für eigene Klassen
an. Die ursprüngliche Bedeutung wird nicht verändert.
Deklaration in der Klasse:
MyClass operator+ (MyClass c); oder
int operator< (MyClass c);
Definition außerhalb der Klasse:
MyClass MyClass :: operator+ (MyClass c) { … } ;
9.6.1 Beispiele von überladenen Operatoren
MyClass MyClass :: operator- (MyClass c) {
MyClass temp;
//Damit kein Argument überschrieben wird.
temp.x = c.x ; temp.y = c.y ; return temp; }
 MyClass MyClass :: operator= (MyClass c) {
x = c.x; y = c.y; return *this ; }
 MyClass MyClass :: operator++ ( ) {
x += 1; y += 1; return *this ; }
 MyClass MyClass :: operator++ ( int not_used ) {
MyClass temp = *this ;
x += 1; y += 1; return temp ; }
 MyClass MyClass :: operator== (MyClass c ) {
if (x == c.x && y == c.y ) return 1 ;
else return 0 ;
 MyClass MyClass :: operator++ ( int not_used ) {
MyClass temp = *this ;
x += 1; y += 1; return temp ; }
Zu generischer Klasse:
template <class Typ> class MyArray {
Typ a[SIZE] ;
… Typ &operator[] (int i) ; … }
Typ &MyArray<Typ> :: operator[] (int i) {
// Index check …
return a[i] ; }
op:opcode:Basic Opertion
rs:erste Register Quelle
rt: zweite Register Quelle
rd: Register Ziel, shamt: Buchstaben,Zahlen (shift ammount)
High level language program (in C) -> Compiler -> Assembly
lang. Program (MIPS) -> Assembler -> binary machine lang
1
Arithmetic for Computers
Two Components
000=0 001=1 010=2 011=3 100=-4 101=-3 110=-2 111=-1
Keine doppelte Null, somit am geeignetesten! -> viel gebraucht
Maximal: 2,147,483,647 dezimal Minimal: -2,147,483,648
16 -> 32 bits: 0010 -> 0000 0010, 1010 -> 1111 1010
Multiply:
Overflow: Bsp: 5 + 1 = 6
dezimal, binär = -6!
0111 + 0001 = 1000 = -6
Floating Point
(1) sign  1  significan d  2exp onentbias
bias = 127 / 1023
single precision: 8, 23(+1sign), 127 bit. double:11, 52, 1023
Bsp: -.75 = 1 0111 1110 1000 0000 0000 0000 0000 000
Boolean
AND, OR, INVERT:
3
(NAND, NOR)
Multiplexer MUX
2
Finite State Machine (FSM)
Principe of Universality: wir wissen alles über A, B kann alles
machen was A auch kann, NUR Status von A beschreiben
FSM: endlos langer Papiersteifen mit Lese- und Schreib-Nadel
Limite: unbeschränkte Klammern&Multiplizieren(zuwenig save)
Turing Machine: Mathematiker mit unlimitierter FSM im Kopf
Computability = Turing compatable: effektive Prozedur um
etw zu berechnen zu finden, entspr. TM finden,die Problem löst
FSMvsTM:endlicher Speicher vs move left&right, zurückgreifen
3
Coding und Informationstheorie
Shannon’s Theorem

M
1
1 

 1   q  log 2 ( )  (1  q)  log 2 (
)
N
q
1

q 

Gegen ½ wir wissen nichts! Gg 1 alles falsch, gg 0 alles richtig
Entropie, durchschn. Information:

H ( X )  i pi log 2 pi 
 E ( X )   n  pn p…Wahrsch.keit
n 1
Präfix Code: keine
Trennstriche zw. 2
Farben, keine
Verwechslungen
Erwartete Codelänge:
Kraftsche Ungleichung:
Informationsmass: L   pi log 2 pi
Huffman Coding (Iterative Prozedur)
die beiden untersten sind gleich
lang und unterscheiden sich nur in
1 Ziffer. Verbindunsstriche:
unterer jeweils 1, oberer 0, von rechts nach links gelesen
Information
Informations-Inhalt:
Durchschn. Info:
Info pro Symbol:
4
Netzwerke
N Symbole, n mögl msg
3.Vermittlungsschicht: IP (Internet Protocol), Verantw. Für
Datenübertragung über weite Strecken
4.Transportschicht:
TCP (Transmission Control Protocol), schaut kein Datenverlust
und kein Durcheinander
Sockets: IP und Port, Verbindungsendpkte (Sender/Empf)
Flusskontrolle: verlust von Paketen, weil schneller senden als
empfangen -> definierte Regeln, wann nächstes senden
Stop-and-wait Protokoll: langsam, da immer auf
acknowledgements gewartet wird.
Sliding-Window Protokoll: schneller, buffer noch besser
UDP (User Datagram Protocol), verbindungslos, ohne
Rückmeld. ungesichertes Protokoll, kurze Ladezeit (bspVideo)
5.Anwendungsschicht: ftp (file transfer protocol), telnet,
remote, login, DNS (domain name service), SMTP (mail), http
(hyper text transfer protocol)
SSH: Secure shell: protocol, das uid und pw aud anderem
Rechner erlaubt. 1.ssh Daemon macht Softwareupdate
2.Sitzungsschlüssel wird vereinbart 3.private host key zur
Antschlüsselung 4.Authentifizierung des users
Pakete
Paketgrösse: TCP/IP < 64 kB, Ethernet 1,5 kB
IP Adresse, Netzmaske …
IPv4: 32 bit Adresse für jeden Computer, resp. 4 byte (2^32)
IPv6: 128 bit, resp. 16 byte (2^128^=10^38)
Bsp: 192.168.0.20 = 11000000 10101000 00000000 00010100
Firewall:Paketfilter basiert auf Protocol, Port, IP-Adresse
MAC-Adresse: 48 bit, vom Hersteller zufällig zugewiesen
Netzmaske: IP-Adresse und Nm binär zusammenrechnen und
mit anderer Summe vergleichen -> gleiches Netz, sonst Router
DNS: (Domain Name Server) .ch -> Top-Level Domain
5
Routing
Find kürzesten Weg: Dijkastra’s algorithm
Beweis:
6
Kryptologie
Unkeyed (oneway, keine geheimen Schlüssel, hash
functions: einfach berechenbar, jedoch schwierig gleich Fkt
finden)
Secret-Key(symm.Krypto. Diffie Hellman key protocol: 1.A:
Q= Eb(p)->B 2. B: Db(Q)=Db(Eb(p))=P)
Schichtenmodell
Kommunikation: real nur
zw.1.Schichten, sonst virtuell
Protokolle: zur Def. der Form und
Art der Kommunikation, Regeln
nach denen peers kommunizieren
Vertikale K: Austausch Services
Public-Key (asym. Krypto, RSA)
1.Bitübertragungschicht: Übertragungskapazität, Transferzeit
der Übertragung: Übertragungs- und Signallaufzeit
2.Sicherungsschicht: Zugriffsverfahren: wer wann senden,
Fehlerfreie Übertragung
(Fehlerkorrektur), NUR
(n)  z  ( p  1)( q  1)
Korrektheit, nicht um
RSA: Phi(x) = Teilerfremde Zahlen Bsp: phi(4)=1,3=2
Datenverlust besorgt
Euler-Formel: a  ( n )  1 mod n
4