SPL – Practical Session 2 Topics: Makefile C++ Memory Management Pointers

Preprocessor: accepts source code( Preprocessor: accepts source code(*.cpp); removes comments; add the content of the include files. Compiler: translates source to assembly code (AND, OR, JMP, SUB etc.). Assembler: creates object code (machine code, 0-s and 1-s, *.o files). Linker: links the object files to an executable and creates an executable machine code; marks the main() as the starting point of the execution.

Example Program We have a program that contains 3 files: Run.cpp, HelloWorld.cpp, HelloWorld.h HelloWorld.h included in both .cpp files Executable should be the file helloWorld

Flags Needed for the Assignments -c: compile file. input: file.cpp, output: file.o. File is not executable! -o: parameter to specify name of output . -g: produces debugging information for debugger. -Wall: prints all errors/warnings in detail. -Weffc++: prints errors/warning that violate the guidelines in “Effective C++” and “More Effective C++” books. Read more: http://www.programmingforums.org/thread7219.html

How would you compile it?! helloWorld (executable binary) helloWorld.o run.o HelloWorld.cpp HelloWorld.h Run.cpp Compile Run.cpp without creating an executable: g++ -c –o run.o Run.cpp Compile HelloWorld.cpp without creating an executable: g++ -c -o helloWorld.o HelloWorld.cpp Linking the object files and creating an executable called helloWorld: g++ -o helloWorld run.o helloWorld.o

makefile the make utility

Why makefile? An advanced way to compile your program with a single line! After creating the makefile ofcourse… But that needs to be created only once! Saves a lot of time.. We’ll see how…

Makefile example code helloWorld: run.o helloWorld.o g++ –Wall –o helloWorld run.o helloWorld.o run.o: HelloWorld.h g++ –c Run.cpp helloWorld.o: HelloWorld.h g++ –c HelloWorld.cpp clean: rm –rf ./*.o helloWorld Compiling program: Command: make helloWorld Process: compiles first run.o compiles HelloWorld.o links run.o and helloWorld.o into helloWorld Removing binaries: make clean clean has no dependencies, so it runs the remove command.

How the Makefile Works T1: D1 D2 Commands To build T1, the make utility will work as follows: if either  D1 or D2 do not exist, build them (recursively). Check if both  D1 and D2 are up to date. If not, build them recursively. Check the date of  (the modification time). If  T1 is at least as new as BOTH  D1 and D2, we are done; Otherwise, follow the instructions given to build T1 

CC = g++ CFLAGS = -g -Wall -Weffc++ # All Targets all: hello # Executable "hello" depends on the files hello.o and run.o. hello: bin/hello.o bin/run.o @echo 'Building target: hello' @echo 'Invoking: C++ Linker' $(CC) -o bin/hello bin/hello.o bin/run.o @echo 'Finished building target: hello' @echo ' ' # Depends on the source and header files bin/hello.o: src/HelloWorld.cpp include/HelloWorld.h $(CC) $(CFLAGS) -c -Linclude -o bin/hello.o src/HelloWorld.cpp bin/run.o: src/Run.cpp include/HelloWorld.h $(CC) $(CFLAGS) -c –Linclude -o bin/run.o src/Run.cpp #Clean the build directory clean: rm -rf bin/* Example from Practical Session 2 Part B – Makefile Segment Reading material: http://dev-faqs.blogspot.com/2011/03/simple-makefile-tutorial.html

When you type "make" in your shell, the script will look for a file "makefile" in the same directory and will execute it. By default, make will only execute the first target in the makefile; so, make sure the first target will cause a complete build. Important - the space you see to the left of some lines are tabs, and not space characters. makefile variables are all upper-case, and are referenced using ${VAR_NAME}.

C++ Memory Handling Memory Model, Pointers

Variables in C++ Memory System There are two "kinds" of memory available to a process: Stack: Stores local variables of the function. Removed once the function ends! Heap: Contains dynamically allocated variables. Stays once the function ends, unless cleared before! Read more: http://www.learncpp.com/cpp-tutorial/79-the-stack-and-the-heap/

Primitives and Arrays pi = &j; pi[3] = 5; pi = A; pi[3] = 5; pi++;   pi = A; pi[3] = 5;  pi++;   pi[0] = 1; // int A[10]; int s=0;  int *pi; int j;

Pointers A pointer is a variable that holds the address of some other variable. In Java, you can’t directly access the memory of such object! Only by reference. In C++, you can access them directly! Alter them any way you like, without any limitations! Benefit: More control than Java. Drawback: Memory leaks, Memory corruption. A 64-bit computer can address 264 bytes! Each memory cell is 1 byte. (byte-accessible machines – most machines today) Each pointer takes a static size of 4 bytes in a 32bit OS, 8bytes in a 64bit OS. Pointers themselves are saved on the stack.

Java vs. C++ Java’s References C++ Pointers String s = new String("a string"); The value of the variable 's' is the location of the object on the heap, but we don’t have access to this value! You can not have a variable that 'points' to a primitive type String s = null; means "I don't have the address of any meaningful data" Have access to actual memory locations. Can point to anything! The null value in C++ is the number 0 (memory address 0). In c++11, nullptr is used to denote a null pointer.

Pointers – Bit Level Declaration: int x= 5 x: c: int *ptr1 = &x; integers are of size 4bytes, which means: x: Char c = ‘z’; char *ptr2 = &c; (‘z’ equals to 122) Char takes 1byte of memory: c: ptr1 1 1 Decimal to binary conversion: http://www.wikihow.com/Convert-from-Decimal-to-Binary ASCII table: http://www.asciitable.com/ ptr2

Pointers int x; int *foo; x= 123; foo = &x; 1 2 3 MEMORY ADDRESS SPACE ... MEMORY ADDRESS SPACE 1000 1001 1002 1003 1004 1005 1006 81345 81346 81347 Address int x; int *foo; x= 123; foo = &x; x 1 2 3 foo 1000 foo contains the address it points at. *foo is the value that foo points at. &x is the address of variable x. &foo is the address of the pointer foo.

Comparing Pointers int j = 5; int i = 5; int *ptrj1 = &j; int *ptri = &i;   True/False: if (ptrj1 == ptrj2)  ? if (ptrj1 == ptri)  ? if (&ptrj1 == &ptrj2)  ? if (*ptrj1 == *ptri) ?  True False False True

Assigning a value to a dereferenced pointer A pointer must have a value before you can dereference it (follow the pointer). int *x; *x=3; int foo; int *x; x = &foo; *x=3; x does not point to anything! ERROR! this is fine x points to foo

Pointers to pointers int *x; int **y; double *z; x some int y some double

Pointers to pointers Example: Then: int i = 5; int *p_i = &i; int **pp_i = &p_i;   Then: pp_i is memory location of …    p_i *pp_i is memory location of … i **pp_i equals…  5

Pointers and Arrays Array name is basically a const pointer pointing at the beginning of the array. You can use the [] operator with pointers! Example: int A[5]; Creates a memory block of 5 integers on the stack (5x4bytes) where A (the pointer) points at the beginning of the array -> A[0]. A

Pointers and Arrays a x x[0] x[1] x[2] int *x; int a[5]={-1,-2,-3,-4,-5}; x = &a[2]; for (int i=0;i<3;i++) x[i]++; x is “the address of a[2] ” a x[i] is the same as a[i+2] x -1 -2 -3 -4 -5 x[0] x[1] x[2]

Pointer arithmetic Integer math operations can be used with pointers: +, -, ++, --, +=, -= If you increment a pointer, it will be increased by the size of whatever it points to. Incrementing pointers will basically make it point to the “next” element in memory. int *ptr = a; *(ptr+2) *(ptr+4) *ptr a[0] a[1] a[2] a[3] a[4] int a[5];

C++ char* char* is another way to represent strings in C++. (it actually came first - with C!) char* is an array of chars. char* arrays are terminated with ‘\0’ – “null terminated strings”. “denotes end of string”. char *msg= “RPI”; Length of string? strlen(msg) == 3; msg null 'R‘ 'P‘ 'I‘ \0

Using the Heap All primitives are stored in the stack, char* var = “ “; var is also stored in the stack. All that is made without new command are stored in the stack. Using the new keyword, we can now allocate memory on the heap. int *i = new int; string *str = new string(“hi there, heap is cozy!”); int *arr = new int[5]; Deleting these objects can be done by using the delete keyword. delete i; delete str; delete[] arr; Safe Delete: if (nullptr != p){ delete p; p=nullptr; } DO NOT DELETE A PONTER NOT ALLOCATED BY NEW

Pointer Pitfalls Assigning values to uninitialized, null, or deleted pointers: int *p; int *p = NULL; int *p = new int; *p = 3; *p = 4; delete p; *p = 5; All of these cases end up with segmentation fault!

Dangling Pointer A pointer that points at nothing: Example: int *p, *q; p = new int; q = p; delete q; *p = 3; //illegal assignment! p and q point to the same location, q is deleted, results with p becoming a dangling pointer!

Memory Leaks Memory leak is when you remove the reference to the memory block, before deleting the block itself. Example: int *p = new int; p = nullptr;//or a new other value p points at memory location of type int. p changed to point at null. Result? Must free memory block before changing reference. Memory leak!

 A memory leak can diminish the performance of the computer by reducing the amount of available memory. Eventually, in the worst case, too much of the available memory may become allocated and all or part of the system or devices stops working correctly, the application fails, or the system slows down. Use valgrind with –leak-check=yes option if your implementation has memory leaks. Valgrind User Manual, The Valgrind Quick Start Guide, Graphical User Interfaces * This is why the –g flag is used when debugging!

lvalue, rvalue rvalue cannot be on left side of an expression. int main(int argc, char** argv) {   int i = 5;    int j = 4;    char *s = "test";    j = 5 * 22;    i = i + j;  } int i = 5; // i is lvalue, 5 is rvalue   int j = 4; // j is lvalue, 4 is rvalue   char *s = "test"; // s is lvalue, "test" is rvalue   j = 5 * 22; // j is lvalue, 5 * 22 is rvalue   i = i + j; // i is lvalue, i + j is rvalue

References (lvalue references) A variable that is used to refer to another variable (alias). Notation: varType &refVar = objVar; Example: int i =3; int &r =i; r = 4; //will change the value of i to 4

Hides indirection from programmer Must be typed (int, double…) Can only refer to the type to which it can point. Checked by compiler int &r = i; // can only refer to int Must always refer to something Must be initialized upon creation. Cannot be initialized to 0 or NULL. Value cannot be changed once initialized.

What are they for? When you send a variable to a function: Function: void removeLast(intArray intArr){ ... }; intArray myArr = intArray(1,2,3,4,5); removeLast(myArr); Variable is passed by value! Which means a copy of myArra is created and sent to the function. Problem? Functions that alter the values of the variable sent to them cannot alter the variable! They will alter a copy of the variable.

myArr = removeLast(myArr); Possible solution? Alter the function to return the same object type: intArray removeLast(intArray intArr){ … }; Usage: myArr = removeLast(myArr); Another solution? References! void removeLast(intArray& intArr){ … }; removeLast(myArr); Common places references are used at? Used in copy constructor Used in operator overloading

Lvalue Reference vs. Pointers Referencing is done directly. User interacts with it as if it was the object itself. Must be typed. Must be initialized upon creation. Can’t be altered after. Pointer: Stores the memory address of the object. Requires dereferencing in order to retrieve the object. Does not have to be typed. (use casting..) Does not have to be initialized upon creation. Can be altered afterwards. Dereferencing: the act of getting what the pointer is pointing at.