Question

Define an exception class called tornadoException. The class should have two constructors, including the default constructor. If the exception is thrown with the default constructor, the method what should return "Tornado: Take cover immediately!". The other constructor has a single parameter, say, \(m\), of the int type. If the exception is thrown with this constructor, the method what should return "Tornado: m miles away; and approaching!"

Short answer

A `tornadoException` class is defined with a default and parameterized constructor, implementing `what()` to return appropriate messages.

Step-by-step solution

Define the Class

Create a new class named `tornadoException`. This class will inherit from the standard `exception` class in C++. Use `public` keyword to make it extend exception.

Implement Default Constructor

Inside `tornadoException`, define a default constructor that initializes an internal message to "Tornado: Take cover immediately!". This can be stored as a private member variable, say `message_`.

Implement Parameterized Constructor

Add a constructor that accepts an integer parameter `m`. This constructor should set the internal message to "Tornado: `m` miles away; and approaching!". Use `std::to_string(m)` to convert the integer to a string within the message.

Define the `what()` Method

Override the `what()` method from the `exception` class. This method should use the `message_` member variable from the constructors to return the appropriate string message.

Code Completion

Implement the class in C++ as follows: ```cpp #include #include class tornadoException : public std::exception { private: std::string message_; public: // Default constructor tornadoException() : message_("Tornado: Take cover immediately!") {} // Constructor with parameter tornadoException(int m) { message_ = "Tornado: " + std::to_string(m) + " miles away; and approaching!"; } // Override what() method const char* what() const noexcept override { return message_.c_str(); } }; ```

Key concepts

C++ Inheritance

In C++, inheritance is a foundational concept that allows a class, often called a derived or child class, to inherit properties and behaviors from another class known as the base or parent class. This mechanism is crucial for creating a hierarchy of classes that share common functionality, promoting code reusability and organization. By using the `public` keyword, as seen in the `tornadoException` class inheriting from `std::exception`, we ensure that the public and protected members of the parent class are accessible in the child class. This visibility is important because it allows the child class to utilize and sometimes override the inherited methods or properties while also extending its own functionalities.

It's similar to real-world objects: if you think of a base class as a general object like "vehicle," a derived class could be "car," which automatically has the general characteristics of a vehicle, but can also have additional, specific features that define a car.

Custom Exceptions

Creating custom exceptions in C++ involves defining a new class that typically inherits from the standard `std::exception` class. This is precisely what we do in the `tornadoException` class. By doing so, we can design exceptions with specific behavior and messages tailored to our program's needs, instead of relying on generic error messages that may not be as informative.

In the process of defining a custom exception, it's important to consider what information is necessary to convey when the exception is thrown. In our `tornadoException`, we can either issue a generalized warning or provide specific details about the tornado's approach by integrating a distance parameter. This versatility is part of custom exceptions' power, allowing developers to handle errors and alert users in a meaningful and contextual manner.

Constructor Overloading

Constructor overloading is a powerful feature in C++ that allows a class to have multiple constructors with different signatures. Each constructor can perform different tasks or initialize the object in various ways. In the `tornadoException` class, constructor overloading is used to define two constructors: one default and one parameterized.

The default constructor initializes a fixed warning message, while the parameterized constructor takes an integer `m` and constructs a message with dynamic content, reflecting how far the tornado is. This flexibility makes it easy to create objects that can represent different states or have different initial data, without requiring separate classes or complex logic.

To implement constructor overloading, simply declare multiple constructors within the same class, each with different parameters, ensuring the principle of uniqueness—meaning each constructor's signature should uniquely identify it through its parameter type or number.

Standard Exception Class

The standard exception class in C++ serves as a base class for all exceptions thrown by the Standard Library and user-defined exceptions. It provides a common interface and basic functionality that custom exception classes can extend. The `what()` method is a virtual function defined in the `std::exception` class, which custom exceptions can override to return a descriptive error message.

Using `std::exception` as the base class when creating custom exceptions, like with `tornadoException`, allows our custom class to integrate seamlessly with the existing exception handling mechanisms. This ensures that even if our `tornadoException` is caught as a generic exception, the overridden `what()` method will provide the specific message, enhancing the debuggability and user understanding.

The `std::exception` class supports polymorphism by allowing custom exceptions to be grouped and processed using a single type—`std::exception&`. This makes handling of different exceptions more unified and efficient.