A C++ Crash Course Part I

1. A C++ Crash CoursePart I UW Association for Computing Machinery http://www.cs.washington.edu/orgs/acm/tutorials acm@cs.washington.edu Questions & Feedback to Hannah C. Tang (hctang) and Albert J. Wong (awong)

2. C/C++ fundamentals Functions Primitive data types The stack Arrays (working model) Pointers A practice program C-style types Typedefs Structs Arrays (whole story) More C++-isms C++-style vs Java-style references C++ gotchas What We’ll Cover

3. What We’re NOT Covering • Topics related to C++ classes • Multiple files • The preprocessor • C++ classes • Inheritance and dynamic dispatch • Memory management • The heap • Destructors • Advanced topics • Modifiers: const, static, and extern • Operator overloading • Templates

4. Goals of Java Java • Simple • Consistent • Huge OO Focus • Cross platform via a virtual machine • Originally for embedded systems Java, C, and C++, have different design goals.

5. Goals of C and C++ C and C++ are popular because they have met, with reasonable success, their goals. C • Low level • No Runtime Type info • Easy implementation C++ • Originally to add some OO functionality to C • Attempt to be a higher-level language • Now it’s a totally different language

6. public void printSum(void) { int x, y; // … get user input … int sum = x + y; // … print sum … } void printSum(void) { int x, y; // … get user input … int sum = x + y; // … print sum … } A simple program snippet

7. printSum() The simple program – Java version class Calculator { public void printSum(void) { int x, y; // … get user input … int sum = x + y; // … print sum … } } class App { public static void main(String[] args) { Calculator c = new Calculator; c.printSum(); } } App Calculator

8. void printSum(void) { int x, y; // … get user input … int sum = x + y; // … print sum … } int main(int argc, const char * argv[]) { printSum(); return 0; } class Calculator { public void printSum(void) { int x, y; // … get user input … int sum = x + y; // … print sum … } } class App { public static void main(String[] args) { Calculator c = new Calculator; c.printSum(); } } The simple program – C++ version

9. Procedural Programming • Functions are free-floating “methods” disassociated from any class • Functions declarations can be separate from function implementations • The declaration provides the signature, which specifies the name, return type, and parameter list of the function • C is completely procedural • C++ mixes object-oriented and procedural programming

10. Discussion Point I Which of these programs can be written procedurally? Object-orientedly? • HelloWorld • A traffic simulator • Must simulate cars, roads, and the interactions between these entities • A calculator • Accepts two numbers, then calculates the sum or difference, depending on a user-selected operator • An mp3 player • Accepts a list of files, and plays them in the specified order. Needs to support skins • Come up with your own example

11. Function Syntax and Semantics <ReturnType> functionName( … <parameter list> … ); int calculatePower(int base, int exponent); • <ReturnType> can be any type except an array • Class-scoped methods and free-floating functions are basically the same, except …

12. Parameter Passing in Java – Part I class Example { public void moveToDiagonal(Point p) { p.setY(p.getX()); } public static void main( String[] args ) { Point pt; pt = new Point(3, 4); moveToDiagonal(pt); // What are the coordinates of pt now? } }

13. In Java, everything is a reference x: 3y: 4 x: 3y: 3 pt p moveToDiagonal(Point p) { p.setY(p.getX()); } Point pt; pt = new Point(3, 4) In Java, modifying a method parameter means modifying the original instance

14. Java atomic types: int double boolean etc … C++ atomic types: int double bool etc … … almost everything is a reference In Java, modifying an atomically-typed parameter did NOT modify the original instance. In Java, atomic types are passed by copy. The same semantics hold for C++ atomic types

15. C/C++ Function Parameters • In C++, all function parameters are passed by copy – even if they’re not of atomic type • Why? • First, a brief detour …

16. i d2 d1 y x Detour: Functions & Memory • Every function needs a place to store its local variables. Collectively, this storage is called the stack • This storage (memory aka “RAM”), is a series of storage spaces and their numerical addresses • Instead of using raw addresses, we use variables to attach a name to an address • All of the data/variables for a particular function call are located in a stack frame Memory location void aFunc(int x, int y) { double d1, d2; int i; }

17. Detour: Functions & Memory (cont) • When a function is called, a new stack frame is set aside • Parameters and return values are passed by copy (ie, they’re copied into and out of the stack frame) • When a function finishes, its stack frame is reclaimed void aFunc(int x, int y) { double d1 = x + y; } int main(int argc, const char * argv[]) { int x = 7; aFunc(1, 2); aFunc(2, 3); return 0; } d1 y aFunc x x 7 main

18. C/C++ Function Parameters (cont.) • In C++, all function parameters are passed by copy – even if they’re not of atomic type • Why? • In C++, all variables exist on the stack by default • In C++, parameters are copied into the callee’s stack frame • We’ll talk about Java parameter passing later (when we talk compare C++ and Java references)

19. Discussion Point II • Examine the code fragment below. • Draw the stack frame(s) for some sample input. • If you see any bugs, what are they? How would the program behave? void sillyRecursiveFunction(int i) { if(i == 0) { return; } else { sillyRecursiveFunction(i – 1); } }

20. myArray[5] myArray[4] myArray[3] myArray[2] myArray[1] myArray[0] or myArray Arrays <ArrayType> arrayName[ numElements ] • Arrays are contiguous memory locations, and its name refers only to the address of the first element • Indexing into an array is the same as adding an offset to the address of the first element • When declaring an array, its size must be known at compile-time

21. Arrays as function parameters <ReturnType> funcName( ArrayType arrName[ ] ) int sumOfArray( int values[], int numValues ) • Arrays are not passed by copy. Instead, the address of the first element is passed to the function • Note how array parameters and non-parameter arrays behave identically

22. Discussion Point III • Why are arrays not passed by copy? • Hint: the size of a stack frame is computed long before the program is run (specifically, at compile time)

23. x(4104) y(4100) Variable name n(4096) Address Storage space Pointers What if we had variables that contained addresses? They could contain addresses of anything! We could use these variables in functions to modify the caller’s data (we could implement Java’s parameter-passing semantics!)

24. x(4104) y(4100) 4096 n(4096) 7 Pointers: vocabulary • A pointer is a variable which contains addresses of other variables • Accessing the data at the contained address is called “dereferencing a pointer” or “following a pointer”

25. Declaring Pointers Declaring a pointer: <Type> * ptrName; “ptrName is a variable which contains the address of something of type <Type>” For example: int * nPtr1, * nPtr2; void aFunc( int aParam, int * ptrParam); Using Pointers Dereferencing a pointer: *ptrName “Go to the address contained in the variable ptrName” Getting the address of a variable: &aVar “Get the address of aVar” For example: aFunc(myInt, &anotherInt); anInt = *myPtr * 4; *dinner = 100; Pointer Syntax

26. The code int * p; int q; p = &q *p = 5; Box Diagrams “p’s type is int pointer. q’s type is int.” “Assign 5 to where p points (which is q).” 5 p Pointers: Putting it all together Memory Layout pcontains the address of anint. qcontains anint. Go to the address thatpcontains, and place a 5 there. 8196 p (8200) q q (8196) 5

27. The code void doubleIt(int x, int * p) { *p = 2 * x; } int main(int argc, const char * argv[]) { int a = 16; doubleIt(9, &a); return 0; } Box diagram Pointers: Putting it all together (cont.) Memory Layout main p(8200) 16 8192 a doubleIt x (8196) 9 a (8192) 16 main doubleIt 9 x p

28. p(8200) p(8200) p(8200) 8192 8192 8192 b (8196) b (8196) b (8196) 300 9 9 a (8192) a (8192) a (8192) 200 200 16 Pointer Arithmetic Pointers are numbers, so you can do math on them! int * p = &a; *p = 200; *(p+1) = 300; Pointer p refers to an int, so adding 1 to p increments the address by the size of one int. The C/C++ expression for this is sizeof(int)

29. Pointers and Arrays Pointers and arrays are (almost) interchangeable Given: myArray[4] (9000) int myArray[5]; int * p = myArray; myArray[3] (8196) myArray[2] (8192) These are equivalent: • *p • myArray[0] • *(p+0) • *myArray • p[0] • 0[p] myArray[1] (8188) myArray[0] (8184) p (8180) 8184

30. Discussion Point IV • How do pointers and arrays differ? • Hint: how are pointers implemented in memory? Arrays?

31. Exercise • Get up and stretch! • Do the worksheet exercise • Then, write a program to do the following: • Read some numbers from the user (up to a max number of numbers) • Calculate the average value of those numbers • Print the user’s values which are greater than the average • Get up and stretch again!

32. Pointer Problems • Pointers can refer to other variables, but: • Create an additional variable • Have an ugly syntax

33. Function Pointers <ReturnType> (*ptrName)(arg type list ); • Functions are pieces of code in memory • Pointers can point to functions. • This syntax is U-G-L-Y (the ugliest in C) • Notice that the name of the variable appears in the middle of the statement! • You do not have to dereference a function pointer Function pointers are not scary. They are useful!

34. Function Pointers - example void foo(int i, char b); void bar(int i, char b); int main(void) { void (*p)(int,char); p = foo; p(1, ‘c’); // equivalent to foo(1, ’c’); p = bar; p(2, ‘b’); // equivalent to bar(2, ‘b’); (*p)(2, ‘b’); // Exactly the same return 0; }

35. Pointer: Reference: 9 x x ref 9 ref References References are an additional name to an existing memory location If we wanted something called “ref” to refer to a variable x:

36. Properties of References Reference properties: • Cannot be reassigned • Must be assigned a referee at construction Therefore: • References cannot be NULL • You cannot make an array of references. Given what you know about references, can you explain where these properties come from?

37. References Declaring a reference: <Type> & refName = referee; Usage: int n; int & referee = n; void aFunc( int aParam, int & ptrParam); aFunc(1, n); Pointers Declaring a pointer: <Type> * ptrName; Usage: int n; int * nPtr1 = &n; void aFunc( int aParam, int * ptrParam); aFunc(1, &n); Reference Syntax

38. Discussion Point V • What are the differences between Java references and C++ references? What about Java references and C++ pointers?

39. C-style struct A struct is used to group related data items struct student { int id; char name[80;] }; Note that the it is optional to name a struct • To the programmer • id and name are now related • structstudent creates a convenient grouping • To the compiler • Id and name have a fixed ordering (not offset) in memory • Struct student is a first-class type that can be passed to functions

40. Declaring a Struct Declaring a struct: struct [optional name] { <type> field1; <type> field2; … } [instance list]; Examples: struct Foo { int field1; char field2; } foo,*foo_ptr; struct Foo foo2; struct { int a; } blah; Access struct fields Accessing a field in a struct: foo.field1; “gets field1 from the instance foo of struct Foo” Pointers syntax and structs The * has lower precedence than the ‘.’ : *foo_ptr.field1; means *(foo_ptr.field1); Which won’t compile Accessing a field in a struct pointer: (*foo_ptr).field1; foo_ptr->field1; struct Syntax

41. enum An enum creates an enumerated type; they are options with an associated value enum PrimaryColors { RED = 0, GREEN, BLUE }; Note that the it is optional to name an enum • By default, the first option is given the value 0 • You can assign an option any integer • Subsequent options have the previous option’s value + 1 • All enumeration values are in the same namespace

42. Declaring an enum Declaring a enum: enum [optional name] { OptionName [= int], OptionName [= int], … } [instance list]; Example of an enum: enum Color { RED, GREEN, BLUE } color, *color_ptr; enum Color c; void drawCircle (enum Color c); Enum quirks Problems with Enums: Frail abstraction Treated as integers Can be assigned invalid values Flat namespace Proper use guidelines: Avoid breaking abstraction Mangle name of enum into option name (so ColorRed instead of Red) Here is one sanctioned abstraction break enum Color { RED, GREED, BLUE, NumberOfColors }; enum Syntax

43. union An union creates an union type; all fields share the same memory location union Argument { int intVal; double doubleVal; char charVal; }; Note that the it is optional to name a union • Changing intVal changes doulbeVal and charVal! • Can be used to create constrained-type containers • Usually used in conjunction with an enum that says which field is currently valid.

44. Declaring an enum Declaring a enum: union [optional name] { <type> name1; <type> name2; … } [instance list]; Example of a union: union Argument { int value; char *string; } arg1, *ptr; union Argument arg2; arg1.value = 3; arg2.string = NULL; Union quirks Problems with Enums: Only assume that the last field written two is valid. Don’t use to “save space.” Proper use guidelines: Ensure you have another method of knowing which field is currently valid. union Syntax

45. Typedef Typedef is used to create an alias to a type typedef unsigned char byte; unsigned char mybyte; byte mybyte; • byte now represents an unsigned char • Both definitions of mybyte are equivalent to the compiler. • The second definition is preferred as it gives more info

46. Typedef – common uses • Abstraction • The user may easily change the type used to represent a variable. • Clarification • More informative names for a type be given • Variables that use the same type in different ways can be separated easily • Convenience • Type names can get very long • People like structs to look like real types • Some type names (like function pointers or array pointers) are really hard to read/write

47. Typedefs – structs/enums/unions People often make a typedef of an anonymous struct, enum, or union typedef struct { int id; char name[80]; } Student; Student st; struct Student { int id; char name[80]; }; struct Student st; These are almost the same. However, anonymous structs cannot refer to themselves. struct List { int data; struct List *next; };

48. Discussion Point VI • What advantages do named structs/unions have over anonymous ones? Are enums different? • How would you try to pass anonymous structs, enums, or unions to a function? Can you?

49. C++ “Gotcha” I Don’t use exceptions unless you know what you’re doing! • Uncaught C++ exceptions do not produce a stack trace. • C++ does not automatically reclaim new’d resources (more in a later tutorial) void someFunc(void) { throw “Exception!"; } int main(int argc, const char * argv[]) { someFunc(); return 0; } $ ./myProg Aborted $

50. C++ “Gotcha” II Don’t return pointers (or references) to local variables! double * aFunc(void) { double d; return &d; } int main(int argc, const char * argv[]) { double * pd = aFunc(); *pd = 3.14; return 0; } Boom! (maybe)