Measures of Dispersion and Variability: Range, QD, AD and SD
Memory Management with Java and C++
1. Understanding
Memory Management
and Garbage Collection
Java and C++
Mohammad Shaker
FIT of Damascus - AI dept.
MohammadShakerGtr@gmail.com
Programming Languages
6. Bad Pointers
• When a pointer is first allocated, it does
not have a pointee.
• The pointer is “uninitialized” or simply
"bad".
• every pointer starts out with a bad
value.
• There is nothing automatic that gives
a pointer a valid pointee.
8. Bad Pointers – Faster?!
• Most languages make it easy to omit
this important step.
• The run-time checks are also a reason
why such languages always run at
least a little slower than a compiled
language like C or C++!
9.
10.
11.
12. Bad Pointers - Example
void BadPointer() {
int* p; // allocate the pointer, but not the pointee
*p = 42; // this dereference is a serious runtime error
}
13. Pointer Rules Summary
• A pointer stores a reference to its pointee. The
pointee, in turn, stores something useful.
• The dereference operation on a pointer accesses its
pointee. A pointer may only be dereferenced after
it has been assigned to refer to a pointee. Most
pointer bugs involve violating this one rule.
• Allocating a pointer does not automatically assign it
to refer to a pointee. Assigning the pointer to refer
to a specific pointee is a separate operation which
is easy to forget.
• Assignment between two pointers makes them refer
to the same pointee which introduces sharing.
14. Large Locals Example
void X() {
int a = 1;
int b = 2;
// T1
Y(a);
// T3
Y(b);
// T5
}
void Y(int p) {
int q;
q = p + 2;
// T2 (first time through)
// T4 (second time through)
}
16. A bit harder - Bill Gates By Value
void B(int worth) {
worth = worth + 1;
// T2
}
void A() {
int netWorth;
netWorth = 55; // T1
B(netWorth);
// T3 -- B() did not change netWorth
}
17. A bit harder - Bill Gates By Value
void B(int worth) {
worth = worth + 1;
// T2
}
void A() {
int netWorth;
netWorth = 55; // T1
B(netWorth);
// T3 -- B() did not change netWorth
}
18. A bit harder - Bill Gates By Reference
void B(int &worth) {
worth = worth + 1;
// T2
}
void A() {
int netWorth;
netWorth = 55; // T1
B(netWorth);
// T3 -- B() did not change netWorth
}
19. A bit harder - Bill Gates By Reference
void B(int *worth) {
*worth = *worth + 1;
// T2
}
void A() {
int netWorth;
netWorth = 55; // T1
B(&netWorth);
// T3 -- B() did not change netWorth
}
23. Heap!
• "Heap" memory, also known as
"dynamic" memory.
• an alternative to local stack Memory.
24. Facts
• Local memory is quite automatic — it is
allocated automatically on function call
and it is deallocated automatically when
a function exits.
• Heap Lifetime
– Because the programmer now controls
exactly when memory is allocated and
deallocated, it is possible to build a data
structure in memory, and return that data
structure to the caller. This was never possible
with local memory which was automatically
deallocated when the function exited.
25. Heap - Allocation
• Allocate 3 GIF images in the heap
each of which takes 1024 bytes of
memory.
35. • both values and the variables are allocated memory.
However, each assignment copies into the variable’s block,
not the contents of the value block, but instead its address
36. • both values and the variables are allocated memory.
However, each assignment copies into the variable’s block,
not the contents of the value block, but instead its address
37. null.toString();
• we get a NullPointerException (Java)
• we can determine whether the value
of a pointer variable is null or not, and
hence, whether we can access its
member.
39. Point p1 = new ACartesianPoint(50, 50);
Point p2 = p1;
p1.setX(100);
System.out.println(p2.getX());
• When p1 is assigned to p2, the pointer stored
in p1 is copied into p2, not the object itself.
Both variables share the same object, and thus, the
code will print 100 and not 50, as you might expect.
42. Foreknowledge
• Code area
– where code to be executed is stored
• Heap
– store variables and objects allocated
dynamically
– accessed with no restrictions
• Execution Stack
– perform computation
– store local variables
– perform function call management
49. Scope Activation Record (SAR)
• Contains:
– Local variables (declared inside the
block)
– The Static Link SL (a.k.a SAR link)
a pointer to the SAR of the
immediate enclosing block; used to acce
ss local variables of outer blocks from the
current block.
54. C++ again
• In C++ classes are truly user defined ty
pes. Objects are treated as any other
variable and are allocated:
– On the stack, as regular local variables
– On the heap, like in Java
55. Java example
int[] hello = new int[5];
// reference hello is on stack, the object is on the
// heap.
hello[0] = 2;
// Java puts this value directly in same slot and doesn't
// create a wrapping object.
From: http://stackoverflow.com/questions/10820787/how-does-java-treat-primitive-type-arrays
56. Java: Why are wrapper classes needed?
http://stackoverflow.com/questions/2134798/java-why-are-wrapper-classes-needed
57. Java example
public class CoffeeMaker {
public CoffeeMaker(){}
}
..
..
CoffeeMaker aCoffeeMaker;
aCoffeeMaker = new CoffeeMaker();
int sugar = 4;
Integer sugarObject = new Integer(3);
58. Java example
public class CoffeeMaker {
public CoffeeMaker(){}
}
..
..
CoffeeMaker aCoffeeMaker;
aCoffeeMaker = new CoffeeMaker();
int sugar = 4;
Integer sugarObject = new Integer(3);
59. Java example
• Java objects can be accessed just
through reference variables, that hold
the address of objects in heap.
60. C++ example
class CoffeeMaker {
public:
CoffeeMaker();
virtual ~CoffeeMaker();
};
// ..
CoffeeMaker aCoffeeMaker;
CoffeeMaker *aPtrCoffeeMaker = new CoffeeMaker();
CoffeeMaker &aRefCoffeeMaker = aCoffeeMaker;
aRefCoffeeMaker = *aPtrCoffeeMaker; // dangerous!
int sugar = 4;
int *ptrSuger = new int;
int &aRefSugar = sugar;
63. Issues for objects in memory (Java)
• Objects with no references pointing to
them are considered eligible for
automatic garbage collection by the
system, which runs periodically and
performs the real destruction of the
objects.
• GC is not directly under control of the
programmer.
64. Issues for objects in memory (C++)
• After an object has been created on
the heap (with the new directive) it
survives until someone destroys it
explicitly using the delete directive.
• This could lead to memory leaks
– if the programmer forgets to delete
objects no longer needed, they remain
on the heap as wasted space
65. Methods (Java)
public class CoffeeMaker {
public void prepareCoffee() {}
public void prepareCoffeeSweet(int sugarAm){}
void main(...) {
CoffeeMaker aCoffeeMaker;
aCoffeeMaker = new CoffeeMaker();
aCoffeeMaker.prepareCoffee();
}
}
66. Methods (Java)
public class CoffeeMaker {
public void prepareCoffee() {}
public void prepareCoffeeSweet(int sugarAm){}
void main(...) {
CoffeeMaker aCoffeeMaker;
aCoffeeMaker = new CoffeeMaker();
aCoffeeMaker.prepareCoffee();
}
}
