(a) Occasionally one encounters the suggestion that a garbage-collected language should provide a delete operation as an optimization: by explicitly delete-ing objects that will never be used again, the programmer might save the garbage collector the trouble of finding and reclaiming those objects automatically, thereby improving performance. What do you think of this suggestion? Explain. (b) Alternatively, one might allow the programmer to “tenure” an object, so that it will never be a candidate for reclamation. Is this a good idea?

(a) Occasionally one encounters the suggestion that a garbage-collected language should provide a delete operation as an optimization: by explicitly delete-ing objects that will never be used again, the programmer might save the garbage collector the trouble of finding and reclaiming those objects automatically, thereby improving performance. What do you think of this suggestion? Explain. (b) Alternatively, one might allow the programmer to “tenure” an object, so that it will never be a candidate for reclamation. Is this a good idea?

C++ for Engineers and Scientists

4th Edition

ISBN:9781133187844

Author:Bronson, Gary J.

Publisher:Bronson, Gary J.

Chapter10: Pointers

Section10.1: Addresses And Pointers

Problem 7E

See similar textbooks

Similar questions

Make a case for the use of deep access over shallow access from the viewpoint of a programmer; attempt to stay away from a performance-focused argument.
Should they be maintained apart or should object-oriented programming and abstract data types be implemented simultaneously? Object-oriented programming and abstract data types have been more popular in recent years. This was not a deliberate attempt to couple the two. Are you of the opinion that there are instances when you just have to disagree? If you don't have a position, explain it or offer an example.
Java Assignment: Experiment with naming rules in Java Does the language use static or dynamic scoping? Can scopes nest? Are they open or closed? Does the scope of a name encompass the entire block in which it is declared, or only the portion after the declaration? How does one declare mutually recursive types or subroutines? Can subroutines be passed as parameters, returned from functions, or stored in variables? If so, when are referencing environments bound? Justify your answers with suitable code snippet and its output.
Make an argument that supports the usage of deep access rather than shallow access from the perspective of a coder; try to avoid making an argument that revolves around performance.
I am having some issues in understanding pointers, references and overloading and how should I apply them? It is because I already understand how to define, use, and understand the theory behind it. Yet, still lost when trying to apply them in various situations.
How can dictionaries be implemented efficiently in memory-constrained environments, and what trade-offs are involved in optimizing memory usage versus lookup speed?
The question of whether or not object-oriented programming and abstract data types need to be put into practise jointly or singly is one that is hotly debated. This is a very unlikely occurrence that cannot be rationalised in any way. You acknowledge that we are in disagreement, don't you? If you do have a position, could you please tell me what it is? If not, could you possibly offer an example?
Do object-oriented programming and abstract data types complement one another, or are they two different ideas that need to be studied independently? The frequent coexistence of these two ideas in programming languages is just accidental and cannot be explained. If you agree, please explain why; if not, please provide an illustration of your position.
In C++, how simple is it to duplicate an array of shared pointers into a new array? Create a list of potential solutions to the issue at hand. Do the objects controlled by a shared pointer also get copied when it's copied? Explain
Mention one problem likely to be faced by programs written in programming languageswhich do not support garbage collection.
Compilers for contemporary programming languages may implement abstract data types in a number of ways. Exists a universally applicable definition, and if not, why not? Can you share an example?
You should concentrate your efforts on avoiding an argument that centres on how well deep access performs in compared to shallow access, and you should make the case for utilising deep access rather than shallow access from the standpoint of a coder.