De presentatie wordt gedownload. Even geduld aub

De presentatie wordt gedownload. Even geduld aub

18 Februari 2013 Where friends have access to your privates!

Verwante presentaties


Presentatie over: "18 Februari 2013 Where friends have access to your privates!"— Transcript van de presentatie:

1 18 Februari 2013 Where friends have access to your privates!

2  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

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

4  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!

5  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++

6  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

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

8  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

9 C++ Basics

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

11 #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!"); }

12 #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!"); }

13  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

14  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

15  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

16  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)

17  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

18  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);

19  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

20 #include using namespace std; int main(int argc, char* argv[]) { int number; cout<

21  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; }

22  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

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

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

25  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#

26  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);

27  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<

28  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

29 for(int i = 0; i < 10; i++) { if(i == 5) continue; cout<

30 int main(int argc, char* argv[]) { hell: cout<<"Ugly code!"<

31 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: "<

32  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; }

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

34  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; }

35  Einde van een string wordt aangeduid met een 0-byte char myString[100] = "hello world!"; cout<

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

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

38 #include using namespace std; int main(int argc, char* argv[]) { int n; cin>>n; for(int i=0;i

39 #include using namespace std; int main(int argc, char* argv[]) { float n; cin>>n; for(int i=0;i

40 #include using namespace std; int main(int argc, char* argv[]) { char buffer[100]; cin>>buffer; cout<

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

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

43  Gebruik getline() #include using namespace std; int main(int argc, char* argv[]) { string buffer; getline(cin, buffer); cout<

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

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

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

47 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; }

48 // 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<

49 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; }

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


Download ppt "18 Februari 2013 Where friends have access to your privates!"

Verwante presentaties


Ads door Google