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

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

3. 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

4. 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:

5. 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

6. makefile
the make utility

7. 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…

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

9. 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 

10. 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:

11. 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}.

12. C++ Memory Handling
Memory Model, Pointers

13. 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:

14. 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;

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

16. 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.

17. 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:
ASCII table:
ptr2

18. 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.

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

20. 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

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

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

23. 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

24. 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]

25. 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];

26. 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

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

28. 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!

29. 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!

30. 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!

31.  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!

32. 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

33. 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

34. 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.

35. 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.

36. 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

37. 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.