OOP principles overview in C++ - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this C++ code demonstrating encapsulation?

Consider this C++ class that uses encapsulation to protect its data.

class Box {
private:
    int length;
public:
    void setLength(int len) { length = len; }
    int getLength() { return length; }
};

int main() {
    Box box;
    box.setLength(10);
    std::cout << box.getLength() << std::endl;
    return 0;
}

What will this program print?

C++

#include <iostream>
class Box {
private:
    int length;
public:
    void setLength(int len) { length = len; }
    int getLength() { return length; }
};

int main() {
    Box box;
    box.setLength(10);
    std::cout << box.getLength() << std::endl;
    return 0;
}

A Undefined behavior due to uninitialized variable

B 0

C Compilation error due to private member access

D 10

💡 Hint

Think about how the setter and getter methods control access to the private variable.

The private variable length is set using the public method setLength. Then getLength returns the value 10, so the output is 10.

❓ Predict Output

intermediate

What is the output of this C++ code demonstrating inheritance?

Look at this code with a base class and a derived class:

class Animal {
public:
    void speak() { std::cout << "Animal speaks" << std::endl; }
};

class Dog : public Animal {
public:
    void speak() { std::cout << "Dog barks" << std::endl; }
};

int main() {
    Dog dog;
    dog.speak();
    return 0;
}

What will this program print?

C++

#include <iostream>
class Animal {
public:
    void speak() { std::cout << "Animal speaks" << std::endl; }
};

class Dog : public Animal {
public:
    void speak() { std::cout << "Dog barks" << std::endl; }
};

int main() {
    Dog dog;
    dog.speak();
    return 0;
}

A Dog barks

B Compilation error due to method overriding

C Animal speaks

D Runtime error due to ambiguous call

💡 Hint

Which class's speak method is called on the Dog object?

The Dog class overrides the speak method. Calling dog.speak() calls the Dog version, printing "Dog barks".

❓ Predict Output

advanced

What is the output of this C++ code demonstrating polymorphism with virtual functions?

Consider this code using virtual functions:

class Base {
public:
    virtual void show() { std::cout << "Base show" << std::endl; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived show" << std::endl; }
};

int main() {
    Base* ptr = new Derived();
    ptr->show();
    delete ptr;
    return 0;
}

What will this program print?

C++

#include <iostream>
class Base {
public:
    virtual void show() { std::cout << "Base show" << std::endl; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived show" << std::endl; }
};

int main() {
    Base* ptr = new Derived();
    ptr->show();
    delete ptr;
    return 0;
}

A Derived show

B Base show

C Compilation error due to virtual function

D Runtime error due to invalid pointer

💡 Hint

Virtual functions allow the program to decide which method to call at runtime.

The pointer ptr is of type Base* but points to a Derived object. Because show is virtual, the Derived version is called, printing "Derived show".

❓ Predict Output

advanced

What is the output of this C++ code demonstrating abstraction with pure virtual functions?

Look at this abstract class example:

class Shape {
public:
    virtual void draw() = 0; // pure virtual function
};

class Circle : public Shape {
public:
    void draw() override { std::cout << "Drawing Circle" << std::endl; }
};

int main() {
    Circle c;
    c.draw();
    return 0;
}

What will this program print?

C++

#include <iostream>
class Shape {
public:
    virtual void draw() = 0; // pure virtual function
};

class Circle : public Shape {
public:
    void draw() override { std::cout << "Drawing Circle" << std::endl; }
};

int main() {
    Circle c;
    c.draw();
    return 0;
}

A Compilation error due to abstract class instantiation

B Drawing Circle

C Runtime error due to pure virtual function call

D No output, program hangs

💡 Hint

Can you create an object of the abstract class? What about the derived class?

The abstract class Shape cannot be instantiated, but Circle implements draw. Creating a Circle object and calling draw prints "Drawing Circle".

🧠 Conceptual

expert

Which OOP principle is best demonstrated by this C++ code snippet?

Consider this code:

class Logger {
public:
    void log(const std::string& message) {
        std::cout << "Log: " << message << std::endl;
    }
};

class FileLogger : public Logger {
public:
    void log(const std::string& message) {
        // code to write message to a file
        std::cout << "File log: " << message << std::endl;
    }
};

Which OOP principle does this best illustrate?

C++

#include <iostream>
#include <string>
class Logger {
public:
    void log(const std::string& message) {
        std::cout << "Log: " << message << std::endl;
    }
};

class FileLogger : public Logger {
public:
    void log(const std::string& message) {
        // code to write message to a file
        std::cout << "File log: " << message << std::endl;
    }
};

A Encapsulation - hiding data inside classes

B Polymorphism - using the same interface with different behaviors

C Inheritance - reusing code from a base class

D Abstraction - hiding complex implementation details

💡 Hint

Look at how FileLogger relates to Logger.

FileLogger inherits from Logger, reusing and extending its functionality. This is an example of inheritance.