Samenvatting C en C++ (E761018)

C en C++
C
1. Basisconcepten C
• Conditionele uitdrukking
o A = b > 0 ? 1 : -1
• Switch
Switch(score) {
Case 12: case 13: case 14:
Resultaat = ‘A’
Break;
Case 15: case 16
Resultaat = ‘B’
Break;
Default:
Resultaat = ‘D’;
}
Uitvoer en invoer
• Printf(“test %d”, getal)
• Scanf(“%d”, &getal)
• Inputbuffer legen
o While(getchar() != ‘\n’)
Arrays
• Variabele die meerdere geheugenplaatsen bevat
• !! grootte van array moet een getalconstante zijn -> geen variabele
o Int getallen[8]
o #define MAX 8
o Int getallen2[MAX]
• Grootte van array berekenen
o Sizeof(naam)/sizeof(type)
• Arrays zijn pointers
• Declaratie
o Int i[6] = {1,2,3,4,5,6}
• Als functieparameter
o Void verdubbel(int [], int)
• Grootte moet steeds specifiek meegegeven worden
o Er bestaat geen length functie
• Resultaat van functie kan geen array zijn, wel pointer
• Adres van array wordt meegegeven als argument
o Functie kan inhoud van array wijzigen
o Dit vermijden -> const toevoegen
o Void kopieer(const int[])
2. Pointers
• Wijzen naar bepaald gegeven
o Int *p = &g
o *p = 9 // g wordt 9
o (*p)++ //g wordt 10
o *p *= 2 //g wordt 20
o Printf(“*p=%d p=%p &p=%p”, *p, p, &p) //waarde g, adres g, adres p
• Nullpointer = pointer die naar nergens wijst
o Double *p
o P = 0 of p = NULL
o If(p) {} //kijken of pointer naar ergens wijst
o !! nullpointer niet derefereren
• Voidpointer

1

, o Void *v
o Niet derefereren maar eerst casten naar geschikte pointer
o Printf(“*v=%f”, *(double *)v)
• Call by reference
o Geef adressen van variabelen mee
o Kopieën vermijden
o Tegengestelde(&i)
o Void tegengestelde(int *a){ *a *= -1 }
Pointers en arrays
• Arraypointer is een constante pointer naar 1e element van de array
o Kan niet verzet worden, moet naar eerste element blijven wijzen
• Pointer naar constante waarde
o Const int *p = &n
o *p = … //gaat niet want de int waarnaar p wijst is constant
• TIP -> lees het achterstevoren
o int const *p -> p is een pointer naar een constant int
o const int *p -> p is een pointer naar een constant int
o int *const p -> p is een constante pointer naar int
Bewerkingen op pointers
• Voorbeeld
o Int t[5] = {0};
o Int *p
o P = &t[3];
o P++ //verspringen in geheugen naar volgend
element
o T niet verplaatsen
o Geen bewerkingen met voidpointers
• Arraypointers niet verzetten in hoofdprogramma, wel in andere functies
Void vulop(int *t, int n, int w) {
Int i ;
For (i=0) ; i<n ; i++) {
*t++ = w //ok, t is gewone pointer -> verplaatsen OK
}
}

Int main() {
Int i ;
Int t[10] = {0}
For(i=0 ; i<10 ; i++) {
*t++ = 5 //nt ok, t = constante pointer, niet verplaatsen
}
Vulop(t, 10, 5)
Return 0
}
• Constante pointer
o Const int *p = &n
o Int * const q = &n
o Const int * const l = &n
o Constante pointer -> bij declaratie initialiseren
Functiepointer
• Pointer naar een functie
o Void proc(int a, char b)
o Void (*p)(int, char)
o P = &proc OF p = proc
o (*p)(2,’a’) OF p(2,’a’)
• Array van functiepointers
o Double sum(double x, double y) { return x+y }
o Double product(double x, double y} { return x*y }
Int main() {
Double a = 10, b = 5
Double (*pf[])(double, double) = { sum, product, fmin }

2