C-Programmeren Voor BPE Avionica 20 november 2018

Introductie Basis van C-programmeren. Wat heb je nodig? Laptop Een C-compiler/developer geinstalleerd en werkend Microsoft Visual Studio DevCPP Eclipse IDE Codeblocks 20 november 2018

Introductie 20 november 2018

Optionele literatuur Problem Solving and Program Design in C (Boek thuis, PDF available) Sams Teach Yourself C in 21 Days (PDF available) Schaum’s Programming with C (PDF available) C for dummies (PDF available) www.stackoverflow.com www.c4learn.com/learn-c-programming-language/ Youtube! Google! 20 november 2018

Onderwerpen Proces van probleem oplossen PSD (Program Structure Diagram) / Flowchart Implementatie Data types Scanf, printf Operators Prioriteit van operators If-, while-, for-, do-, switch- statements Style, format en lay-out Opbouw programma Hungarian notation Arrays Functies 20 november 2018

1. Problem solving 20 november 2018

1 2 3 4 5 Problem solving Het stappenplan: Probleem oplossen: (zonder computer) Specificeren, analyseren, eisen 2 Algoritmisch ontwerp: Vorm/structuur Program Structure Design(s) / Flowchart(s) 3 Testen met de hand: Programma doorlopen, proberen met bekende/verwachtte input en output 4 Implementeren: Code schrijven C, C++, C#, ASM, Java, Python, etc… 5 Code testen Het stappenplan: Van een probleem naar een werkend programma. Voor je begint met tikken: Enig idee hoe ‘t eruit komt te zien. Enig idee hoe ‘t moet werken. Dus: ONTWERP! 20 november 2018

Algoritmisch ontwerp Maak een stappen plan voor het programma. Simpel voorbeeld: Lamp staat uit (Initiele waarde) Druk op knop (Input) Lamp gaat aan (Doe iets…) Wacht 5s Lamp gaat uit (Klaar) Wacht op actie van de knop (Evt. Herhaling) 20 november 2018

Algoritmisch ontwerp Maak een stappen plan voor het programma. Stap vergeten = Stap niet gedaan. Zet je de lamp niet uit, blijft hij aan… Gaat niet automatisch uit! 20 november 2018

Algortimisch ontwerp: Flowchart blokken 20 november 2018

Algoritmisch ontwerp: Ontwerp methodes 2 Methoden: PSD Flowchart Input Do something Output Input Do something Output 20 november 2018

Algoritmisch ontwerp: “If”-statement Als dit, dan dit, anders dat. PSD Flowchart condition true? yes no actions 1 actions 2 no condition true ? yes 20 november 2018

Algoritmisch ontwerp: “While”-Loop Terwijl dit waar is, doe dit, anders klaar. PSD Flowchart while condition is true do something Initialize condition yes condition true ? no do something 20 november 2018

Algoritmisch ontwerp: “For”-Loop Doe dit voor een bepaalde hoeveelheid keren. PSD Flowchart From [start_value] to [end_value] in [step_value] steps do something Initialize condition yes condition true ? no do something counter 20 november 2018

Implementeren: Source code int i; //Maak een variabele aan genaamd i. i=1; //Geef de variabele een waarde, 1. i=i/2; //Doe iets met die waarde. ^ Dat noemen ze de source code. In een programmeer taal… (C, C++, C#, ASM, Java, Python, etc…) 20 november 2018

Implementeren: Assembly code Programmeer talen zijn makkelijker te gebruiken versies van origineel assembly code. Compiler zet dit om voor jou in standaard instructies! Daarna wordt dit weer omgezet in ‘machine code’ (1’tjes en 0’tjes) 20 november 2018

Implementeren 20 november 2018

2. Data types 20 november 2018

Bits and bites (Duh!) Data bestaat uit 1’s en 0’s. 1x een 1 of een 1x een 0, is 1bit! 1byte bestaat uit 8bits! Data types bepalen hoeveel bytes de variabele is. Meer bytes = groter mogelijk getal! 20 november 2018

Bits and bites (Duh!) 1byte = 256 mogelijkheden (2^8) 0b0000 0000 = 0 0b1111 1111 = 255 Data van 1 byte kan dus niet groter worden dan decimaal 255. 20 november 2018

Signed and unsigned Signed = Heeft wel een sign ervoor. 0b 0 000 0000 ^betekend – of + 0= +, 1= - Range: -127 t/m 128 of -127 t/m 127 (Value signed ligt aan 2’s complement / 1’s complement) Unsigned = Geen sign ervoor. Range: 0 t/m 255 20 november 2018

Integer data types Integer = geen komma getallen! Char 1 byte Unsigned 1 byte Signed 1 byte Int 2 t/m 4 bytes Unsigned 2 t/m 4 bytes Short 2 bytes Unsigned short 2 bytes Long 4 bytes Unsigned long 4 bytes 20 november 2018

Integer data types Integer = geen komma getallen! Char Unsigned 0 t/m 255 Signed -128 t/m 127 Int Unsigned Short -32768 t/m 32767 Unsigned short 0 t/m 65535 Long -2 147 483 648 t/m 2 147 483 647 Unsigned long 0 t/m 4 294 967 295 20 november 2018

Floating type data types Anders opgebouwt dan integer types, daarom: Decimalen mogelijk Groter bereik! Float 4 bytes 1.2E-38 t/m 3.4E+38 tot 6 decimalen Double 8 bytes 2.3E-308 t/m 1.7E+308 tot 15 decimalen Long double 10 bytes 3.4E-4932 t/m 1.1E+4932 tot 19 decimalen 20 november 2018

Input (scanf) Scanf(“%lf”,&dTime); Data van user van keyboard Data opgeslagen in variabele dTime Vergeet niet & voor de variabele!! %lf is de format string, bepaald de data type die uitgelezen wordt. 20 november 2018

Output (printf) Printf(“velocity = %8.3lf m/s”, dVelocity); “…” De te printen text (string aan characters) % word herkent in combinatie met format string, om variablen te printen. Na de tekst, een komma met de gebruikte variabelen. 20 november 2018

Format string scanf, printf %d : Scan an integer as a signed decimal number. %f : Scan a floating-point number in normal (fixed-point) notation. %g, %G : Scan a floating-point number in either normal or exponential notation. %g uses lower-case letters and %G uses upper-case. %s : Scan a character string. The scan terminates at whitespace. A null character is stored at the end of the string, which means that the buffer supplied must be at least one character longer than the specified input length. %c : Scan a character (char). No null character is added. %lf : Scan as a double floating-point number. 20 november 2018

Format string scanf, printf %3d int value in at least 3 positions %d int value in the default nr. of positions %7ld long value in at least 7 positions %8.2f float with a 2 digits after the . Uses 8 positions in total (123456.78) 20 november 2018

3. Operators 20 november 2018

Assignment operators (waarde toekennen) 20 november 2018

Binary en hexadecimal prefixes! Het getal 4, kan je declareren als Int x = 4; Maar ook: Int x = 0b0100; //0b is de binary prefix! Of Int x = 0x04; //0x is de hex prefix! 20 november 2018

Unary operators (operators met 1 input) Meaning Example + Addition Operator 10 + 20 = 30 - Subtraction Operator 20 – 10 = 10 (type) Type Casting Operator 20 * 10 = 200 20 november 2018

Voorbeeld casting #1: UNCAST int sum = 17; int count = 5; double mean = sum / count; #2: CASTED double mean = (double) sum / count; Verschil? 20 november 2018

Voorbeeld casting Verschil: #1: mean = 3 #2: mean = 3.400000 20 november 2018

Binary operators (operators met 2 inputs) Meaning Example + Addition Operator 10 + 20 = 30 - Subtraction Operator 20 – 10 = 10 * Multiplication Operator 20 * 10 = 200 / Division Operator 20 / 10 = 2 % Modulo Operator 20 % 6 = 2 Andere mathematische bewerkingen door math.h; #include <math.h> 20 november 2018

Assignment operators (waarde toekennen) Operator symbol Name of the operator Example Equivalent construct += Addition assignment x += 4; x = x + 4; -= Subtraction assignment x -= 4; x = x – 4; *= Multiplication assignment x *= 4; x = x * 4; /= Division assignment x /= 4; x = x / 4; %= Remainder assignment x %= 4; x = x % 4; 20 november 2018

Increment & decrement Operator symbol Name of the operator Example Equivalent construct ++ Increment assignment x++ x = x + 1; ++x -- Decrement x--; x = x - 1; --x; 20 november 2018

Increment & decrement Verschil tussen ++x en x++: Pre- en post- increment! (voor en na increment) int i, x; i = 2; x = ++i; // now i = 3, x = 3 x = i++; // now i = 3, x = 2 geeft x waarde van voor de ++ 20 november 2018

Logic operators (bitwise) Name of the Operator & And Operator | Or Operator ^ XOR Operator ~ Not Operator << Bitshift naar links >> Bitshift naar rechts ^ IS DUS NIET POWER! Gebruik dan math.h functie POW! 20 november 2018

Logic operators (bitwise) char x = 0b10001010; // Binare getal 1000 1010 Want char was 1byte, toch!? x << 4; // Bitshift met 4 bits Wordt dus 1010 0000! Laatste 4 bits zijn naar links opgeschoven Wordt leeg gevuld! Andere bits die buiten de data type vallen zijn weg! 20 november 2018

( ) //functies&math [ ] //arrays Priority Operator Associativity ( ) //functies&math [ ] //arrays . //structs left-to-right //unary operators + – ! ~ (type) * & sizeof right-to-left 20 november 2018

Priority Operator Associativity //Binary operators * / % left-to-right *  /  % left-to-right +  – <<  >> <  <= >  >= ==  != & ^ 20 november 2018

= += -= *= /= %= &= ^= |= <<= >>= Priority Operator Associativity | left-to-right && | | ? : right-to-left = +=  -= *=  /= %=  &= ^=  |= <<=  >>= 20 november 2018

4. Statements 20 november 2018

If-statement Als … dan doe ik… If(expression == true) { printf(“Ik doe hier iets”); } Iets word uitgevoerd als de expressie true is. 20 november 2018

Relation operators (Vergelijkende operators) Meaning == Equal to != Not equal to > Greater than >= Greater than or equal to <= Less than or equal to < Less than 20 november 2018

Relation operators (Vergelijkende operators) Verschil = en == = Kent een waarde toe… == Vergelijkt waardes, resulteerd in waar of niet waar. In statements gebruik dus == ! (Sommige compilers geven warning bij zo’n fout) 20 november 2018

If-statement Wat is nou het verschil?: En if (x == true) if (x = true) 20 november 2018

If-statement Wat is nou het verschil?: En if (x == true) //Alleen als x true is En if (x = true) //Doe dit eigenlijk gewoon altijd… 20 november 2018

If-else-statement Als … dan doe ik… anders… dan doe ik… if(expression == true) { printf(“Ik doe hier iets”); } else printf(“Ik doe hier iets ANDERS”); 20 november 2018

Nested If-statement If statements in elkaar. if (expression == true) { //Doe iets omdat expressive 1 true is. If(expression2 == true) //Doe iets als expressie 1 en 2 true zijn … } 20 november 2018

Nested If-statement If statements in elkaar. if (expression == true) { //Doe iets omdat expressive 1 true is. If(expression2 == true) //Doe iets als expressie 1 en 2 true zijn … } HOU OVERZICHT DOOR INSTAPPEN TE GEBRUIKEN! DOE DIT DUS NIET! 20 november 2018

Compound if-statement Als… , && …, dan doe ik… if((expression == true) && (expression2 == true)) { printf(“Ik doe hier iets als beide expressies true zijn”); } 20 november 2018

Logic operators Let op! Dubbele tekens voor && en ||, anders voor bitwise operations, niet voor de gehele waardes! Operator Name of the Operator && And Operator || Or Operator ! Not Operator 20 november 2018

Logic operators x & y // bitwise AND, 0101 & 0011 = 0001 x | y // bitwise OR, 0101 | 0011 = 0111 x && y // true als x en y allebei true zijn x || y // true als of x waar is, of y waar is // (of beide) 20 november 2018

If-else if-statement Als… dan doe ik… Anders, als… dan doe ik… if(expression1 == true) { printf(“Ik doe hier iets”); } else if (expression2 == true) printf(“Ik doe hier iets ANDERS”); … //meer else ifs else printf(“Ik doe hier weer iets ANDERS”); 20 november 2018

Kan ook anders! Switch statement switch(variabele) { case value_1: //Doe iets . . . . . break; case value_n: default: } 20 november 2018

While-statement Terwijl… Doe dit… anders NIET Test aan het begin! while(expression) { //Zolang de expressie true is, doe ik dit. //Dit kan oneindig door gaan… } 20 november 2018

Do-While-statement Terwijl… Doe dit… anders NIET Test aan het eind! do { //Doe dit minimaal een keer, //Daarna controleer of je het nog een keer gaat doen in de //while //Dit kan oneindig door gaan… } while (expression); 20 november 2018

For-statement Doe iets voor een bepaald aantal keren! Feitelijk een while loop met een counter: int x = 0; //Begin conditie while (x<10) //Eind conditie { //Doe iets… x = x + 1; //Werkende c.q. loop conditie } 20 november 2018

For-statement Doe iets voor een bepaald aantal keren! Zo wordt de for loop ook wel gebruikt. for(begin_conditie; eind_conditie; werkende_conditie) { //Doe iets } for(int x=0; x<10; x=x+1) Vaak gebruikt samen met increment/decrement! 20 november 2018

5. Style, format & Layout 20 november 2018

Style, format & Layout Belangrijk: Overzicht houden. Leesbaar en begrijpbaar, ook voor anderen! Helpt met foutzoeken Daarvoor zijn er aantal stijl regels: (Pas ze toe naar eigen inzicht, weet dat ‘t er is) 20 november 2018

Style rule 1: Opbouw van een programma: Begin je programma met een header: /***************************************************\ | R.J. Haccou 2017-08-14 | | | | C-programmeren header //Titel | | //Nuttige informatie over ‘t project | \***************************************************/ 20 november 2018

Style rule 1: Gevolgd door files en libraries: //Files and libraries #include <stdio.h> #include <stdlib.h> #include <math.h> Declareren voor je ze kan gebruiken! Op een standaard plek, boven in je programma! 20 november 2018

Style rule 1: Gevolgd door constanten: //Constants #define PI 3.1415 #define G 9.81 Declareren voor je ze kan gebruiken! Op een standaard plek, boven in je programma! 20 november 2018

Style rule 1: Gevolg door globale variabelen. //Global variables Int x, y, z; Int nNumber; Char cName; Declareren voor je ze kan gebruiken! Op een standaard plek, boven in je programma! Ook binnen functies, variabele bovenin! *Voorkom zoveel mogelijk! 20 november 2018

Style rule #1: Opbouw Gevolgd door het declareren van functie prototypen! Nette lijst van functies die toegepast worden Main eerste functie is die je tegen komt //Function list void myFunction(int x); int mySecondFunction(int x, int y); //format: return_type function_name (type arg1, type arg2, …); int main(void) { //Do something … }//End of main void myFunction(int x) 20 november 2018 Eventuele voettekst

Style rule #2: Commentaar Gebruik commentaar om dingen toe te lichten! Leesbaar en begrijpbaar, ook voor anderen! Helpt met foutzoeken // Compute velocity. dVelocity = G * dTime; 20 november 2018

Style rule #3: Witte regels, inspringingen Gebruik witregels om blokken te scheiden Overzichtelijk! Leesbaar en begrijpbaar, ook voor anderen! // Compute velocity. dVelocity = G * dTime; // Compute new distance. dDistance = 0.5 * G * dTime * dTime; 20 november 2018

Style rule #3: Witte regels, inspringingen Gebruik inspringingen voor functies en statements: Overzichtelijk! Leesbaar en begrijpbaar, ook voor anderen! int main(void) { //begin of main printf(“Hello world.\n”); if (…) … //Do something. } //End of if. } //End of main. 20 november 2018

Style rule #4: Hungarian notatie Voeg een prefix toe aan de naam van je variabele, Weet welk type variabele Hoeft niet terug te zoeken naar declaratie Type Prefix Example char ch chCharacter int n nAge unsigned u uID long l lHours float fl flAngle double d dSalary BOOL b bReady WORD w wSize DWORD dw dwError pointer p pValue string sz szName 20 november 2018

Style rule #5: Symbolische constante Onderscheid constanten van variabelen door ze volledig in uppercases neer te zetten: //Constants #define PI 3.1415 #define G 9.81 20 november 2018

Style rule #6: Consistentie Consistent zijn zorgt voor overzicht! Doe het wel of niet, niet beide half… Style rule #7: Haakjes Gebruik haakjes Betere leesbaarheid van formules Minder fouten in formules 20 november 2018

Style rule #8: Opbreken van lange formules Split formules in meerdere lijnen Betere leesbaarheid van formules Minder fouten in formules Tussen resultaten tonen voor fout zoeken! dResult = (((lfX + lfY) * (dEps / (fSum + dLength)) + nTotal) + 0.5); Beter: lfHelp_1 = lfX + lfY; lfHelp_2 = dEps / (fSum + dLength); dResult = ( (lfHelp_1 * lfHelp_2 + nTotal) + 0.5); 20 november 2018

Style rule #9: Gebruik prompts (printf) Vertel de operator wat er gedaan moet worden: Printf(“Enter new time value in seconds: “); Scanf(“%lf”,&dTime); In command window wordt dit dus: Enter new time value in seconds: _ 20 november 2018

Style rule #10: Zo expliciet mogelijk! Eenheden zijn belangrijk, ook bij programma’s. Geef ze mee bij je prompts, maar ook in de output! Printf(“Enter new time value in seconds: “); Printf(“velocity = %8.3lf m/s \n”, dVelocity); 20 november 2018

6. Arrays 20 november 2018

Arrays Een tabel van een bepaald datatype Gereserveerd geheugen voor grote van datatype Opgebouwd als een normale variabele, maar dan met []! Voorbeeld: int nArray[10]; //Een integer array met 10 plaatsen Zelfde als 10 int variabelen aanmaken! Maar makkelijker te gebruiken 20 november 2018

Arrays Een tabel van een bepaald datatype Gereserveerd geheugen voor grote van datatype Opgebouwd als een normale variabele, maar dan met [x]! En x defineerd de hoeveelheid plaatsen (‘cellen’) Voorbeeld: int nArray[5]; //Een integer array met 5 plaatsen (‘cellen’) 20 november 2018

Arrays Een individuele array cell werkt het zelfde als een normale variabele. Kan een waarde toegewezen krijgen Kan zijn waarde toewijzen aan een andere variabele Kan worden vergeleken met een variabele of constante 20 november 2018

Arrays Waarde toewijzen! Maak gebruik van het index nummer Index nr#: 0 1 2 3 4 Voorbeeld: int nArray[5]; nArray[0] = 1; nArray[1] = 9; nArray [2] = 2003; 20 november 2018

Arrays Waarde toewijzen! Kan ook meerdere cellen tegelijkertijd: Index nr#: 0 1 2 3 4 Voorbeeld: int nArray[5] = {1,9,2003}; //index 3 en 4 blijven leeg! 20 november 2018

Arrays Waarde toewijzen! Alle cellen toewijzen zonder grootte te definieren. Voorbeeld: int nArray[] = {1,9,2003}; Geen grootte aangemaakt bij declaratie, wel groote geinitialiseerd door alle cellen een waarde toe tewijzen! 20 november 2018

Arrays Te initializeren en te gebruiken d.m.v. een for-loop: Uitlezen van 100 int-waardes: int nArray[100]; for (int i=0; i<100; i++) { scanf(“%d”,&nArray[i]); } 20 november 2018

Arrays Te initializeren en te gebruiken d.m.v. een for-loop: Printen van meerdere int-waardes: int nArray[]= {10,21,32,43,54,65,76,87,98,109}; for (int i=0; i<100; i++) { printf(“Value = %d \n”, nArray[i]); } 20 november 2018

Character arrays Ook te gebruiken met characters! Voorbeeld: char chArray[]= {‘h’, ‘e’, ‘l’, ‘l’, ‘o’}; for (int i=0; i<5; i++) { printf(“%c”, chArray[i]); } 20 november 2018

Character arrays: Strings Character arrays zijn veel gebruikt, worden ook wel “string(s)” genoemd. 1 Speciale eigenschap: Worden geeindigd met het null character: ‘\0’ ‘\0’ is een character in C, net als ‘\n’. Noemen ze ook wel ‘escape characters’ 20 november 2018

Escape characters Character arrays zijn veel gebruikt, worden ook wel “string(s)” genoemd. \a audible alert \b backspace \f form feed \n newline \r carriage return \t horizontal tab \v vertical tab \\ backslash \” double quote \’ single quote \? question mark 20 november 2018

Character arrays: Strings Terug komend op ons vorige voorbeeld: char chArray[]= {‘h’, ‘e’, ‘l’, ‘l’, ‘o’}; Dit is (nog) geen string! char chArray[]= {‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘\n’}; NU WEL! Let op: Nu is de size dus 6 characters lang. 20 november 2018

Character arrays: Strings Strings kun je dus zo definieeren: char chArray[]= {‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘\n’}; Maar makkelijker is: char chArray[]= “hello”; En dan te printen als: Printf(“%s”,chArray); 20 november 2018

Character arrays: Strings Strings kun je dus zo definieeren: char chArray[]= {‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘\n’}; Maar makkelijker is: char chArray[]= “hello”; En dan te printen als: Printf(“%s”,chArray); 20 november 2018

Character arrays: Strings Strings kun je ook inlezen met scanf: Scanf(“%s”,chArray); Let op: Geen ‘&’ teken voor de variabele-naam! En vergeet niet de ruimte die je hiervoor nodig hebt! 20 november 2018

Character arrays: Strings Probleem met strings (en uberhaupt arrays)… Je kan geen (volledige) arrays vergelijken of mathematische bewerkingen aan uitvoeren: = ,+ ,- ,== ,!= ,< ,> ,etc… Voor strings heb je daar functies voor: Strlen(s1) Lengte van s1, excluding= ‘\0’ strcpy(s1,s2) Kopieer s2 in s1 strcat(s1,s2) Voeg s2 toe aan s1 (append) strcmp(s1,s2) Vergelijk s1 met s2 20 november 2018

Multidimensionele Arrays One-dimensioneel: int nArray[3] = { 1 ,9 ,2009 }; Multi-dimensioneel: Meerdere index-waardes int nMatrix[3][4] = { { 10 , 5, -3, 17 }, { 9, 0, 0, 8 }, { 32, 20, 1, 0} }; 20 november 2018

7. Functions 20 november 2018

Functies Wat zijn het, wat heb je er aan? Stukken code c.q. blokken code Meerdere keren uit te voeren en her te gebruiken! Oproepen in main Structuur & leesbaarheid Fundementeel voor goed gestructureerde en goed geschreven code! 20 november 2018

Functies return_type functie_naam(type arg1, type arg2, …) { doe iets! (met arg1 en arg2) return waarde; } 20 november 2018

Functies Net als variabelen: Eerst declareren, Dan gebruiken! //Functie declaraties return_type functie_naam (type arg1, type arg2) int main() { … } Ook wel functie prototypes! Bovenaan je programma! 20 november 2018

Functies Net als variabelen: Eerst declareren, Dan gebruiken! //Functie declaraties return_type functie_naam (type arg1, type arg2) Waarbij arg1 en arg2 de namen van de variabelen zijn die je: In main aan de functie mee geeft, In de functie gebruikt op dezelfde manier als in main Meegegeven waardes veranderen niet in main! (tenzij pointers) 20 november 2018

Functies: Hoe werken ze? 20 november 2018

Functies: Geen return, geen argumenten 20 november 2018

Functies: No return, no arguments void area(); // Prototype Declaration void main() { area(); } void area() float area_circle; float rad; printf("\nEnter the radius : "); scanf("%f",&rad); area_circle = 3.14 * rad * rad ; printf("Area of Circle = %f",area_circle); 20 november 2018

Functies: Geen return, wel argumenten void area(float rad); // Prototype Declaration void main() { float rad; printf("nEnter the radius : "); scanf("%f",&rad); area(rad); } void area(float rad) float ar; ar = 3.14 * rad * rad ; printf("Area of Circle = %f",ar); 20 november 2018

Functies: Een return, plus argumenten float area(float rad); // Prototype Declaration void main() { float rad, area; printf("nEnter the radius : "); scanf("%f",&rad); area = area(rad); } void area(float rad) float ar; ar = 3.14 * rad * rad ; printf("Area of Circle = %f",ar); return ar; 20 november 2018

Voor zelf studie Pointers Werken met strings File handling Zelf libraries (headers & source files) maken 20 november 2018