C++ Interview Questions and Answers (Part-E)

Part-E of C++ interview questions with new answers:

41. What is the use of the volatile keyword in C++?

• The volatile keyword indicates to the compiler that a variable’s value may change at any time without any action being taken by the code the compiler finds nearby. This is useful when working with hardware registers or variables shared between multiple threads.

42. What are C++ namespaces, and how do they prevent naming conflicts?

• C++ namespaces are used to group related classes, functions, and variables under a single name. They help prevent naming conflicts by providing a way to differentiate between entities with the same name but defined in different namespaces.

43. How is function overloading resolved during compilation in C++?

• Function overloading is resolved based on the number, type, and order of arguments provided to the function. The compiler determines the most appropriate function to call based on the function signature that matches the given arguments.

44. What is the purpose of the typename keyword in C++ templates?

• The typename keyword is used in templates to specify that a dependent name represents a type. It is required when defining a nested type within a template or when using a dependent type inside a template definition.

45. How do you implement a copy assignment operator in C++?

• The copy assignment operator is used to perform a deep copy of an object. It is typically implemented as a member function with the following signature:

   ClassName& operator=(const ClassName& other);

It is responsible for copying the data members from the other object to the current object and handling self-assignment.

46. Explain the C++ override and final keywords.

• The override keyword is used to explicitly indicate that a function is intended to override a virtual function in the base class. It helps catch potential errors at compile-time when the function signature does not match any virtual function in the base class.
• The final keyword is used to prevent further overriding of a virtual function in a derived class. Once a function is marked as final, it cannot be overridden by any further derived classes.

47. How do you implement multithreading in C++?

• Multithreading in C++ can be achieved using the <thread> header and the std::thread class. You can create a new thread by passing a function or callable object to the std::thread constructor. C++ provides synchronization primitives like std::mutex and std::condition_variable to manage thread synchronization and avoid data races.

48. Explain the difference between std::make_shared and std::shared_ptr in C++.

• std::make_shared is a utility function that creates a std::shared_ptr and the associated object in a single memory allocation. It is more efficient and safer than calling std::shared_ptr directly, as it ensures proper deallocation of the object even if an exception is thrown during construction.

49. How can you prevent memory leaks in C++?

• To prevent memory leaks in C++, always ensure that memory allocated with new is deallocated with delete (for single objects) or delete[] (for arrays). Alternatively, use smart pointers (std::shared_ptr, std::unique_ptr) to manage resources automatically and safely.

50. What are C++ Lambda Captures? Explain capture-by-value and capture-by-reference.

• C++ Lambdas can capture variables from the enclosing scope. There are two types of captures:
  • Capture by Value ([var]): Captures a copy of the variable var. Changes to the captured variable inside the lambda do not affect the original variable.
  • Capture by Reference ([&var]): Captures the variable var by reference. Changes to the captured variable inside the lambda affect the original variable.

Remember to study these questions thoroughly and practice coding problems to build confidence for your C++ interviews. Good luck!