Which of the following is not supported in C++?

Question

Accepted Answer

The correct option is (1):
Automatic garbage collection is the facility to automatically free up memory that is no longer being used by the program, typically managed by a language's runtime environment (like in Java or C\#). C++ adheres to a philosophy of low-level control and high performance, which dictates manual memory management. Programmers are explicitly responsible for allocating dynamic memory using `new` and deallocating it with `delete`. While modern C++ incorporates techniques like Resource Acquisition Is Initialization (RAII) and smart pointers to help manage memory safely, these are user-implemented, deterministic cleanup mechanisms and not the non-deterministic, runtime-based automatic garbage collection system that the question refers to.

The incorrect option is (2):
Multiple inheritance is a foundational and fully supported feature of the C++ language. It allows a derived class to inherit members from more than one base class, enabling a rich and complex class hierarchy. Although multiple inheritance can introduce challenges like the 'Diamond Problem' where a class inherits from a common ancestor along multiple paths, C++ provides specialized mechanisms, such as virtual inheritance, to resolve such ambiguities effectively.

The incorrect option is (3):
Smart pointers are fully supported in modern C++ (available in the Standard Library) and are considered the modern best practice for managing dynamic memory. They are wrappers around raw pointers that automatically manage the memory they point to, primarily through the RAII principle. The standard library provides types such as `std::unique_ptr` and `std::shared_ptr`, which are crucial tools for managing resource ownership, preventing memory leaks, and enhancing the safety and reliability of C++ programs.

The incorrect option is (4):
Virtual destructors are an integral and necessary feature for safe polymorphic behavior in C++. They are declared in a base class to ensure that when an object of a derived class is deleted via a pointer of the base class type, the correct sequence of destructors is called—first the derived class's and then the base class's. Without a virtual destructor in this scenario, only the base class destructor would be called, leading to an incomplete cleanup of the derived class's resources and resulting in a memory leak or undefined behavior.