18 Februari 2013 Where friends have access to your privates!

 Tigran Gasparian ◦ 3 e jaars GameTech student ◦ C++ voor hobby, eerste programmeertaal ◦ Assistent bij een heleboel vakken  Gydo Nieraeth ◦ 4 e jaars student, 3 e jaars GameTech ◦ C++ ervaring: Software Project + Werkervaring

 Hou de site in de gaten!  Voor vragen/opmerkingen mail naar: ◦ ◦ ◦ Begin je onderwerp met [CPP]

 Industrie standaard ◦ Bijna alle grote games hebben een basis in C++  Performance ◦ Low level features ◦ Strakke memory management  Multi-Paradigm ◦ Gebruiker is vrij in het kiezen van programmeer stijl ◦ Zelfs functioneel!

 C with Classes ◦ 1979: Bjarne Stroustrup (Bell Labs), uitbreiding op C  High Level ◦ Geschikt voor grote projecten, maar lage performance  Low Level ◦ Goede performance, maar ongeschikt voor grote projecten  Intermediate Level ◦ Features van low level en high level ◦ C++

 Open Standaard ◦ 1998: C++98: eerste officiele standaard ◦ 2003: C++03: verbeterde versie ◦ 2007: C++TR1: extensies in de standard library ◦ 2011: C++11: nieuwste standaard  Compliance ◦ Verschillende mate van ondersteuning ◦ Niet elke feature is beschikbaar in elke compiler ◦ Sommige compilers voegen extra features toe

 Compilers ◦ Veel verschillende opties ◦ Commercieel vs Open Source ◦ GCC, Borland, Microsoft.....  Standaard specificeert syntax maar... ◦ Compiler specifieke interpretatie ◦ Compatability / portability problemen

 Vanaf volgende week: Practica!  Wij gaan uit van Microsoft Visual C++12 ◦ Gebruik Visual Studio 2012  Gratis verkrijgbaar via Dreamspark voor studenten ◦ Installeer het thuis op je laptop, dan kunnen we volgende week meteen van start  Benodigde libraries worden op de site bekend gemaakt

C++ Basics

#include using namespace std; int main(int argc, char* argv[]) { cout<<"Hello World!"; return 0; }

#include using namespace std; int main(int argc, char* argv[]) { cout<<"Hello World!"; return 0; } using System; class Program { static void Main(string[] args) { Console.WriteLine("Hello World!"); }

#include using namespace std; int main(int argc, char* argv[]) { cout<<"Hello World!"; return 0; } using System; class Program { static void Main(string[] args) { Console.WriteLine("Hello World!"); } #include int main(int argc, char* argv[]) { std::cout<<"Hello World!"; return 0; } class Program { static void Main(string[] args) { System.Console.WriteLine("Hello World!"); }

 main is het beginpunt van elk programma ◦ argc: een int die aangeeft hoeveel argument er zijn ◦ argv: een array met argc argumenten  Geen string, maar een char* (straks meer) ◦ main eindigt met error code (normaal 0)  Gebruik maken van andere libraries met “#include” statements ◦ Preprocessor directives (straks meer)  Gebruik maken van andere namespaces met “using namespace” statement

 Wat gebeurt er: ◦ We vragen de iostream library op ◦ We geven aan dat we gebruik gaan maken van de namespace “std” (standard) ◦ We gebruiken een speciale stream operator om “Hello World” naar de standaard output (“cout”) te schrijven ◦ We geven met return 0 aan dat het programma normaal termineert

 Vergelijk het met C# ◦ In project setup geven we aan welke libraries we gebruiken ipv #include ◦ Using om namespace aan te geven (hetzelfde) ◦ Functie main zit niet in een klasse. ◦ Cout ipv Console

 Vergeleken met C# ◦ Het idee is veelal hetzelfde, we spreken gewoon een ander ‘dialect’ ◦ Op sommige punten leveren we in:  Geen automatische Garbage collection  Minder high level functions ◦ Maar op andere punten halen we weer iets binnen  Meer controlle over geheugen  Minder overhead  Er zijn heeeeeel veel libraries beschikbaar (waardoor we alles wat we mis lopen zo weer terug kunnen krijgen)

 Fundamental types: ◦ Gedefinieerd in standaard, maar platform afhankelijk  bool: true of false  char: gebruikelijk één byte  short: minstens 16 bit  int: minstens 16 bit, gebruikelijk 32 bit  long: minstens 32 bit (is dus vaak hetzelfde als int)  long long: minstens 64 bit  float: single precision floating point, gebruikelijk 32 bit  double: double precision floating point, gebruikelijk 64 bit

 Fundamental types ◦ Minimum is vastgesteld, maar het platform bepaald de uiteindelijke grootte ◦ Meeste compilers hebben libraries met types met een gegarandeerde grootte, zoals int32_t ◦ Modifiers zijn beschikbaar voor veel types:  signed/unsigned  short/long/long long ◦ Veel synoniemen:  short = short int, signed long = long int, etc sizeof(int);

 Dingen die we al weten (maar toch nog 1 slide aan wijden) ◦ Variabelen ◦ Casting ◦ Operators ◦ Boolean logic ◦ Control structures  If-else  while/do-while  For  Jumps  Switch

#include using namespace std; int main(int argc, char* argv[]) { int number; cout<<number<<endl; number = 10; cout<<number<<endl; return 0; } Eerste run: Tweede run: Derde run: Debug mode:

 Variablen: ◦ Toewijzen en klaar ◦ Variabele heeft een waarde ◦ We slaan waardes op in variabelen int main(int argc, char* argv[]) { int number = 50; char token = 'a'; bool boolean = true; bool boolean2 = 30; return 0; }

 Casting ◦ Impliciet of expliciet. ◦ Meer manieren van casten, later meer over. int a = 5.5; // double to int int b = 5.5f; // float to int float f = (float)5.5; // double to float char c = (char)100; // int to char

 Operators ◦ Wiskundig:  +, -, /, *, % ◦ Compound  +=, -=, /=,....  A += B -> A = A + B ◦ Optellen/aftrekken  ++, --  Postincrement: A++ geeft waarde terug voor optellen  Preincrement: ++A geeft waarde terug na optellen

 Boolean logic: ◦ && en || en ! ◦ ==, !=, >, =, <= ◦ Net zoals in C#

 If-Else ◦ if (condition) { code; } [else { andereCode; }] ◦ Als de boolean conditie ‘condition’ naar true evalueert wordt ‘code’ uitgevoerd [anders wordt andereCode uitgevoerd]  Net zoals in C#

 While/do-while ◦ while (condition) { code; } ◦ Blijft ‘code’ herhalen, zolang condition true blijft ◦ do { code; } while (condition) ◦ Voert code 1x uit en blijft het daarna uitvoeren zolang condition true blijft do { cout<<"loop"; } while(true);

 for loop ◦ for ( [initialization]; condition; [statement] ) { code; } ◦ Eerst wordt ‘initialization’ één keer uitgevoerd. ◦ Zolang condition true is, wordt ‘code’ uitgevoerd. ◦ Elke keer nadat ‘code’ is uitgevoerd, wordt ‘statement’ uitgevoerd for(int i = 0; i < 10; i++) { cout<<i<<endl; }

 Jumps ◦ In loops:  continue: ga direct naar de volgende iteratie  break: verlaat de loop ◦ goto:  Het is mogelijk om met labels te definieren en met goto direct naar een label te springen  Levert makkelijk spaghetti code op, dus liever vermijden

for(int i = 0; i < 10; i++) { if(i == 5) continue; cout<<i<<endl; if(i == 8) break; } Output:

int main(int argc, char* argv[]) { hell: cout<<"Ugly code!"<<endl; goto hell; return 0; } Output: Ugly code!...

for(int x = 0; x < width; x++) { for(int y = 0; y < height; y++) { if(IsPlayer(x, y)) { player_x = x; player_y = y; goto end; } end: cout<<"Player position: "<<player_x<<", "<<player_y<<endl;

 Switch ◦ Gedrag is gematched aan constantes, als je een waarde in een switch gooit, springt de code naar het correcte gedrag char c = 'a'; switch(c) { case 'a': // code break; case 'b': // code break; default: // code break; }

 Net zoals in C# // This is a single-line comment /* This is a multi-line comment (of a single line) */

 Geen standaard string data type  Char arrays  Arrays houden zelf geen lengte bij! char myArray[100]; int myArray[200]; for(int i=0;i<200;i++) { myArray[i] = 0; }

 Einde van een string wordt aangeduid met een 0-byte char myString[100] = "hello world!"; cout<<myString<<endl; char myString[] = "hello world!"; cout<<myString<<endl; char myArray[6] = "Hello"; char myArray[6] = {‘H', 'e', 'l', 'l', 'o', '\0'};

 String klasse  Later meer over arrays (en pointers) #include using namespace std; int main(int argc, char* argv[]) { string str = "Hello world!"; cout<<str<<endl; return 0; }

 Iostream  cout voor output  cin voor input #include using namespace std; int main(int argc, char* argv[]) { cout<<"Hello World!"; return 0; }

#include using namespace std; int main(int argc, char* argv[]) { int n; cin>>n; for(int i=0;i<n;i++) cout<<"hello"<<endl; return 0; } 3 hello

#include using namespace std; int main(int argc, char* argv[]) { float n; cin>>n; for(int i=0;i<n;i++) cout<<i<<": hello"<<endl; system("pause"); return 0; } 3.5 0: hello 1: hello 2: hello 3: hello

#include using namespace std; int main(int argc, char* argv[]) { char buffer[100]; cin>>buffer; cout<<buffer<<endl; return 0; } Hello Hello World! Hello

 Gebruik cin.getline() Hello World #include using namespace std; int main(int argc, char* argv[]) { char buffer[100]; cin.getline(buffer, 100); cout<<buffer<<endl; return 0; }

 Met strings! #include using namespace std; int main(int argc, char* argv[]) { string buffer; cin>>buffer; cout<<buffer<<endl; return 0; } Hello Hello World! Hello

 Gebruik getline() #include using namespace std; int main(int argc, char* argv[]) { string buffer; getline(cin, buffer); cout<<buffer<<endl; return 0; } Hello World

 Return type  Naam  Argumenten int main(int argc, char* argv[])

int add(int x, int y) { return x + y; } int main(int argc, char* argv[]) { int n = add(1, 2); return 0; }

int main(int argc, char* argv[]) { int n = add(1, 2); return 0; } int add(int x, int y) { return x + y; }

int add(int x, int y); int main(int argc, char* argv[]) { int n = add(1, 2); return 0; } int add(int x, int y) { return x + y; }

// global scope int a = 0; int add(int x, int y) { a++; return x + y; } int main(int argc, char* argv[]) { // local scope int b = add(2, 3); cout<<a<<endl; return 0; }

int main(int argc, char* argv[]) { // local (function) scope int a = 0; if(a == 0) { // local (block) scope int b = 2; } { // also local (block) scope int c = 4; }

 Volgende keer practicum  Installer Visual Studio 12  Houd website in de gaten ◦  Oefen voor jezelf  Next up: Pointers, Arrays & Dynamic Memory!