Interface-like behavior in C++ - Mini Project: Build & Apply

Interface-like Behavior in C++

📖 Scenario: Imagine you are building a simple program to manage different types of devices that can be turned on and off. Each device should have a way to turn it on and off, but the exact way might be different for each device.

🎯 Goal: You will create a basic interface-like behavior in C++ using abstract classes. You will define a class with pure virtual functions and then create classes that implement these functions. Finally, you will use these classes to turn devices on and off.

📋 What You'll Learn

Create an abstract class called Device with two pure virtual functions: turnOn() and turnOff().

Create a class called Light that inherits from Device and implements turnOn() and turnOff().

Create a class called Fan that inherits from Device and implements turnOn() and turnOff().

Create a pointer of type Device* to point to objects of Light and Fan and call their turnOn() and turnOff() methods.

Print messages to show which device is turning on or off.

💡 Why This Matters

🌍 Real World

Many programs use interface-like behavior to handle different objects in a uniform way, such as controlling various hardware devices or managing different types of user inputs.

💼 Career

Understanding abstract classes and polymorphism is essential for software development jobs, especially in C++ programming for systems, games, and applications requiring flexible design.

1

Create the abstract class Device

Create an abstract class called Device with two pure virtual functions: turnOn() and turnOff(). Both functions should return void and have no parameters.

C++

// Define the abstract class Device with pure virtual functions turnOn() and turnOff()
// Your code here

Hint

Use virtual keyword and = 0 to make functions pure virtual.

2

Create the Light class inheriting Device

Create a class called Light that inherits from Device. Implement the turnOn() method to print "Light is turned ON" and the turnOff() method to print "Light is turned OFF".

C++

#include 

class Device {
public:
    virtual void turnOn() = 0;
    virtual void turnOff() = 0;
    virtual ~Device() = default;
};

// Define class Light inheriting Device and implement turnOn() and turnOff()
// Your code here

Hint

Use override keyword to show you are implementing the base class methods.

3

Create the Fan class inheriting Device

Create a class called Fan that inherits from Device. Implement the turnOn() method to print "Fan is turned ON" and the turnOff() method to print "Fan is turned OFF".

C++

#include 

class Device {
public:
    virtual void turnOn() = 0;
    virtual void turnOff() = 0;
    virtual ~Device() = default;
};

class Light : public Device {
public:
    void turnOn() override {
        std::cout << "Light is turned ON" << std::endl;
    }
    void turnOff() override {
        std::cout << "Light is turned OFF" << std::endl;
    }
};

// Define class Fan inheriting Device and implement turnOn() and turnOff()
// Your code here

Hint

Follow the same pattern as the Light class for Fan.

4

Use Device pointers to control Light and Fan

Create a Device* pointer called device. Point it to a Light object and call turnOn() and turnOff(). Then point device to a Fan object and call turnOn() and turnOff(). Print the output.

C++

#include 

class Device {
public:
    virtual void turnOn() = 0;
    virtual void turnOff() = 0;
    virtual ~Device() = default;
};

class Light : public Device {
public:
    void turnOn() override {
        std::cout << "Light is turned ON" << std::endl;
    }
    void turnOff() override {
        std::cout << "Light is turned OFF" << std::endl;
    }
};

class Fan : public Device {
public:
    void turnOn() override {
        std::cout << "Fan is turned ON" << std::endl;
    }
    void turnOff() override {
        std::cout << "Fan is turned OFF" << std::endl;
    }
};

// Create a Device* pointer called device
// Point it to Light and call turnOn() and turnOff()
// Point it to Fan and call turnOn() and turnOff()
// Your code here

Hint

Use a pointer of type Device* to point to objects of Light and Fan. Call their methods using the pointer.

Practice

1. What is the main purpose of an interface-like class in C++?

easy

A. To store data members for derived classes

B. To provide full function implementations for reuse

C. To define functions that derived classes must implement

D. To create objects directly without inheritance

Solution

1. Step 1: Understand interface concept

   Interfaces specify what functions a class must have but do not provide their code.

2. Step 2: Identify interface role in C++

   In C++, interfaces are created using pure virtual functions that derived classes must implement.

3. Final Answer:

   To define functions that derived classes must implement -> Option C

4. Quick Check:

   Interface = function declarations only [OK]

Hint: Interfaces declare required functions without code [OK]

Common Mistakes:

• Thinking interfaces provide function code
• Assuming interfaces hold data members
• Believing interfaces can be instantiated

2. Which of the following is the correct syntax to declare a pure virtual function in a C++ class?

easy

A. virtual void func() = 0;

B. virtual void func();

C. void func() override;

D. virtual void func() = 1;

Solution

1. Step 1: Recall pure virtual function syntax

   Pure virtual functions are declared with '= 0' after the function signature.

2. Step 2: Check options for correct syntax

   virtual void func() = 0; uses '= 0' correctly, others do not match pure virtual syntax.

3. Final Answer:

   virtual void func() = 0; -> Option A

4. Quick Check:

   Pure virtual = '= 0' [OK]

Hint: Pure virtual functions end with '= 0;' [OK]

Common Mistakes:

• Using '= 1' instead of '= 0'
• Omitting 'virtual' keyword
• Confusing override with pure virtual

3. Consider the following code:

class IShape {
public:
    virtual double area() const = 0;
};

class Circle : public IShape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override { return 3.14 * radius * radius; }
};

int main() {
    Circle c(2);
    std::cout << c.area();
    return 0;
}

What is the output of this program?

medium

A. 4

B. Compilation error

C. 3.14

D. 12.56

Solution

1. Step 1: Calculate area of circle with radius 2

   Area = π * r² = 3.14 * 2 * 2 = 12.56

2. Step 2: Confirm code compiles and runs correctly

   Circle implements pure virtual function area(), so no error; output is area value.

3. Final Answer:

   12.56 -> Option D

4. Quick Check:

   Area = 3.14 * 4 = 12.56 [OK]

Hint: Calculate area formula carefully [OK]

Common Mistakes:

• Forgetting to implement pure virtual function
• Using wrong radius value
• Expecting compilation error

4. What is wrong with this code snippet?

class IAnimal {
public:
    virtual void speak() = 0;
};

class Dog : public IAnimal {
public:
    void speak() { std::cout << "Woof"; }
};

int main() {
    IAnimal a;
    a.speak();
    return 0;
}

medium

A. Missing override keyword in Dog::speak()

B. Cannot create object of abstract class IAnimal

C. speak() should return a value

D. Dog class must be abstract

Solution

1. Step 1: Identify abstract class usage

   IAnimal has a pure virtual function, so it is abstract and cannot be instantiated.

2. Step 2: Check main() for object creation

   Code tries to create IAnimal a; which is illegal and causes compilation error.

3. Final Answer:

   Cannot create object of abstract class IAnimal -> Option B

4. Quick Check:

   Abstract class objects cannot be created [OK]

Hint: Abstract classes cannot be instantiated [OK]

Common Mistakes:

• Ignoring abstract class instantiation rules
• Thinking override keyword is mandatory
• Assuming pure virtual functions must return values

5. You want to create an interface-like class IPrinter with a pure virtual function print(). Then create two classes ConsolePrinter and FilePrinter that implement print(). Which of the following code snippets correctly demonstrates this?

hard

A. class IPrinter {
public:
virtual void print() = 0;
};

class ConsolePrinter : public IPrinter {
public:
void print() override { std::cout << "Console output"; }
};

class FilePrinter : public IPrinter {
public:
void print() override { /* write to file */ }
};

B. class IPrinter {
public:
void print() { }
};

class ConsolePrinter : public IPrinter {
public:
void print() { std::cout << "Console output"; }
};

C. class IPrinter {
public:
virtual void print();
};

class ConsolePrinter : public IPrinter {
};

D. class IPrinter {
public:
virtual void print() = 1;
};

Solution

1. Step 1: Define interface with pure virtual function

   IPrinter declares print() as pure virtual with '= 0', making it an interface.

2. Step 2: Implement print() in derived classes

   ConsolePrinter and FilePrinter override print() with their own code, fulfilling interface contract.

3. Final Answer:

   Code snippet D correctly defines interface and implementations -> Option A

4. Quick Check:

   Pure virtual = 0 + override implementations [OK]

Hint: Use '= 0' for pure virtual and override in derived [OK]

Common Mistakes:

• Using '= 1' instead of '= 0' for pure virtual
• Not implementing pure virtual functions in derived classes
• Defining interface functions with bodies