<s>[INST] C++11 provides a feature called "smart pointers," which can be used to automatically manage the memory occupied by objects created on the heap. However, in certain situations, it might still be necessary to manually manage these objects using pointers. In this exercise, we will delve into the memory layout of objects created on the heap and explore how to manually decommission these objects using C++11.

Create a class called `Vehicle` that has three member variables: `type`, `color`, and `speed`, all of which are of type `char`. Declare and initialize each of these variables in the class definition. In the class definition, declare a constructor that initializes the member variables, as well as a destructor.

Next, create a function called `TestVehicle` that tests the creation, initialization, and destruction of an instance of `Vehicle` using a raw pointer. This function creates a pointer to `Vehicle`, initializes it on the heap, and then destroys the object. Finally, create a `main` function that demonstrates the `TestVehicle` function.

```cpp
#include <iostream>
#include <ostream>
#include <stdexcept>

class Vehicle {
public:
    char type = 'C';
    char color = 'W';
    char speed = 'S';

    Vehicle() = default;

    ~Vehicle() {
        std::cout << "Vehicle destructor" << std::endl;
    }
};

void TestVehicle() {
    try {
        Vehicle* ptr = new Vehicle();
        ptr->~Vehicle();
        delete ptr;
    } catch (const std::exception& e) {
        std::cout << "Exception caught: " << e.what() << std::endl;
    }
}

int main() {
    TestVehicle();
    return 0;
}
```

**Problem:** The destructor `~Vehicle()` should explicitly be called before the `delete` keyword in the `TestVehicle()` function to ensure that the object is properly cleaned up. Although it's not required in most cases, calling the destructor explicitly can be useful in some scenarios.

How would you modify the `TestVehicle()` function to fix this problem?[/INST]