\( \begin{array}{l}\text { What happens when you define a class that used } \\ \text { dynamic memory allocation and define a destructor } \\ \text { but no copy constructor? } \\ \text { It is possible to modify the values in the argument in the } \\ \text { function. } \\ \begin{array}{l}\text { When an object that was used as an argument for a call- } \\ \text { by-value parameter goes out of scope, it will cause a run- } \\ \text { time error. } \\ \text { If an object of the class is plugged in for a call-by-value } \\ \text { parameter, when the function ends, the parameter's } \\ \text { dynamic memory is returned to the freestore at the end } \\ \text { of the function execution. }\end{array} \\ \text { all of these } \\ \text { none of these }\end{array} \) vices

When you define a class with dynamic memory allocation and only implement a destructor without a copy constructor, you face a risk of memory leaks or double deletions. This is because, during the copy operation, the shallow copy will make two objects point to the same memory, which can lead to issues when either object is destroyed — the same memory could be freed twice, causing runtime errors. In real-world applications, this concept is crucial in resource management. For example, when creating data structures in C++ like linked lists or trees, not properly handling dynamic memory can lead to bugs that are difficult to trace. Ensuring that both a copy constructor and destructor are defined helps maintain control over memory and prevent leaks, making your software robust and efficient!