Sample Questions and Answers Explained

This section provides detailed explanations for sample questions and answers commonly encountered in C++ exams. Understanding these questions will help you prepare effectively for your exams and improve your C++ programming skills.

Key Concepts

1. Function Overloading

Function overloading allows multiple functions with the same name but different parameters to coexist in the same scope. The compiler determines which function to call based on the arguments provided.

Example:

#include <iostream>

void print(int i) {
    std::cout << "Integer: " << i << std::endl;
}

void print(double d) {
    std::cout << "Double: " << d << std::endl;
}

int main() {
    print(5);    // Calls print(int)
    print(3.14); // Calls print(double)
    return 0;
}
    

2. Pointers and References

Pointers store the address of a variable, while references are aliases for existing variables. Understanding how to use and manipulate pointers and references is crucial in C++.

Example:

#include <iostream>

int main() {
    int x = 10;
    int* ptr = &x  // Pointer to x
    int& ref = x;   // Reference to x

    std::cout << "Value of x: " << x << std::endl;
    std::cout << "Value via pointer: " << *ptr << std::endl;
    std::cout << "Value via reference: " << ref << std::endl;

    *ptr = 20;  // Changing value via pointer
    std::cout << "New value of x: " << x << std::endl;

    ref = 30;   // Changing value via reference
    std::cout << "New value of x: " << x << std::endl;

    return 0;
}
    

3. Inheritance and Polymorphism

Inheritance allows a class to inherit properties and methods from another class, while polymorphism enables objects of different classes to be treated as objects of a common base class.

Example:

#include <iostream>

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

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Woof!" << std::endl;
    }
};

int main() {
    Animal* animal = new Dog();
    animal->makeSound();  // Calls Dog's makeSound()
    delete animal;
    return 0;
}
    

4. Templates

Templates allow functions and classes to operate with generic types. This enables code reuse and flexibility in handling different data types.

Example:

#include <iostream>

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << "Addition of integers: " << add(3, 4) << std::endl;
    std::cout << "Addition of doubles: " << add(3.5, 4.5) << std::endl;
    return 0;
}
    

5. Exception Handling

Exception handling allows you to manage errors and exceptional conditions in a structured way. It involves using try, catch, and throw keywords.

Example:

#include <iostream>

int divide(int a, int b) {
    if (b == 0) {
        throw "Division by zero error";
    }
    return a / b;
}

int main() {
    try {
        std::cout << divide(10, 2) << std::endl;
        std::cout << divide(10, 0) << std::endl;
    } catch (const char* msg) {
        std::cerr << msg << std::endl;
    }
    return 0;
}
    

Examples and Analogies

Example: Function Overloading in a Real-World Scenario

Imagine you are designing a library system. You might have a function called checkout that handles checking out books for different types of users (students, teachers, etc.). Each type of user might have different checkout limits, so you overload the checkout function to handle these cases.

Analogy: Pointers and References as Addresses and Aliases

Think of a pointer as a GPS coordinate that tells you where a variable is stored. A reference, on the other hand, is like an alias or nickname for the variable. Both allow you to access and modify the variable, but they do so in different ways.

Example: Inheritance and Polymorphism in a Real-World Scenario

Consider a vehicle manufacturing company. You might have a base class Vehicle with subclasses like Car and Truck. Each subclass inherits common properties from Vehicle but can override methods like startEngine to provide specific behavior.

Analogy: Templates as Generic Recipes

Templates are like generic recipes that can be used to cook different dishes (data types). For example, a recipe for making a cake can be used to make chocolate cake, vanilla cake, etc., depending on the ingredients (data types) you provide.

Example: Exception Handling in a Real-World Scenario

Imagine you are writing a program to handle financial transactions. You might have a function to transfer money between accounts. If the account balance is insufficient, you would throw an exception to handle this error gracefully.

Conclusion

Understanding and practicing these sample questions and answers will help you master key C++ concepts such as function overloading, pointers and references, inheritance and polymorphism, templates, and exception handling. These concepts are fundamental to writing robust and efficient C++ programs and are frequently tested in exams. By mastering these topics, you will be well-prepared for your C++ exams and future programming challenges.