C++ zusammenfassung - Cheatsheet für Klausuren PDF

Preview

Summary

Cheatsheet für Klausuren...

Description

C++ZUSAMMENFASSUNG ChristianForster,28.August2007 [email protected] 

AUFBAUEINESPROGRAMMS #include #include Using namespace std; //stucts, functions, enums int main(void) { system(“pause”); return 0;

= ||   &&   ==   !=   !

grösser,grössergleich,kleiner “oder”    “und”  “gleichheit” “ungleich” “nicht”

EINGABE&AUSGABE

\n \t \”

VARIABELN

13 6 3 1 0

int a; int b = 10; float c = a*b – 0.5; CASTS

//Ausgabe //Eingabe

Zeilenende horizontaler Tabulator Anführungszeichen

UMRECHNUNGBINÄR–DEZIMAL

EINFACHEVARIABELN DEKLARIEREN

1 0 1 1 

Dezimalzahldurch2teilenundRest notieren.Bitsvonuntennachoben lesen. Bsp:13=1101

ÄnderungeinerVariableineinenanderenTypen. double a = 1.5; b = int (a); b = (int) a;

int b; // b=1

Beiint a[ N];mussNa alsconst i nt N = 10; B N definn iertwerden. Eineconst intkannwä hrenddem Prog grammablaufnichtgeändertwerden. r EinArraybeg E inntimmerm ita[0]unde ndetmita[N‐ n 1 1] 

Ü bergibtmaneinArrayeinee rFunktion,s si tdaswie“Caall Ü byReference”.DaasOriginal‐Arrraywirdverän n dert. ARR AYSUNDP OINTER BeiderDefinitionneinesArrayswirdSpeiche rplatzfüreinee bestimmteAnzah lObjektereseerviert.DieArr rayvariable zeigtaufdasersteeObjektdieseesSpeicherplatzes. a Daru umsindfolge ndeAusdrücke n e identisch: 

int c[10]; int* pc; pc = c;

/ /Array definieren //Pointer definieren //Pointer zeigt auf Array

1001=1*23+0*22+0*21+0*20=8+0+0+1=9

pc[3] = 10; ↔ c [3]=1 0; ↔ * (p p c+3)=10;

KONTROLLSTRUKTUREN

Folge ndesgenerieertaucheinArraymitPlatzfür3Integer :

ErrmöglichenAuu fspaltungdessProgramms in Un nterprogramm m e. 

Au ufbau:rückg gabewert funktionsn f name (a argument) {funktion n skörper} DeerRückgabew w ertistimmerrnur1Elemenntundkannvon beeliebigemTyp sein.Falls dieeFunktionkeineRückgabehat, void. s chreibtman c 

DerFunkti onsnamedarf nichtmiteinee rZahlbeginnnen. 

NureinWe rtalsRückgab b ewert.Workaa round:Struccts IN NITIALISIEREE N Mankanneine Funktiondekklarierenunderstspäter M e au usführen. 

in nt dividie ren(int, int); CA ALLBYVALU U E WenneineFunktionaufgeruufenwird,war denbycall‐byy ‐ W value a dieArgum m enteaufden n Stackkopier t. 

vo oid foo(inn t a) { a= 10; } ndere,bleibtsie Au uchwennich ainnerhalb derFunktionä d au usserhalbnoc hgleich.



IF if(a == 10) { b=15; } else b=10; oderkurz:a == 10 ? b=15 : b=10; eineweitereBedingungmit else if() { }

for(int i=1; iString float Kommazahlen32bit,Eingabe:3.0f double Kommazahlen64bit,Eingabe:3.0 short .. ..(int/double)mit16bit(ohne..‐>int) long .. ..mit32bit(Systemabhängig) unsigned .. ..mitnurpositiveZahlen bool  Wahrheitswerte(true/1,false/0)

ARR R AYS

LOGISCHEKONSTRUKTE

mathematischeOperatoren ganzzahligerResteinerDivision15%6==3 x = x + i; ebenso *=, /=, -= =1.1*10‐5 erhöht/verkleinertium1



b=5;c=b++;→c=5,b=6verwende++bfürc=6,b=6 

FürweiteremathematischeFunktionen: #include fabs(), sqrt(), exp(), log(), cos(), acos()

while(b < 20){ b++; } 

oder

Varia belndirektm m itstructddeklarieren: struct point { … } p, q; //er setzt point p, q; Zuwe isung: p=q istgleichbe deutendmit d pp.x=q.x; p.y=q.y; p.c olor = q.color;



Au ufruf: foo(p p a);wennp aeinPointer istoder fo oo(&a); wennakeinPo interist. 

Mannkannauc heinerFunkttioneinenderreferenzierten M n Po ointerüberge ben: vo oid foo(in n t a) { a= = 10; }

do { b--; } while(b != 15);

FUN KTIONENINNSTRUC TS

Au ufruf: foo(* * pa); Dasw w irktdannaberwiecall‐by ‐ value. a

DieK K onstruktor‐FunktionwirdbeiderGenerr ierungeines neue e nStructsaufgerufen.

REEKURSION 





abbrechenmitbreak;ÜberspringendesRestsdes RumpfeszurnächstenAuswärtungmitcontinue;

struct Bar { Bar() { // Konstruktor };

SWITCH switch(a) { case 15: //a==15 cout A(ausASCIITabelle)

text[i] (int) text[i]



liestn‐1ZeichenvonderTastaturinstr[]undhängt“\0” an:void cin.getline(char str[], int n);

struct element { int key; list* next; }; 

DerZeigeramEndederListeisteinNull‐Pointer. myLastElement->next=0; NEUELISTE Pointer root istdasersteListenelement. 

element* root = new element; root->key = 1; root->next = NULL; NEUERKNOTEN AMENDE RekursiveFunktion.DabeisollkeinneuerPointererstellt werdensonderndernvonrootausgegabenwerden.Darum *&call‐by‐reference. 

POINTER

void add(element *&root, int value) { if(root == 0) { root = new element; root->key = value; root->next = NULL; } else add(root->next, value); }

EinPointerspeichertundzeigtaufeineAdresse.Wennan dieserAdresseeinObjektliegt,dannzeigtderPointerauf dasObjekt.

Funktionsaufruf: element* root = NULL; add(root,4);

ASCIITABELLE 65‐90: A‐Z 48‐57: 0‐9 

 

97‐122: a‐z 32: SPACE



Dereferenzierungsoperator*:ZugriffaufInhaltder SpeicherzelleaufdiederPointerverweist. 

Referenzierungsoperator&:ErmittlungderAdresseeiner Variable. int* pa = 0; int *pb; pb = NULL;

//Pointer der auf int //zeigen soll 0 (NULL) //setzen.

int a = 3; pa = &a;

//pa zeigt nun auf a

*pb = 3;

//FEHLER: pb zeigt auf 0

PointerundneuesObjekterzeugen: 

double *pc = new double; int *pd = new int(3); //*pd=3 int *pe = new int[100]; //Ptr auf Array Löschen: delete pc, pd;

delete [] pe;

POINTERAUFSTRUCTS struct triple { int a,b,c; };

SuchenachElementmitkeyk.pistmeineLaufvariable. 

p = root; while(p != NULL) { if(p->key == k) return p; p = p->next; }

//a in tp beschreiben //das selbe wie oben //Funktion in Struct

struct element { int key; element *left, *right; };

//Private Variabeln definieren int size;

EINFÜGEN

//Default Contructor Beispiel() { }

IterativeMethode.RückgabewertisteinPointer. element* search(element* root, int k) { element *p = root; while(p != 0) { if(p->key == k) return p; if(p->key > k) p = p->left; else p = p->right; } } Aufruf: element *x = search(root,2);

O‐NOTATION

pzeigtaufeinElementinderListe.NeuesElementmitKey khinterdemElementaufdaspzeigteinfügen: void insert(int k, element* p) { element *q = new element; q->key = k; q->next = p->next; p->next = q; }

for(int i=0; iright, k); } Aufruf: element *root = NULL; insert(root,2);

NEUERKNOTEN DAZWISCHEN



triple * tp = new struct triple; tp->a=10; (*tp).a=10; tp->getBeer();

LINEARESU CHE

class Beispiel { private:



󰇛󰇜

Formal:lim 󰇻󰇛󰇜󰇻  ∞(ev.Bernoullibenutzen)

Oder:fwächstasymptotischmindestenssoschnellwieg, fallseseinc>0gibt,sodass󰇛󰇜  󰇛󰇛󰇜󰇜 IndiesemFallschreibtman  󰇛󰇜 Bsp:    ,   7 ist  󰇛  󰇜 

 lim 󰇻󰇻  lim 󰇡  󰇢  ∞ →stimmtnicht

//Funktion deklarieren void foo(int x); //Destruktor zerstört die Klasse ~ Beispiel() { } }; AufrufenvonFunktionenundVariabelnderKlasse: Beispiel myClass; //Instanz der Klasse myClass.y=10; //Variable beschreiben myClass.sety(10); //Funktion aufrufen FunktionausserhalbderKlassedefinieren: void myClass::foo(int _x) {x = _x}; PointerinnerhalbKlasseaufrufen:HierPointeraufListe. myClass.myList = new element; myClass.myList->key=10; ÜBERLADENVONOPERATOREN a + bisteineKurzformfüra.operator+(b); oder operator+(a,b); DieFunktionoperator+()ineinerKlasseerlaubtesdem Operator+neueBedeutungzuzuweisen.Bsp: 

Bruch Bruch::operator+(long summand) { } Aufruf: Bruch = Bruch.operator+(summand); Bruch = Bruch + summand; VERERBUNG class myClass : Beispiel { ... } DieKlassemyClass besitztalleElementederBasisklasse Beispiel plus dieneuenElemente....