There are several types of room in a hotel. The HotelRoom Class of Previous Programming Problem was not specific regarding the type of room. Assume that a hotel has guest rooms and meeting rooms. Modify the HotelRoom class as follows: remove the capacity and status instance variables and associated methods. Change the class constructor, copy constructor, and destructor accordingly. Derive from Hotel Room the classes Guestroom and Meeting Room. Guestroom contains the following data members: the integer instance variable capacity, which represents the maximum number of guests that can occupy the room; the integer instance variable status, which represents the number of guests in the room (0 if unoccupied); and the integer instance variable days, which represents the number of days the guest occupies the room. Meeting Room has the integer instance variable seats, which represents the number of seats in the room, and the integer instance variable status (1 if the room is booked for a meeting; 0 otherwise). Code all appropriate constructors, copy constructors and destructors for the classes. Code a function main () to test the classes. Make sure to create object of all types. Computer Science

To modify the HotelRoom class as described, you will need to remove the capacity and status instance variables and associated methods. Then, you will need to change the class constructor, copy constructor, and destructor accordingly.

Here's an example implementation of the modified HotelRoom class:

```cpp
class HotelRoom {
public:
HotelRoom() {
// constructor code
}

HotelRoom(const HotelRoom& other) {
// copy constructor code
}

virtual ~HotelRoom() {
// destructor code
}
};
```

Next, you need to derive two classes from HotelRoom: Guestroom and MeetingRoom.

The Guestroom class will have the capacity, status, and days instance variables, as well as their respective constructors, copy constructors, and destructors. Here's an example implementation:

```cpp
class Guestroom : public HotelRoom {
public:
int capacity;
int status;
int days;

Guestroom() {
// constructor code
}

Guestroom(const Guestroom& other) : HotelRoom(other) {
// copy constructor code
}

~Guestroom() {
// destructor code
}
};
```

The MeetingRoom class will have the seats and status instance variables, as well as their respective constructors, copy constructors, and destructors. Here's an example implementation:

```cpp
class MeetingRoom : public HotelRoom {
public:
int seats;
int status;

MeetingRoom() {
// constructor code
}

MeetingRoom(const MeetingRoom& other) : HotelRoom(other) {
// copy constructor code
}

~MeetingRoom() {
// destructor code
}
};
```

Finally, you can create objects of each type (HotelRoom, Guestroom, and MeetingRoom) in the `main()` function to test the classes. Here's an example `main()` function:

```cpp
int main() {
HotelRoom hotelRoom;
Guestroom guestroom;
MeetingRoom meetingRoom;

// Test the classes by using the objects

return 0;
}
```

Note: This is just an example implementation, and you may need to adapt it to fit your specific requirements.