- Memory Management and C++
- Memory Partitioning
- The Heap
- Object Orientation
- The Three P's
- Constuctors and Destructors in C++
Control over how and where to obtain memory
-
Static memory
- Global variables
- Static local variable in functions or classes
-
The Stack
- Non-static variables
- Anything declared at compile time
- Can possibly lead to a memory leak
-
The Heap
- Dynamically allocated memory
- Variables
- Static
- Dynamic
Operating System allocated memory block from Appropriate division
Memory allocated during compile time and before program execution
Only one copy of memory will be created
Changes made to static variables will impact all uses of that variable
- Static variables will only go out of scope when the program terminates
Created through the static keyword
{
void login()
{
static int counter = 0; //only initialized once
readId_pwd();
if(verified())
counter++; //count the number of users that are logged in
}
}Static variables are not the same as a global variable
- They can be global, but can also be local
- Global variables are always accessible
- Statics in a local sense can only be accessed within that function
These static variables can also be defined within a part of a class
A static local variable doesn't go out of the scope
Used for dynamic allocation
Used within Java because JVM created a Heap for garbage collection and memory allocation
The heap is allocated during run time through dynamic allocation, changed during runtime
- This is where garbage collection and management comes from
Manging memory can come with issues
-
Memory leaks
-
Forget to delete unused objects or a dynamically created structure
- Takes up RAM that cannot be reallocated
-
If the memory is abandoned by a pointer.. it will continue to exist
-
-
Dangling Reference and Segmentation Faults
- A dangling reference happens when object or memory is trying to be accessed which has already been deleted or out of scope
- A seg-fault happens when you try to access some memory illegally
- Going out of bounds within an array
- Accessing bad memory through a dangling reference
- Using a pointer that hasn't been allocated correctly (null-reference)
Classes become the primary unit of abstraction
A class definition beings with the keyword class
The body of the class is contained within a set of { }; (notice the semicolon)
Two things that make a class
-
properties
- Properties can accept values like strings, integers, and booleans (true/false values), like any other variable
- Student ID, grades, age, gender
-
Object
- Something that would store the information from properties, assign personal properties
-
Methods
- A function within a class that manipulates some object or returns values
Method is a function that specifically belongs to a class
Python can have both, where as Java would only deal with methods rather than functions
{
class class name
{
...
}; //do NOT FORGET the semicolon
}Encapsulation and Data Hiding require judicious use of Visibility Modifiers
Unlike other programming languages, these are NOT prefixes
Public, Private and Protected are sections within the class
Attention must be payed to organization of properties and methods
- items are private by default
{
class class_name
{
private:
...
...
...
public:
...
...
...
}; //SEMI-COLON!
}{
class Circle
{
private:
double radius;
public:
void setRadius(double radius);
double getDiameter();
double getArea();
};
}Different than something like Java we only declare the methods and variables (properties) but nothing is defined
Scope-resolution must be used to define method in the class
The double-colon
{
//class A could be forward declared in any situation, as most things can
class A; //forward declaration... not necessary
class A
{
private:
int a;
void doubleA();
public:
static int nextId;
int getA();
void setA(int);
};
int A::nexId = 1000; //modify the variable
int nextId = 1000; //this would declare a Global variable
int getA() //this would define a function rather than a method from the class
{
return this->a;
}
int A::getA() //this defines a METHOD from class A
{
...
}
void A::setA(int val)
{
this ->a = val;
}
void A::doubleA()
{
this->a = a * 2;
}
int main(int argc, char ** argv)
{
return 0;
}
}Create a variable of the object on the stack or one can be created through a pointer on the heap
- Using a pointer is much more common within C++ code
circle c1;
Circle* c2 = new Circle();A constructor in a class is a function whose name is the same as the class name and is used to initialize objects
A destructor is used to collect garbage
{
class Queue {
private:
int queue_size;
protected:
int *buffer;
int front;
int rear;
public:
...
}
}The constructor is defined below:
Queue(void) { //constructor
front = 0; rear = 0;
queue_size = 0;
buffer = NULL;
}
Queue(int n){ //constructor
front = 0; rear = 0;
queue_size = n;
buffer = new int[queue_size];
} //constructor Overload
If it is put on the heap and we delete the pointer, it would now be a memory leak. We need garabge collection which is not automatically done for us with C++. The destructor allows us to delete everything from the object. Helping with our memory leak. Destructor -->
virtual ~Queue(void) {
delete buffer;
buffer[] = NULL;
}void application(){
Queue *myQueue; //declare pointer only
myQueue = new Queue(500); //created in application
myQueue->enqueue(23); //add 23 on myQueue
myQueue->enqueue(8);
delete myQueue; //delete will call ~Queue();
}The destructor is called in delete function
- Class-Writer: If heap memory is used (through new() operator) in the class (constructor) a destructor must be used to delete the memory - Class users are NOT responsible for the garbage collection of memory they did not explicitly create
- For each new() operation, one must use a delete somewhere to delete the memory created by the new()