C++ Exception Handling & Templates Interview Questions

In modern C++, developers aim to write programs that do not easily break, can be reused in different situations, and run efficiently. Two important features that help achieve this are:

• Exception Handling: C++ supports a structured error-handling which ensures that runtime errors are caught and managed gracefully instead of crashing the program.
• Templates: Templates in C++ are a feature that allows you to write generic and reusable code. Instead of writing the same function or class multiple times for different data types (like int, float, double), you can use templates to create a single blueprint that works for any data type.

1. What is the difference between throw, try, and catch in C++?

In C++, exceptions are handled using three keywords:

• throw is used to signal an exception.
• try defines a block of code that may throw exceptions.
• catch defines a block to handle exceptions thrown from the try block.

Example:

2. What are templates in C++? Explain their importance.

• Templates allow writing generic and reusable code.
• They enable functions and classes to operate with different data types without rewriting code.
• Two types:
  • Function templates – for generic functions.
  • Class templates – for generic classes or data structures.
• Syntax example: template <typename T> T add(T a, T b) { return a + b; }

Example:

This function works for int, float, and other types that support the + operator.

3. What are standard exceptions in C++? List some common types.

C++ provides a hierarchy of standard exceptions in the <exception> and <stdexcept> headers. These are predefined classes derived from the base class std::exception and can be used to represent common errors.

Some commonly used standard exceptions:

• std::exception – Base class for all exceptions
• std::bad_alloc – Thrown when memory allocation fails (new)
• std::out_of_range – For invalid array or container indexing
• std::runtime_error – Represents errors at runtime
• std::invalid_argument – For invalid function arguments
• std::length_error, std::overflow_error, etc.

Example:

Using standard exceptions makes your code consistent and compatible with STL and third-party libraries.

4. How do you create a custom exception in C++? Give an example.

You can create a custom exception by defining a class that inherits from the std::exception class and overriding its what() method, which returns an error message.

Example:

Benefits:

• Provides clear error information
• Works seamlessly with standard exception handling
• Encourages structured and maintainable code

5. What is a function template in C++? Write a simple example.

A function template allows a function to operate on generic data types. It provides a way to write one function for multiple types, which is resolved at compile-time.

Syntax:

6. What is RAII in C++ and how does it relate to exception safety?

RAII (Resource Acquisition Is Initialization) is a design pattern where resources (like memory, file handles, sockets) are acquired in the constructor of an object and released in its destructor. RAII ensures automatic cleanup, even if an exception is thrown, making code exception-safe.

Example:

In this example, even if an error occurs, the file is properly closed when the object goes out of scope.

7. What is the use of the catch(...) block? How is it different from specific catch blocks?

The catch(...) block is used to catch any type of exception, regardless of its data type or class. It acts as a generic fallback handler.

Example:

Difference:

• catch(int e): catches only int exceptions
• catch(...): catches all exceptions, even if no matching type is found

It’s helpful when you want to ensure that no exception escapes unhandled, but it does not provide specific details about the exception type.

8. What is the difference between inline and constexpr in C++?

Example constexpr:

Example inline:

Use constexpr when the value is needed at compile-time, and inline when you want faster execution without function call overhead.

9. Can we catch a derived exception in a base catch block? What are the risks involved?

Yes, C++ allows catching derived exceptions using a base class reference (std::exception &). But object slicing or loss of specific information can occur if exceptions are not caught by reference or pointer.

Example:

10. What happens if an exception is thrown but not caught?

If an exception is thrown but not caught anywhere in the call stack, the program calls std::terminate(), which by default aborts execution. Exceptions can propagate up the call stack until a suitable catch block is found. If none is found, the program terminates.

Example:

Output:

terminate called after throwing an instance of 'int'
Aborted (core dumped)

This can lead to abrupt termination, loss of data, or unclean resource release. That's why it's critical to ensure every throw has a matching catch, either directly or through stack unwinding.

11. What is stack unwinding in exception handling? Explain its role.

Stack unwinding is the process of cleaning up the call stack after an exception is thrown and before it is caught. During unwinding, destructors of all local objects are called in reverse order of construction, ensuring proper cleanup. This prevents resource leaks and enforces RAII (Resource Acquisition Is Initialization).

Why is it important?

• Prevents memory/resource leaks
• Ensures safe destruction of objects
• Supports RAII (Resource Acquisition Is Initialization)

Example:

Output:

Constructor
Destructor
Exception caught

This shows that even when an exception occurs, destructors are called properly to clean up resources.

12. What is the difference between throw; and throw ex; inside a catch block?

• throw: rethrows the currently handled exception exactly as it is, and can only be used inside a catch block.
• throw ex: throws a copy of the exception object ex, which may lead to slicing if ex is of a derived type but caught as a base type.

Example:

throw; preserves the original exception type and stack trace, which is important for advanced debugging and exception chaining.

13. What is the use of noexcept in C++ exception handling?

The noexcept keyword specifies that a function does not throw exceptions. It makes intent clear to both the compiler and developers. If a noexcept function does throw, std::terminate() is called. noexcept is especially important for move constructors and destructors, where it enables optimizations such as exception-safe move operations in standard containers.

Example:

Benefits:

• Faster execution (compiler skips setting up exception-handling code)
• Clear documentation of function behavior
• Can cause std::terminate() if the function throws anyway

noexcept is especially important in move constructors and destructors in modern C++.

14. What will happen if you throw an exception from a destructor?

Throwing an exception from a destructor during stack unwinding (i.e., while handling another exception) results in a call to std::terminate(), which aborts the program.

Example:

Avoid throwing from destructors, especially when exceptions are active. Use std::uncaught_exceptions() (C++17) or try-catch inside destructor to suppress.

15. Can function templates be partially specialized in C++? If not, what is the alternative?

Function templates cannot be partially specialized, only fully specialized. Partial specialization is only supported for class templates. To achieve similar behavior with functions, you can use overloading, SFINAE (Substitution Failure Is Not An Error), or tools like std::enable_if and if constexpr to tailor behavior for specific categories of types.

Example (Alternative using enable_if):

Using std::enable_if, we mimic specialization behavior for functions based on type traits, allowing cleaner and type-specific implementations.

16. What happens when you throw a pointer vs. throw an object in C++?

Throwing a pointer means you're throwing an address. It won’t trigger automatic destruction of the object pointed to, and catching it requires catching the same pointer type. Throwing by value creates a copy, and cleanup is automatic.

Example:

Throwing objects ensures RAII and automatic cleanup. Throwing pointers must be handled with care to avoid memory leaks.

17. Can a function template throw an exception based on the type it is instantiated with?

Yes. Templates can use static_assert or if constexpr to control logic at compile-time based on type, and can throw exceptions conditionally at runtime.

Example:

Templates can adapt behavior based on type at compile time. Combining this with runtime exception logic adds powerful type-aware safety mechanisms.