![\"cpp](\"https:\/\/www.placementpreparation.io\/blog\/wp-content\/uploads\/2024\/05\/cpp-beginners-course-desktop-banner-horizontal.webp\")
<\/a><\/p>Practice C++ Interview Questions and Answers<\/h2>
Below are the top 50 C++ interview questions for freshers with answers:<\/p>
1. Write a C++ program to swap two numbers without using a third variable.<\/h3>
Answer:<\/strong><\/p> Use arithmetic operations to swap values directly without needing extra space.<\/p> int a = 5, b = 10; Answer:<\/strong><\/p> Use a loop to swap characters from the beginning and end of the string until you reach the middle.<\/p> std::string str = “Hello”; Answer:<\/strong><\/p> Reverse the number and compare it with the original to check for palindrome property.<\/p> bool isPalindrome(int num) { Answer:<\/strong><\/p> Define a recursive function that multiplies the current number by the factorial of the previous number until it reaches 1.<\/p> int factorial(int n) { Answer:<\/strong><\/p> Compare the numbers pairwise and store the largest one at each step.<\/p> int largest(int a, int b, int c) { Answer:<\/strong><\/p> Define a class with private attributes and public methods to set and get the attribute values.<\/p> class Student { public: Answer:<\/strong><\/p> Create multiple constructors within a class to initialize objects in different ways.<\/p> class Rectangle { public: Answer:<\/strong><\/p> Derive a new class from an existing class using the public<\/strong> inheritance specifier.<\/p> class Base { class Derived : public Base { Answer:<\/strong><\/p> Define multiple functions with the same name but different parameters.<\/p> class Math { Answer:<\/strong><\/p> Create a base class with a virtual function and derive classes that override this function.<\/p> class Base { class Derived : public Base { Base* basePtr = new Derived(); Answer:<\/strong><\/p> Use new<\/strong> to allocate memory and delete[]<\/strong> to deallocate it.<\/p> int* arr = new int[10]; Answer:<\/strong><\/p> Define a Node<\/strong> structure and use pointers to link the nodes together.<\/p> struct Node { void insertAtBeginning(Node*& head, int newData) { Answer:<\/strong><\/p> Use pointer increment to traverse the array.<\/p> int arr[] = {1, 2, 3, 4, 5}; Answer:<\/strong><\/p> Use the std::unique_ptr<\/strong> from the C++ Standard Library to manage dynamic memory automatically.<\/p> #include <memory> Answer:<\/strong><\/p> A memory leak occurs when allocated memory is not properly deallocated. It can be avoided by ensuring that all allocated memory is deleted.<\/p> int* ptr = new int(10); Answer:<\/strong><\/p> Use the std::stack<\/strong> container adapter to implement a stack.<\/p> #include <stack> Answer:<\/strong><\/p> Use the std::max_element<\/strong> algorithm to find the maximum element.<\/p> #include <vector> Answer:<\/strong><\/p> Use std::sort<\/strong> with a custom comparator.<\/p> #include <vector> Answer:<\/strong><\/p> Use the std::count<\/strong> algorithm to count occurrences.<\/p> #include <list> Answer:<\/strong><\/p> Use std::set_union<\/strong> to merge two sets.<\/p> #include <set> Answer:<\/strong><\/p> Use a loop to repeatedly divide the array and narrow down the search range.<\/p> int binarySearch(int arr[], int size, int key) { Answer:<\/strong><\/p> Use an array to store elements and manage front and rear indices for queue operations.<\/p> class Queue { Answer:<\/strong><\/p> Use a divide-and-conquer approach to partition the array and recursively sort the subarrays.<\/p> void quickSort(int arr[], int low, int high) { int partition(int arr[], int low, int high) { Answer:<\/strong><\/p> Define a Node<\/strong> structure and write a function to insert nodes based on value comparison.<\/p> struct Node { Node* insert(Node* root, int data) { Answer:<\/strong><\/p> Use a priority queue to explore the graph and update the shortest paths to each node.<\/p> #include <vector> void dijkstra(std::vector<std::vector<std::pair<int, int>>> &graph, int src, int V) { while (!pq.empty()) { for (auto &neighbor : graph[u]) { Answer:<\/strong><\/p> Use ifstream<\/strong> for reading and ofstream<\/strong> for writing.<\/p> #include <fstream> void copyFile(const std::string &inputFile, const std::string &outputFile) { while (std::getline(inFile, line)) { Answer:<\/strong><\/p> Use file streams to read the file word by word and count the occurrences.<\/p> #include <fstream> int countWords(const std::string &filename) { while (inFile >> word) { Answer:<\/strong><\/p> Use ifstream<\/strong> and ofstream<\/strong> with the ios::binary<\/strong> flag to handle binary files.<\/p> #include <fstream><\/p>\n struct Data { void writeBinary(const std::string &filename) { void readBinary(const std::string &filename) { Answer:<\/strong><\/p> Use ofstream<\/strong> with the ios::app<\/strong> flag to append data to a file.<\/p> #include <fstream> void appendToFile(const std::string &filename, const std::string &text) { Answer:<\/strong><\/p> Use file streams to serialize (write) and deserialize (read) an object’s data.<\/p> #include <fstream><\/p>\n class MyClass { void serialize(const std::string &filename) { void deserialize(const std::string &filename) { Answer:<\/strong><\/p> Use std::thread<\/strong> to create and manage threads.<\/p> #include <thread> void printNumbers() { void printLetters() { int main() { Answer:<\/strong><\/p> Use std::mutex<\/strong> to protect access to the shared resource.<\/p> #include <thread> int counter = 0; void incrementCounter() { int main() { Answer:<\/strong><\/p> Use std::condition_variable<\/strong> to synchronize the producer and consumer threads.<\/p> #include <queue> std::queue<int> q; void producer() { void consumer() { int main() { Answer:<\/strong><\/p> Create a pool of worker threads that can execute tasks from a task queue.<\/p> #include <iostream> class ThreadPool { private: void workerThread(); ThreadPool::ThreadPool(size_t numThreads) : stop(false) { ThreadPool::~ThreadPool() { void ThreadPool::enqueueTask(std::function<void()> task) { void ThreadPool::workerThread() { int main() { Answer:<\/strong><\/p> Use std::future<\/strong> and std::promise<\/strong> to handle asynchronous operations and retrieve their results.<\/p> #include <iostream> int asyncTask(std::promise<int> &promiseObj) { int main() { Answer:<\/strong><\/p> Define a function template using the template<\/strong> keyword.<\/p> template <typename T> Answer:<\/strong><\/p> Use a class template to define a stack that works with any data type.<\/p> template <typename T> public: Answer:<\/strong><\/p> Define a derived class that inherits from multiple base classes.<\/p> class Base1 { class Base2 { class Derived : public Base1, public Base2 { int main() { Answer:<\/strong><\/p> Use std::function<\/strong> to store a callable entity and invoke it later.<\/p> #include <iostream> void myCallback(int x) { int main() { Answer:<\/strong><\/p> Use lambda expressions to define inline functions that can capture variables.<\/p> #include <iostream><\/p>\n int main() { Answer:<\/strong><\/p> Define a custom exception class and use try<\/strong>, catch<\/strong>, and throw<\/strong> to handle exceptions.<\/p> class MyException : public std::exception { int main() { Answer:<\/strong><\/p> Use multiple catch<\/strong> blocks to handle different types of exceptions.<\/p> int main() { Answer:<\/strong><\/p> Use RAII (Resource Acquisition Is Initialization) to manage resources safely.<\/p> class ResourceGuard { int main() { Answer:<\/strong><\/p> Define an enum for error codes and return these from functions to indicate success or failure.<\/p> enum class ErrorCode { ErrorCode performOperation(int data) { Answer:<\/strong><\/p> Use std::exception_ptr<\/strong> to capture and propagate exceptions across threads.<\/p> #include <iostream> std::exception_ptr eptr;<\/p>\n void threadFunc() { int main() { Answer:<\/strong><\/p> Use a static<\/strong> function to return the single instance of the class and protect it with a std::mutex<\/strong>.<\/p> class Singleton { public: static Singleton *getInstance() { Singleton *Singleton::instance = nullptr; Answer:<\/strong><\/p> Use a factory method to create and return different types of objects.<\/p> class Shape { class Circle : public Shape { class Square : public Shape { class ShapeFactory { int main() { Answer:<\/strong><\/p> Use a subject class to maintain a list of observers and notify them of state changes.<\/p> #include <iostream> class Observer { class Subject { public: class ConcreteObserver : public Observer { int main() { Answer:<\/strong><\/p> Define a strategy interface and implement different strategies that can be selected dynamically.<\/p> class SortStrategy {
\na = a + b;
\nb = a – b;
\na = a – b;<\/p>\n<\/div><\/div>2. How would you reverse a given string in C++ without using the reverse() function?<\/h3>
\nint n = str.length();
\nfor (int i = 0; i < n \/ 2; i++) {
\nstd::swap(str[i], str[n – i – 1]);
\n}<\/p>\n<\/div><\/div>3. Write a C++ function to check if a given number is a palindrome.<\/h3>
\nint original = num, reversed = 0;
\nwhile (num > 0) {
\nint digit = num % 10;
\nreversed = reversed * 10 + digit;
\nnum \/= 10;
\n}
\nreturn original == reversed;
\n}<\/p>\n<\/div><\/div>4. How do you calculate the factorial of a number using recursion in C++?<\/h3>
\nif (n <= 1) return 1;
\nreturn n * factorial(n – 1);
\n}<\/p>\n<\/div><\/div>5. Write a C++ program to find the largest of three numbers using a simple if-else construct.<\/h3>
\nif (a > b && a > c) return a;
\nelse if (b > c) return b;
\nelse return c;
\n}<\/p>\n<\/div><\/div>6. How do you implement a basic class in C++ to represent a Student with attributes like name and roll number?<\/h3>
\nprivate:
\nstd::string name;
\nint rollNumber;<\/p>\n
\nvoid setName(std::string n) { name = n; }
\nvoid setRollNumber(int r) { rollNumber = r; }
\nstd::string getName() { return name; }
\nint getRollNumber() { return rollNumber; }
\n};<\/p>\n<\/div><\/div>7. Write a C++ program to demonstrate constructor overloading with an example.<\/h3>
\nprivate:
\nint width, height;<\/p>\n
\nRectangle() : width(0), height(0) {}
\nRectangle(int w, int h) : width(w), height(h) {}
\nint area() { return width * height; }
\n};<\/p>\n<\/div><\/div>8. How would you implement single inheritance in C++? Demonstrate with a Base and Derived class.<\/h3>
\npublic:
\nvoid show() { std::cout << “Base class\\n”; }
\n};<\/p>\n
\npublic:
\nvoid display() { std::cout << “Derived class\\n”; }
\n};<\/p>\n<\/div><\/div>9. Write a C++ program that demonstrates the concept of function overloading.<\/h3>
\npublic:
\nint add(int a, int b) { return a + b; }
\ndouble add(double a, double b) { return a + b; }
\n};<\/p>\n<\/div><\/div>10. How would you implement polymorphism in C++ using a base class pointer and virtual functions?<\/h3>
\npublic:
\nvirtual void show() { std::cout << “Base class\\n”; }
\n};<\/p>\n
\npublic:
\nvoid show() override { std::cout << “Derived class\\n”; }
\n};<\/p>\n
\nbasePtr->show(); \/\/ Outputs “Derived class”<\/p>\n<\/div><\/div>11. Write a C++ program to dynamically allocate memory for an array and deallocate it.<\/h3>
\n\/\/ Use the array
\ndelete[] arr;<\/p>\n<\/div><\/div>12. How do you implement a simple linked list in C++ using pointers? Write the code to insert a node at the beginning.<\/h3>
\nint data;
\nNode* next;
\n};<\/p>\n
\nNode* newNode = new Node();
\nnewNode->data = newData;
\nnewNode->next = head;
\nhead = newNode;
\n}<\/p>\n<\/div><\/div>13. Write a C++ program to demonstrate the concept of pointer arithmetic by iterating over an array.<\/h3>
\nint* ptr = arr;
\nfor (int i = 0; i < 5; ++i) {
\nstd::cout << *(ptr + i) << ” “;
\n}<\/p>\n<\/div><\/div>14. How do you implement a smart pointer in C++? Write a basic unique_ptr implementation.<\/h3>
\nstd::unique_ptr<int> ptr(new int(5));
\n\/\/ No need to manually delete the memory<\/p>\n<\/div><\/div>15. What is a memory leak, and how can it be avoided in C++? Demonstrate a situation that could lead to a memory leak and how to prevent it.<\/h3>
\n\/\/ Forgot to delete the memory
\n\/\/ delete ptr; \/\/ Prevent memory leak<\/p>\n<\/div><\/div>16. How do you implement a stack using STL in C++? Provide an example of basic stack operations like push and pop.<\/h3>
\nstd::stack<int> s;
\ns.push(10);
\ns.push(20);
\nint top = s.top(); \/\/ 20
\ns.pop(); \/\/ Removes 20<\/p>\n<\/div><\/div>17. Write a C++ program to find the maximum element in a vector using STL.<\/h3>
\n#include <algorithm>
\nstd::vector<int> v = {10, 20, 30, 40};
\nint maxElem = *std::max_element(v.begin(), v.end());<\/p>\n<\/div><\/div>18. How do you sort a list of strings in descending order using STL in C++?<\/h3>
\n#include <algorithm>
\nstd::vector<std::string> vec = {“apple”, “banana”, “cherry”};
\nstd::sort(vec.begin(), vec.end(), std::greater<std::string>());<\/p>\n<\/div><\/div>19. Write a C++ program to count the occurrences of a specific element in a list using STL.<\/h3>
\n#include <algorithm>
\nstd::list<int> lst = {1, 2, 3, 2, 4, 2};
\nint count = std::count(lst.begin(), lst.end(), 2); \/\/ 3 occurrences of 2<\/p>\n<\/div><\/div>20. How would you merge two sets in C++ using STL? Provide a code example that merges two std::set containers.<\/h3>
\n#include <algorithm>
\nstd::set<int> set1 = {1, 2, 3};
\nstd::set<int> set2 = {3, 4, 5};
\nstd::set<int> result;
\nstd::set_union(set1.begin(), set1.end(), set2.begin(), set2.end(),
\nstd::inserter(result, result.begin()));<\/p>\n<\/div><\/div>21. Write a C++ program to implement binary search on a sorted array.<\/h3>
\nint left = 0, right = size – 1;
\nwhile (left <= right) {
\nint mid = left + (right – left) \/ 2;
\nif (arr[mid] == key) return mid;
\nif (arr[mid] < key) left = mid + 1;
\nelse right = mid – 1;
\n}
\nreturn -1;
\n}<\/p>\n<\/div><\/div>22. How do you implement a basic queue using an array in C++? Provide the code for enqueue and dequeue operations.<\/h3>
\nprivate:
\nint arr[100];
\nint front, rear;
\npublic:
\nQueue() : front(0), rear(0) {}
\nvoid enqueue(int data) { arr[rear++] = data; }
\nint dequeue() { return arr[front++]; }
\n};<\/p>\n<\/div><\/div>23. Write a C++ program to sort an array using the quicksort algorithm.<\/h3>
\nif (low < high) {
\nint pi = partition(arr, low, high);
\nquickSort(arr, low, pi – 1);
\nquickSort(arr, pi + 1, high);
\n}
\n}<\/p>\n
\nint pivot = arr[high];
\nint i = (low – 1);
\nfor (int j = low; j <= high – 1; j++) {
\nif (arr[j] < pivot) {
\ni++;
\nstd::swap(arr[i], arr[j]);
\n}
\n}
\nstd::swap(arr[i + 1], arr[high]);
\nreturn (i + 1);
\n}<\/p>\n<\/div><\/div>24. How would you implement a binary tree in C++? Write the code for inserting a node into a binary tree.<\/h3>
\nint data;
\nNode* left, *right;
\nNode(int val) : data(val), left(nullptr), right(nullptr) {}
\n};<\/p>\n
\nif (root == nullptr) return new Node(data);
\nif (data < root->data) root->left = insert(root->left, data);
\nelse root->right = insert(root->right, data);
\nreturn root;
\n}<\/p>\n<\/div><\/div>25. Write a C++ program to find the shortest path in a graph using Dijkstra’s algorithm.<\/h3>
\n#include <queue>
\n#include <climits><\/p>\n
\nstd::vector<int> dist(V, INT_MAX);
\ndist[src] = 0;
\nstd::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<>> pq;
\npq.push({0, src});<\/p>\n
\nint u = pq.top().second;
\npq.pop();<\/p>\n
\nint v = neighbor.first, weight = neighbor.second;
\nif (dist[u] + weight < dist[v]) {
\ndist[v] = dist[u] + weight;
\npq.push({dist[v], v});
\n}
\n}
\n}
\n}<\/p>\n<\/div><\/div>26. How do you read and write to a text file in C++? Provide an example that reads a file line by line and writes the content to another file.<\/h3>
\n#include <string><\/p>\n
\nstd::ifstream inFile(inputFile);
\nstd::ofstream outFile(outputFile);
\nstd::string line;<\/p>\n
\noutFile << line << “\\n”;
\n}
\n}<\/p>\n<\/div><\/div>27. Write a C++ program to count the number of words in a text file.<\/h3>
\n#include <string><\/p>\n
\nstd::ifstream inFile(filename);
\nstd::string word;
\nint count = 0;<\/p>\n
\ncount++;
\n}
\nreturn count;
\n}<\/p>\n<\/div><\/div>28. How do you handle binary files in C++? Write a program to read and write binary data.<\/h3>
\nint id;
\nchar name[20];
\n};<\/p>\n
\nstd::ofstream outFile(filename, std::ios::binary);
\nData d = {1, “Example”};
\noutFile.write(reinterpret_cast<char*>(&d), sizeof(Data));
\n}<\/p>\n
\nstd::ifstream inFile(filename, std::ios::binary);
\nData d;
\ninFile.read(reinterpret_cast<char*>(&d), sizeof(Data));
\n}<\/p>\n<\/div><\/div>29. Write a C++ program to append text to an existing file without overwriting its content.<\/h3>
\n#include <string><\/p>\n
\nstd::ofstream outFile(filename, std::ios::app);
\noutFile << text << “\\n”;
\n}<\/p>\n<\/div><\/div>30. How do you serialize and deserialize an object in C++ using file handling? Provide an example of saving and loading a class object to\/from a file.<\/h3>
\npublic:
\nint id;
\nchar name[20];<\/p>\n
\nstd::ofstream outFile(filename, std::ios::binary);
\noutFile.write(reinterpret_cast<char*>(this), sizeof(MyClass));
\n}<\/p>\n
\nstd::ifstream inFile(filename, std::ios::binary);
\ninFile.read(reinterpret_cast<char*>(this), sizeof(MyClass));
\n}
\n};<\/p>\n<\/div><\/div>31. How do you create and manage threads in C++ using the Standard Library? Write a program to run two threads concurrently.<\/h3>
\n#include <iostream><\/p>\n
\nfor (int i = 1; i <= 5; i++) {
\nstd::cout << i << ” “;
\n}
\n}<\/p>\n
\nfor (char c = ‘A’; c <= ‘E’; c++) {
\nstd::cout << c << ” “;
\n}
\n}<\/p>\n
\nstd::thread t1(printNumbers);
\nstd::thread t2(printLetters);
\nt1.join();
\nt2.join();
\nreturn 0;
\n}<\/p>\n<\/div><\/div>32. Write a C++ program that uses a mutex to ensure thread-safe access to a shared variable.<\/h3>
\n#include <mutex>
\n#include <iostream><\/p>\n
\nstd::mutex mtx;<\/p>\n
\nstd::lock_guard<std::mutex> lock(mtx);
\n++counter;
\n}<\/p>\n
\nstd::thread t1(incrementCounter);
\nstd::thread t2(incrementCounter);
\nt1.join();
\nt2.join();
\nstd::cout << “Counter: ” << counter << std::endl;
\nreturn 0;
\n}<\/p>\n<\/div><\/div>33. How do you implement a producer-consumer problem in C++ using threads? Provide a simple implementation using condition variables.<\/h3>
\n#include <thread>
\n#include <mutex>
\n#include <condition_variable>
\n#include <iostream><\/p>\n
\nstd::mutex mtx;
\nstd::condition_variable cv;<\/p>\n
\nfor (int i = 1; i <= 5; i++) {
\nstd::unique_lock<std::mutex> lock(mtx);
\nq.push(i);
\ncv.notify_one();
\n}
\n}<\/p>\n
\nfor (int i = 1; i <= 5; i++) {
\nstd::unique_lock<std::mutex> lock(mtx);
\ncv.wait(lock, [] { return !q.empty(); });
\nint val = q.front();
\nq.pop();
\nstd::cout << “Consumed: ” << val << std::endl;
\n}
\n}<\/p>\n
\nstd::thread t1(producer);
\nstd::thread t2(consumer);
\nt1.join();
\nt2.join();
\nreturn 0;
\n}<\/p>\n<\/div><\/div>34. Write a C++ program that demonstrates the use of a thread pool for parallel processing.<\/h3>
\n#include <vector>
\n#include <thread>
\n#include <queue>
\n#include <functional>
\n#include <condition_variable><\/p>\n
\npublic:
\nThreadPool(size_t numThreads);
\n~ThreadPool();
\nvoid enqueueTask(std::function<void()> task);<\/p>\n
\nstd::vector<std::thread> workers;
\nstd::queue<std::function<void()>> tasks;
\nstd::mutex mtx;
\nstd::condition_variable cv;
\nbool stop;<\/p>\n
\n};<\/p>\n
\nfor (size_t i = 0; i < numThreads; ++i) {
\nworkers.emplace_back([this] { workerThread(); });
\n}
\n}<\/p>\n
\n{
\nstd::unique_lock<std::mutex> lock(mtx);
\nstop = true;
\n}
\ncv.notify_all();
\nfor (std::thread &worker : workers) {
\nworker.join();
\n}
\n}<\/p>\n
\n{
\nstd::unique_lock<std::mutex> lock(mtx);
\ntasks.push(task);
\n}
\ncv.notify_one();
\n}<\/p>\n
\nwhile (true) {
\nstd::function<void()> task;
\n{
\nstd::unique_lock<std::mutex> lock(mtx);
\ncv.wait(lock, [this] { return stop || !tasks.empty(); });
\nif (stop && tasks.empty()) return;
\ntask = std::move(tasks.front());
\ntasks.pop();
\n}
\ntask();
\n}
\n}<\/p>\n
\nThreadPool pool(4);
\npool.enqueueTask([] { std::cout << “Task 1\\n”; });
\npool.enqueueTask([] { std::cout << “Task 2\\n”; });
\npool.enqueueTask([] { std::cout << “Task 3\\n”; });
\npool.enqueueTask([] { std::cout << “Task 4\\n”; });
\nreturn 0;
\n}<\/p>\n<\/div><\/div>35. How do you use futures and promises in C++ to manage asynchronous operations? Write a program that demonstrates their use.<\/h3>
\n#include <future><\/p>\n
\nint result = 10 * 2;
\npromiseObj.set_value(result);
\nreturn result;
\n}<\/p>\n
\nstd::promise<int> promiseObj;
\nstd::future<int> futureObj = promiseObj.get_future();
\nstd::thread t(asyncTask, std::ref(promiseObj));
\nstd::cout << “Result: ” << futureObj.get() << std::endl;
\nt.join();
\nreturn 0;
\n}<\/p>\n<\/div><\/div>36. How do you implement a template function in C++? Write a template function that swaps two values of any data type.<\/h3>
\nvoid swapValues(T &a, T &b) {
\nT temp = a;
\na = b;
\nb = temp;
\n}<\/p>\n<\/div><\/div>37. Write a C++ program that demonstrates the use of template classes by creating a generic stack class.<\/h3>
\nclass Stack {
\nprivate:
\nstd::vector<T> elements;<\/p>\n
\nvoid push(const T &element) { elements.push_back(element); }
\nvoid pop() { elements.pop_back(); }
\nT top() const { return elements.back(); }
\nbool isEmpty() const { return elements.empty(); }
\n};<\/p>\n<\/div><\/div>38. How do you implement multiple inheritance in C++? Write a program that demonstrates multiple inheritance with two base classes and one derived class.<\/h3>
\npublic:
\nvoid show() { std::cout << “Base1\\n”; }
\n};<\/p>\n
\npublic:
\nvoid display() { std::cout << “Base2\\n”; }
\n};<\/p>\n
\n};<\/p>\n
\nDerived d;
\nd.show();
\nd.display();
\nreturn 0;
\n}<\/p>\n<\/div><\/div>39. Write a C++ program that demonstrates the use of the std::function to store and invoke a callback function.<\/h3>
\n#include <functional><\/p>\n
\nstd::cout << “Callback called with value: ” << x << std::endl;
\n}<\/p>\n
\nstd::function<void(int)> callback = myCallback;
\ncallback(10);
\nreturn 0;
\n}<\/p>\n<\/div><\/div>40. How do you use lambda expressions in C++? Write a program that captures variables by value and by reference in a lambda.<\/h3>
\nint a = 10, b = 20;
\nauto add = [a, &b]() {
\nb = b + a;
\nreturn b;
\n};
\nstd::cout << “Sum: ” << add() << std::endl;
\nreturn 0;
\n}<\/p>\n<\/div><\/div>41. Write a C++ program that demonstrates exception handling by throwing and catching a custom exception.<\/h3>
\npublic:
\nconst char *what() const noexcept override {
\nreturn “My custom exception”;
\n}
\n};<\/p>\n
\ntry {
\nthrow MyException();
\n} catch (const MyException &e) {
\nstd::cout << e.what() << std::endl;
\n}
\nreturn 0;
\n}<\/p>\n<\/div><\/div>42. How do you handle multiple exceptions in C++? Provide an example where you catch different types of exceptions.<\/h3>
\ntry {
\nthrow 10;
\n} catch (int e) {
\nstd::cout << “Caught integer exception: ” << e << std::endl;
\n} catch (double e) {
\nstd::cout << “Caught double exception: ” << e << std::endl;
\n}
\nreturn 0;
\n}<\/p>\n<\/div><\/div>43. Write a C++ program that uses a try-catch-finally like mechanism to ensure that resources are released even if an exception is thrown.<\/h3>
\npublic:
\nResourceGuard() { std::cout << “Acquiring resource\\n”; }
\n~ResourceGuard() { std::cout << “Releasing resource\\n”; }
\n};<\/p>\n
\ntry {
\nResourceGuard rg;
\nthrow std::runtime_error(“An error occurred”);
\n} catch (const std::exception &e) {
\nstd::cout << e.what() << std::endl;
\n}
\nreturn 0;
\n}<\/p>\n<\/div><\/div>44. How do you implement a custom error code handling mechanism in C++? Write a program that uses a custom error code enum to represent different error states.<\/h3>
\nSuccess,
\nNotFound,
\nPermissionDenied
\n};<\/p>\n
\nif (data < 0) return ErrorCode::NotFound;
\nif (data == 0) return ErrorCode::PermissionDenied;
\nreturn ErrorCode::Success;
\n}<\/p>\n<\/div><\/div>45. Write a C++ program that demonstrates the use of std::exception_ptr to rethrow an exception in a different thread.<\/h3>
\n#include <thread>
\n#include <exception><\/p>\n
\ntry {
\nthrow std::runtime_error(“Error in thread”);
\n} catch (…) {
\neptr = std::current_exception();
\n}
\n}<\/p>\n
\nstd::thread t(threadFunc);
\nt.join();
\nif (eptr) {
\ntry {
\nstd::rethrow_exception(eptr);
\n} catch (const std::exception &e) {
\nstd::cout << e.what() << std::endl;
\n}
\n}
\nreturn 0;
\n}<\/p>\n<\/div><\/div>46. How do you implement the Singleton pattern in C++? Provide a thread-safe implementation using std::mutex.<\/h3>
\nprivate:
\nstatic Singleton *instance;
\nstatic std::mutex mtx;
\nSingleton() {}<\/p>\n
\nSingleton(const Singleton &) = delete;
\nSingleton &operator=(const Singleton &) = delete;<\/p>\n
\nstd::lock_guard<std::mutex> lock(mtx);
\nif (!instance) {
\ninstance = new Singleton();
\n}
\nreturn instance;
\n}
\n};<\/p>\n
\nstd::mutex Singleton::mtx;<\/p>\n<\/div><\/div>47. Write a C++ program that demonstrates the Factory design pattern by creating different types of objects based on input parameters.<\/h3>
\npublic:
\nvirtual void draw() = 0;
\n};<\/p>\n
\npublic:
\nvoid draw() override { std::cout << “Drawing Circle\\n”; }
\n};<\/p>\n
\npublic:
\nvoid draw() override { std::cout << “Drawing Square\\n”; }
\n};<\/p>\n
\npublic:
\nstatic Shape *createShape(const std::string &type) {
\nif (type == “Circle”) return new Circle();
\nif (type == “Square”) return new Square();
\nreturn nullptr;
\n}
\n};<\/p>\n
\nShape *shape = ShapeFactory::createShape(“Circle”);
\nshape->draw();
\ndelete shape;
\nreturn 0;
\n}<\/p>\n<\/div><\/div>48. How do you implement the Observer pattern in C++? Write a program where observers are notified of state changes in the subject.<\/h3>
\n#include <vector><\/p>\n
\npublic:
\nvirtual void update(int state) = 0;
\n};<\/p>\n
\nprivate:
\nstd::vector<Observer *> observers;
\nint state;<\/p>\n
\nvoid attach(Observer *observer) { observers.push_back(observer); }
\nvoid setState(int newState) {
\nstate = newState;
\nnotifyAll();
\n}
\nvoid notifyAll() {
\nfor (Observer *observer : observers) {
\nobserver->update(state);
\n}
\n}
\n};<\/p>\n
\npublic:
\nvoid update(int state) override { std::cout << “State changed to: ” << state << std::endl; }
\n};<\/p>\n
\nSubject subject;
\nConcreteObserver observer1, observer2;
\nsubject.attach(&observer1);
\nsubject.attach(&observer2);
\nsubject.setState(10);
\nreturn 0;
\n}<\/p>\n<\/div><\/div>49. Write a C++ program that demonstrates the Strategy design pattern by implementing different sorting algorithms that can be selected at runtime.<\/h3>