لینک دانلود و خرید پایین توضیحات
فرمت فایل word و قابل ویرایش و پرینت
تعداد صفحات: 37
| Memory and Resource
Management
C++ offers tremendous flexibility in managing memory, but few C++ programmers fully understand the available mechanisms. In this area of the language ,overloading , name hiding, constructors and destructors, exceptions, static and virtual functions, operator and non-operator functions all come together to provide great flexibility and customizability of memory management. Unfortunately, and perhaps unavoidably, things can also get a bit complex.
In this chapter, we’ll look at how the various features of C++ are used together in memory management, how they sometimes interact in surprising ways, and how to simplify their interactions.
Inasmuch as memory is just one of many resources a program manages, we’ll also look at how to bind other resources to memory so we can use C++’s sophisticated memory management facilities to manage other resources as well.
Failure to Distinguish Scalar and Array Allocation
Is a Widget the same thing as an array of Widgets? Of course not. Then why are so many C++ programmers surprised to find that different operators are used to allocate and free arrays and scalars?
We know how to allocate and free a single Widget. We use the new and delete operators:
Widget *w = new Widget( arg );
// . . .
delete w;
Unlike most operators in C++, the behavior of the new operator can’t be modified by overloading. The new operator always calls a function named operator new to obtain some storage, then may initialize that storage. In the case of Widget, above, use of the new operator will cause a call to an operator new function that takes a single argument of type size_t, then will invoke a Widget constructor on the uninitialized storage returned by operator new to produce a Widget object.
The delete operator invokes a destructor on the Widget and then calls a function named operator delete to deallocate the storage formerly occupied by the now deceased Widget object.
Variation in behavior of memory allocation and deallocation is obtained by overloading, replacing, or hiding the functions operator new and operator delete, not by modifying the behavior of the new and delete operators.
We also know how to allocate and free arrays of Widgets. But we don’t use the new and delete operators:
w = new Widget[n];
// . . .
delete [] w;
We instead use the new [] and delete [] operators. Like new and delete, the behavior of the array new and array delete operators cannot be modified. Array new first invokes a function called operator new[] to obtain some storage, then (if necessary) performs a default initialization of each allocated array element from the first element to the last. Array delete destroys each element of the array in the reverse order of its initialization, then invokes a function called operator delete[] to reclaim the storage.
As an aside, note that it’s often better design to use a standard library vector
rather than an array. A vector is nearly as efficient as an array and is typically safer and more flexible. A vector can generally be considered a “smart” array, with similar semantics. However, when a vector is destroyed, its elements are destroyed from first to last: the opposite order in which they would be destroyed in an array.
Memory management functions must be properly paired. If new is used to obtain storage, delete should be used to free it. If malloc is used to obtain storage, free should be used to free it. Sometimes, using free with new or malloc with delete will “work” for a limited set of types on a particular platform, but there is no guarantee the code will continue to work:
int *ip = new int(12);
// . . .
free( ip ); // wrong!
ip = static_cast(malloc( sizeof(int) ));
*ip = 12;
// . . .
delete ip; // wrong!
تحقیق درباره Memory and Resource
