OOP principles overview in C++

Introduction

OOP helps organize code by grouping related data and actions together. It makes programs easier to understand and change.

When you want to model real-world things like cars or animals in your program.

When your program has many parts that work together and share data.

When you want to reuse code without rewriting it.

When you want to protect data so it can only be changed in safe ways.

When you want to make your code easier to fix or add new features.

Syntax

C++

class ClassName {
  access_specifier:
    // data members
    // member functions
};

Classes are blueprints for objects.

Access specifiers like public and private control what parts can be used outside the class.

Examples

This class has a public function drive and a private data member speed.

C++

class Car {
public:
  void drive();
private:
  int speed;
};

This shows inheritance: Dog is an Animal and can have its own speak method.

C++

class Animal {
public:
  virtual void speak();
};

class Dog : public Animal {
public:
  void speak() override;
};

Sample Program

This program shows inheritance and method overriding. The Dog class changes how speak works.

C++

#include <iostream>
using namespace std;

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

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

int main() {
  Animal a;
  Dog d;

  a.speak();  // Calls Animal's speak
  d.speak();  // Calls Dog's speak

  return 0;
}

Important Notes

Encapsulation means keeping data safe inside classes.

Inheritance lets one class use features of another.

Polymorphism means using the same function name for different behaviors.

Abstraction hides complex details and shows only what is needed.

Summary

OOP groups data and actions into classes and objects.

Four main principles: encapsulation, inheritance, polymorphism, abstraction.

OOP makes code easier to manage and reuse.

Practice

1. Which of the following is NOT one of the four main principles of Object-Oriented Programming (OOP)?

easy

A. Encapsulation

B. Compilation

C. Polymorphism

D. Inheritance

Solution

1. Step 1: Recall the four main OOP principles

   The four main principles are encapsulation, inheritance, polymorphism, and abstraction.

2. Step 2: Identify the option not in the list

   Compilation is a process of converting code, not an OOP principle.

3. Final Answer:

   Compilation -> Option B

4. Quick Check:

   OOP principles exclude compilation [OK]

Hint: Remember the four OOP pillars: E, I, P, A [OK]

Common Mistakes:

• Confusing compilation with abstraction
• Mixing OOP principles with programming processes

2. Which keyword is used in C++ to create a new class?

easy

A. class

B. struct

C. object

D. define

Solution

1. Step 1: Identify the C++ keyword for defining a class

   In C++, the keyword to define a class is class.

2. Step 2: Check other options

   struct defines a structure, object is not a keyword, and define is for macros.

3. Final Answer:

   class -> Option A

4. Quick Check:

   Use class to define classes [OK]

Hint: Use 'class' keyword to define classes in C++ [OK]

Common Mistakes:

• Confusing struct with class
• Using 'object' as a keyword
• Mixing macros with class definition

3. What will be the output of the following C++ code?

class Animal {
public:
    void sound() { std::cout << "Animal sound"; }
};

class Dog : public Animal {
public:
    void sound() { std::cout << "Bark"; }
};

int main() {
    Animal* a = new Dog();
    a->sound();
    delete a;
    return 0;
}

medium

A. Runtime error

B. Bark

C. Compilation error

D. Animal sound

Solution

1. Step 1: Understand method call without virtual keyword

   The sound method is not virtual, so the pointer type Animal* calls Animal's method.

2. Step 2: Determine output

   Since sound is not virtual, Animal sound is printed.

3. Final Answer:

   Animal sound -> Option D

4. Quick Check:

   Non-virtual method calls base class method [OK]

Hint: Without virtual, base class method runs [OK]

Common Mistakes:

• Assuming polymorphism without virtual
• Expecting derived class method call
• Ignoring pointer type effect

4. Identify the error in the following C++ code snippet:

class Vehicle {
private:
    int speed;
public:
    void setSpeed(int s) { speed = s; }
};

int main() {
    Vehicle v;
    v.speed = 100;
    return 0;
}

medium

A. setSpeed method is not defined

B. Missing semicolon after class definition

C. Cannot access private member 'speed' directly

D. Vehicle object not created properly

Solution

1. Step 1: Check access to private member

   The member speed is private and cannot be accessed directly outside the class.

2. Step 2: Identify the error in main()

   Trying to assign v.speed = 100; causes an access violation error.

3. Final Answer:

   Cannot access private member 'speed' directly -> Option C

4. Quick Check:

   Private members need public methods for access [OK]

Hint: Private members can't be accessed outside class [OK]

Common Mistakes:

• Trying to access private variables directly
• Ignoring access specifiers
• Assuming public by default

5. You want to design a C++ class hierarchy where a base class Shape defines a method area() but each derived class calculates area differently. Which OOP principle does this best demonstrate?

hard

A. Polymorphism

B. Inheritance

C. Encapsulation

D. Abstraction

Solution

1. Step 1: Understand the scenario of different area calculations

   Each derived class implements area() differently, but shares the same interface.

2. Step 2: Identify the OOP principle

   This is polymorphism: same method name, different behaviors in subclasses.

3. Final Answer:

   Polymorphism -> Option A

4. Quick Check:

   Same method, different behaviors = Polymorphism [OK]

Hint: Different behaviors, same method name = polymorphism [OK]

Common Mistakes:

• Confusing with inheritance or abstraction
• Thinking encapsulation means method overriding