Object Oriented Advanced
Basics
Syntax of Inheritance
x
1
#include <iostream>2
3
using namespace std;4
5
// Base class (Parent class)6
class Base {7
public:8
void parent_class_function() {9
cout << "This is the base class method." << endl;10
}11
};12
13
// Derived class (Child class) that inherits from the Base class publically14
class Derived : public Base {15
public:16
void child_class_function() {17
cout << "This is the derived class method." << endl;18
}19
};20
21
// Derived -> Base22
int main() {23
Derived derived_obj;24
25
// Calling method from the base class26
derived_obj.parent_class_function();27
28
// Calling method from the derived class29
derived_obj.child_class_function();30
31
return 0;32
}Advanced: Adapter pattern
We can get a little creative with the inheritance syntax and deploy an "Adapter pattern":
50
1
#include <iostream>2
#include <string>3
4
using namespace std;5
6
// Existing class (Adaptee)7
class LegacyMediaPlayer {8
public:9
void play_mp3(const string& filename) {10
cout << "Playing MP3 file: " << filename << endl;11
}12
};13
14
// Target interface15
class AdvancedMediaPlayer {16
public:17
void play_mp4(const string& filename) {18
cout << "This player does not support MP4 files." << endl;19
}20
21
void play_vlc(const string& filename) {22
cout << "This player does not support VLC files." << endl;23
}24
};25
26
// Adapter class using private inheritance27
class MediaPlayerAdapter : private LegacyMediaPlayer, public AdvancedMediaPlayer {28
public:29
void play_mp4(const string& filename) {30
// For simplicity, convert MP4 to MP3 (dummy implementation)31
cout << "Converting MP4 to MP3..." << endl;32
LegacyMediaPlayer::play_mp3(filename + ".converted.mp3");33
}34
35
void play_vlc(const string& filename) {36
// For simplicity, convert VLC to MP3 (dummy implementation)37
cout << "Converting VLC to MP3..." << endl;38
LegacyMediaPlayer::play_mp3(filename + ".converted.mp3");39
}40
};41
42
// Client code43
int main() {44
MediaPlayerAdapter player;45
46
player.play_mp4("example.mp4");47
player.play_vlc("example.vlc");48
49
return 0;50
}Basic Inheritance pattern
Let us learn by studying an example.
62
1
#include <iostream>2
#include <string>3
4
using namespace std;5
6
class Vehicle {7
// protected says that inheriting class will have access to these members8
// but users of the class will not9
protected:10
string brand;11
int year;12
void protected_method() { std::cout << "protected method" << std::endl; }13
14
public:15
Vehicle(string b, int y) : brand(b), year(y) {}16
17
virtual void display_info() {18
cout << "Brand: " << brand << ", Year: " << year << endl;19
}20
};21
22
void example() {23
Vehicle v("name", 2020);24
//v.brand = "123"; // Can't do because brand is private, only inheriting child class can access it25
//v.protected_method(); // Can't do this because this method is not public26
}27
28
class Car : public Vehicle {29
private:30
int doors;31
32
public:33
Car(string b, int y, int d) : Vehicle(b, y), doors(d) {}34
35
void display_info() override {36
cout << "Car - Brand: " << Vehicle::brand << 37
", Year: " << Vehicle::year <<38
", Doors: " << doors << endl;39
}40
};41
42
class Motorcycle : public Vehicle {43
private:44
string type;45
46
public:47
Motorcycle(string b, int y, string t) : Vehicle(b, y), type(t) {}48
49
void display_info() override {50
cout << "Motorcycle - Brand: " << brand << ", Year: " << year << ", Type: " << type << endl;51
}52
};53
54
int main() {55
Car car("Toyota", 2020, 4);56
Motorcycle motorcycle("Yamaha", 2019, "Sport");57
58
car.display_info();59
motorcycle.display_info();60
61
return 0;62
}Abstract classes
Override
A base class can define method(s) that could have override behavior:
13
1
class Animal {2
public:3
virtual void speak() {4
std::cout << "Some generic animal sound" << endl;5
}6
};7
8
class another_animal : public Animal {9
public:10
void speak() { /* Intent is to override the base, parent class */11
std::cout << "I speak differently" << std::endl;12
}13
};One question to ask in the code snippet above is that what happens if the base class changes its method name? In this case, the intent was for another_animal to override, but it no longer overrides anything. This is the reason the override keyword was invented.
14
1
class Animal {2
public:3
//virutal void speak() { /* Case changes: */4
virtual void Speak() {5
std::cout << "Some generic animal sound" << endl;6
}7
};8
9
class another_animal : public Animal {10
public:11
void speak() { /* This overrides the base class function */12
std::cout << "I speak differently" << std::endl;13
}14
};Let us use C++11 syntax to use the override keyword and see what happens when a method is intending to override a function but it doesn't do so:
14
1
class Animal {2
public:3
//virutal void speak() { /* Case changes: */4
virtual void Speak() {5
std::cout << "Some generic animal sound" << endl;6
}7
};8
9
class another_animal : public Animal {10
public:11
void speak() override { /* This overrides the base class function */12
std::cout << "I speak differently" << std::endl;13
}14
};Pure Virtual
A base class can provide default functionality or mandate that the child class inheriting the base (parent) class has to provide a certain functionality. It would look like this:
11
1
class Animal {2
public:3
virtual void speak() = 0; /* I do not know how to speak, someone else tell me how */4
};5
6
class dolphin : public Animal {7
public:8
void speak() override {9
std::cout << "I am a dolphin and I can whistle" << std::endl;10
}11
};Example 1
25
1
#include <iostream>2
using namespace std;3
4
class Animal {5
public:6
virtual void speak() = 0;7
};8
9
class Dog : public Animal {10
public:11
void speak() override { // Overriding the base class function12
cout << "Woof!" << endl;13
}14
};15
16
class Cat : public Animal {17
public:18
void speak() override { // Overriding the base class function19
cout << "Meow!" << endl;20
}21
};22
23
void speak(Animal& animal) {24
animal.speak();25
}Example 2
49
1
#include <iostream>2
#include <vector>3
4
class Shape {5
public:6
// Virtual function to be overridden by derived classes7
virtual void draw() const {8
std::cout << "Drawing a shape\n";9
}10
11
// Virtual destructor to ensure proper cleanup of derived objects12
virtual ~Shape() {}13
};14
15
class Circle : public Shape {16
public:17
void draw() const override {18
std::cout << "Drawing a circle\n";19
}20
};21
22
class Rectangle : public Shape {23
public:24
void draw() const override {25
std::cout << "Drawing a rectangle\n";26
}27
};28
29
int main() {30
// Create a vector of Shape pointers31
std::vector<Shape*> shapes;32
33
// Add different shapes to the vector34
shapes.push_back(new Circle());35
shapes.push_back(new Rectangle());36
shapes.push_back(new Circle());37
38
// Iterate through the vector and call the draw method39
for (const auto& shape : shapes) {40
shape->draw(); // Polymorphic call41
}42
43
// Clean up the allocated memory44
for (auto& shape : shapes) {45
delete shape;46
}47
48
return 0;49
}Video Game Example
56
1
#include <iostream>2
#include <vector>3
#include <memory>4
5
// Base class6
class Character {7
public:8
virtual void attack() const {9
std::cout << "Character attacks in a generic way.\n";10
}11
12
virtual ~Character() {}13
};14
15
// Derived class: Warrior16
class Warrior : public Character {17
public:18
void attack() const override {19
std::cout << "Warrior swings a sword!\n";20
}21
};22
23
// Derived class: Mage24
class Mage : public Character {25
public:26
void attack() const override {27
std::cout << "Mage casts a fireball!\n";28
}29
};30
31
// Derived class: Archer32
class Archer : public Character {33
public:34
void attack() const override {35
std::cout << "Archer shoots an arrow!\n";36
}37
};38
39
int main() {40
// Create a vector of unique_ptr to Character41
std::vector<std::unique_ptr<Character>> characters;42
43
// Add different types of characters to the vector44
characters.push_back(std::make_unique<Warrior>());45
characters.push_back(std::make_unique<Mage>());46
characters.push_back(std::make_unique<Archer>());47
48
// Iterate through the vector and call the attack method49
for (const auto& character : characters) {50
character->attack(); // Polymorphic call51
}52
53
// No need to delete characters; unique_ptr handles it automatically54
55
return 0;56
}Interfaces
An interface abstracts the implementation and enables unit-testing on the code. In other words, an interface is an abstract class that decouples the implementation from the interface, which allows changing or adding new implementations without affecting the rest of the program.
Polymorphism: The code below demonstrates polymorphism through the use of the interface. The test_communication function can take any object that implements the Communicable interface, showcasing how polymorphism enables the writing of more flexible and reusable code.
Example 1
In the example below, the interface ensures that any class that implements it will have a send method, but does not commit to how the sending is done, which is polymorphic.
35
1
#include <iostream>2
3
// Interface class with a single responsibility4
class Communicable {5
public:6
virtual void send(const std::string& message) = 0; // Only one pure virtual function7
virtual ~Communicable() {} // Virtual destructor for proper cleanup8
};9
10
class WiFiDevice : public Communicable {11
public:12
void send(const std::string& message) override {13
std::cout << "Sending over WiFi: " << message << std::endl;14
}15
};16
17
class BluetoothDevice : public Communicable {18
public:19
void send(const std::string& message) override {20
std::cout << "Sending over Bluetooth: " << message << std::endl;21
}22
};23
24
void test_communication(Communicable& device, const std::string& message) {25
device.send(message); // Use the send method to demonstrate communication26
}27
28
int main() {29
WiFiDevice wifi;30
BluetoothDevice bluetooth;31
32
testCommunication(wifi, "Hello WiFi World");33
testCommunication(bluetooth, "Hello Bluetooth World");34
return 0;35
}Example 2
24
1
#include <iostream>2
#include <vector>3
#include <memory>4
5
// Interface class6
class GameCharacter {7
public:8
virtual void attack() = 0; // Pure virtual function9
virtual void defend() = 0; // Pure virtual function10
virtual void heal() = 0; // Pure virtual function11
virtual int get_health() const = 0; // Pure virtual function to get health12
13
virtual ~GameCharacter() {}14
};15
16
void perform_action(GameCharacter& character) {17
if (character.get_health() < 30) {18
character.heal();19
} else if (rand() % 2 == 0) { // 50% chance to attack or defend20
character.attack();21
} else {22
character.defend();23
}24
}Exercise
Let us continue working on the examples below and practice more uses of interfaces.
- Create an interface that returns low threshold level for health
- Create an interface that returns when a character should attack
- Write two classes that inherit and implement the GameCharacter class
- Write a main function to invoke
perform_action()on the two classes