1. Class and Objects
In a class, all the functions that operate on the data structure are grouped together in one place along with the data
Like a struct in C but with the addition of functions
An Object is an instance of a class
Objects share the same functions with other objects of the same class, but each object or instance has its own copy of the data structure I.e, the member data

2. Member Functions
These are functions declared within a class definition
They are referred to as methods of the class
Member Functions may be public or private (as can member data)

3. Public and Private
A public member (data or function) is one that can be read or written (data) or called (functions) by anybody
A private member can only be read, written, or called by a member function of the class

4. Class Example 1
class Stack { public: void Push(int value); int top; int stack[10]; }; void Stack::Push(int value) { ASSERT(top < 10); stack[top++] = value; }

5. Class Example 1
The Stack class has two data members and one member function
All of these are public
If we have a pointer “s” to a Stack object we can access top by doing like so
s->top = 5;
If top were private we'd still be able to modify it through the member function Push as it increments the top variable and is public

6. Class Example 2
class Stack { public: void Push(int value); bool Full(); int top; int stack[10]; }; bool Stack::Full() { return (top == 10); } void Stack::Push(int value) { ASSERT(!(this->Full())); stack[top++] = value;

7. Class Example 2
You can get a pointer to the current object that has been called by using the this keyword
Note that the this is not necessary as it is implicit

8. Class Example 3
class Stack { public: void Push(int value); bool Full(); private: int top; int stack[10]; };

9. Class Example 3 In this example, all data members are private
Private Members are only visible to member functions of the class
all data members are only accessible by the member functions Full() and Push(int)
It is suggested that data members remain private if possible

10. Constructors and the "new" operator
In C one uses the malloc() function to allocate memory on the heap
In C++ we use the new Operator
C might look like this
struct Stack * s = (struct Stack *)malloc(sizeof(struct Stack));
InitStack(s, 17);
C++ would look like this
Stack * s = new Stack(17);

11. Constructors and the “new” operator – Example 4
class Stack { public: Stack(int sz); void Push(int value); bool Full(); private: int size; int top; int * stack; };

12. Example 4 continued.
// constructor Stack::Stack(int sz) { size = sz; top = 0; stack = new int[size]; }

13. Example 4 – The Constructor
To specify how an object is initialized we write a constructor for it as a member function.
This member function has the same name as the class name i.e, Stack().
Stack(int) is the constructor in this example

14. Constructors and new Operator
The new operator automatically allocates space for the object and calls the constructor for the new object
If you declare an automatic variable then the object space is allocated on the stack and the constructor is called

15. Final words on new and constructors
Notice the constructor does not have a return value
Always define a constructor and always initialize all data members
If you do not create a constructor one is automatically defined (not recommended)

16. Destructors and delete operator
delete is to new as free() is to malloc()
TO destroy an object allocated with the new operator do:
delete s;
This deallocates the object but first calls the destructor.
The destructor, like the constructor as it is a member function of the Stack class and is called ~Stack()

17. Example 5
class Stack { public: Stack(int sz); ~Stack(); void Push(int value); bool Full(); private: int size; int top; int * stack; };

18. Example 5 Continued Stack::~Stack() { delete [] stack; }
Notice: to delete the whole allocated array the [] comes after delete and before the array variable name.
The Destructor is used to deallocate data allocated by the constructor.
It is not always necessary to define one.

19. Pointers! Pointers hold or store an address in memory
Pointers may point to any type
Assigning one pointer to another causes both pointers to point to the same location in memory, hence the same data or object

20. Pointers! - Example
void main() { int* x; // Allocate the pointers x and y int* y; // (but not the pointees) x = malloc(sizeof(int)); // Allocate an int pointee, // and set x to point to it *x = 42; // Dereference x to store 42 in its pointee *y = 13; // CRASH -- y does not have a pointee yet y = x; // Pointer assignment sets y to point to x's pointee *y = 13; // Dereference y to store 13 in its (shared) pointee }

21. Pointers – Example (with “new”)
void main() { int* x; // Allocate the pointers x and y int* y; // (but not the pointees) x = new int; // Allocate an int pointee, // and set x to point to it *x = 42; // Dereference x to store 42 in its pointee *y = 13; // CRASH -- y does not have a pointee yet y = x; // Pointer assignment sets y to point to x's pointee *y = 13; // Dereference y to store 13 in its (shared) pointee }

22. Question
At the end of the above code, y is set to have a pointee and then dereferenced it store the number 13 into its pointee. After this happens, what is the value of x's pointee?

23. Answer
The value of x's pointee is 13 because it is also y's pointee. This is what sharing is all about -- multiple pointers pointing to one pointee.

24. Question 2
Write some code that creates the above pointer structure in C++ using the new operator.

25. Answer
int* x; int* y; x = new int; y = new int; *x = 1; *y = 2; x = y;