Lecture 14 - Oct 6, 2023
Summary
In this lecture, we continue on our discussion of dynamic memory allocation of arrays of objects. We also introduce the concept of operator overloading.
Last lecture
Dynamic memory allocation of arrays.
Today
Continue dynamic memory allocation of objects and operator overloading.
Dynamic allocation
Can we dynamically allocate an array of objects? Yes
class Student {
public:
string name;
int ID;
Student() { ID = 0; name = ""; }
~Student() { cout << "Destructor" << endl; }
};
int main() {
Student *arr = new Student[3]; // default constructor called 3 times
delete [] arr; // destructor called 3 times
return 0; // no destructor will be called without delete
}Can I have an array of pointers to objects? Yes
int main() {
// no constructors called
Student** arr2p = new Student* [3];
...
...
for (int i = 0, i < 3; i++) {
arr2p[i] = new Student;
}
...
...
for (int i = 0, i < 3; i++) {
arr2p[i]->ID = i + 1;
}
...
...
for (int i = 0, i < 3; i++) {
delete arr2p[i];
}
...
...
delete [] arr2p;
arr2p = NULL;Overloading operators (+, -, *, /)
Consider this class
class Complex {
private:
double real;
double img;
public:
Complex() { real = 0.0; img = 0.0; }
Complex(double r, double i) { real = r; img = i; }
};
int main() {
Complex x(3,4);
Complex y(5,6);
Complex z;
z = x + y; // I can't do this now
return 0;
}Operator overloading allows for z = x + y.
There are two operators: = and +.
Let’s implement a function that does an addition.
x + y is also equivalent to x.operator+(y).
// return type: Complex
// function name: operator+
Complex Complex::operator+(Complex &rhs) {
return Complex(real + rhs.real, img + rhs.img);
}
class Complex P{
private:
double real;
double img;
public:
Complex() { real = 0.0; img = 0.0; }
Complex(double r, double i) { real = r; img = i; }
// pass by reference: Complex&
Complex operator+(Complex& rhs);
}Passing by value will create a copy of the rhs.
This is memory inefficient if the object has many data members.
Pass by value will not create a copy, so it is memory efficient.
Good practices for safety
Pass the object as a constant object
Complex Complex::operator+(const Complex& rhs) {
rhs.real = 0; // compile-time error!
return Complex(real + rhs.real, img + rhs.img);
}Operator+ does not change members of the object
Use const modifier to prevent changes to members of the object.
Complex Complex::operator+(const Complex& rhs) const {
real = 0; // compile-time error!
return Complex(real + rhs.real, img + rhs.img);
}Ungraded homework
Solve the exercises of Chapter 4: Pointers and Chapter 5: Dynamic Memory Allocation.
Chapter 4
Chapter 5
Question 9 in Fall 2021 Midterm Exam [Intermediate]
Consider the code shown below. You can assume it compiles with no errors and runs.
#include <iostream>
using namespace std;
int a = 0;
int* b = &a;
int** c = &b;
int* foo(int** d) {
(**d)++;
b = *d;
int* e = new int;
*e = 10;
return e;
}
int main() {
int* g = nullptr;
int* f = new int;
*f = 5;
a++;
// Point 1
g = foo(&f);
a++;
(*g)++;
// Point 2
return 0;
}In the table below, give the values of the variables indicated in the table columns when program execution reaches each of the two points, Point 1 and Point 2. If a value cannot be obtained due to dereferencing a nullptr pointer, write nullptr (but assume the program does not stop).
| | a | *b | **c | *g | *f |
|---------|---|----|-----|----|----|
| Point 1 | | | | | |
| Point 2 | | | | | |
:::
::: {.callout-note icon=false collapse="true"}
## Solution
| | a | *b | **c | *g | *f |
|---------|---|----|-----|---------|----|
| Point 1 | 1 | 1 | 1 | nullptr | 5 |
| Point 2 | 2 | 6 | 6 | 11 | 6 |
:::
::: {.callout-note icon=false}
## Exercise 3
Question 10 in Fall 2022 Midterm Exam [Challenging]
A Vtuber is an online entertainer who posts videos on Vtube. A Vtuber will have
followers on Vtube. As a programmer from Vtube, you are asked to implement a
class for Vtuber. The class definition and description are described below.
```cpp
#include <string>
using namespace std;
class Follower {
private:
string name;
int age;
public:
Follower(const string& _name, int _age) {
name = name_;
age = age_;
}
string get_name() const { return name; }
int get_age() const { return age; }
};
class Vtuber {
private:
// Vtuber Name
string name;
// Follower array with a variable size, each element should be a dynamically
// allocated object of class Follower.
Follower** followers;
// The size of follower array.
int follower_max;
// Number of followers
int follower_num;
public:
Vtuber(const string& _name);
~Vtuber();
void insert_follower(const string& follower_name, int follower_age);
void remove_follower(const string& follower_name);
};Specifically, Vtuber’s followers member variable is an array of pointers, each pointer pointing to a Follower object. The following graph illustrates it.
Part 1
Implement the constructor for Vtuber. Vtuber name should be initialized by _name, and follower_max should be initialized to 2. In addition, you should allocate an array called followers using new, with an initial size of 2 (the value of follower_max). Every element in this array should be a pointer to an object of class Follower and initialize all these pointers to NULL.
Part 2
Every Vtuber in Vtube can get new followers or lose their current followers. This is implemented by two methods: insert_follower and remove_follower. Now you are asked to implement these two methods:
- For
remove_follower, a follower name is given. If there is any follower in the array matching the name, you should remove it and free its memory usingdelete. You can assume the follower names are all unique. - For
remove_follower, a follower name is given. If there is any follower in the array matching the name, you should remove it and free its memory usingdelete. You can assume the follower names are all unique.
Part 3
Implement the destructor for the Vtuber class. You should free all the dynamically allocated objects using delete. Remember to be consistent with your previous implementation, as the entire program should not trigger any segmentation fault.