Shulou(Shulou.com)06/03 Report--

What this article shares with you is the detailed explanation of new and delete of C++. The editor thinks it is very practical, so I share it with you to learn. I hope you can get something after reading this article. Without saying much, follow the editor to have a look.

1. Internal implementation of new and delete

In C++, you need to use the keywords new and delete to create and destroy objects in heap memory. For example, the following code

Class CA {public: CA () CA (0) {} CA (int a): Massia (a) {} virtual void foo () {coutm_a = 20 delete p1-> ~ CA (); p2-> CA (); delete [] buf2

You can see that buf1 is stack memory and buf2 is heap memory in the code, both of these memory areas are allocated memory, and now we want to use these memory as objects of the CA class, so we need to call the class constructor CA::CA () to the memory. The internal implementation of the constructor will fill the memory area with virtual table pointers, so that objects can call virtual functions such as foo. But it's not elegant to write code like this, so is there a more elegant way to build objects on an existing piece of memory? The answer is placement technology. In C++, new and delete are still used to implement this technology. In addition to implementing the default operators, new and delete overload the following operator functions:

Void* operator new (size_t size, void* p) {return p;} void* operator new [] (size_t size, void* p) {return p;} void operator delete (void* p1, void* p2) {/ / do nothing..} void operator delete [] (void* p1, void* p2) {/ / do nothing..}

We call these four operators placement new and placement delete. Through these operators, we can achieve the above functions gracefully:

Char buf1 [100]; CA * p1 = new (buf1) CA (10); / / call operator new (size_t, void*) p1-> foo (); char * buf2 = new charchar[ sizeof (CA)]; CA * p2 = new (buf2) CA (20); / / call operator new (size_t, void*) p2-> foo (); p1-> CA (); operator delete (p1, buf1); / / call operator delete (void*, void*) p2-> CA (); operator delete (p2, buf2) / / call operator delete (void*, void*) delete [] buf2

In the above example, it is found that objects can be elegantly built in existing memory through placement new, but destructors and placement delete functions must be called artificially instead of directly calling delete p1 and delete p2 to destroy objects. And from the above placement delete implementation, there is no code in it, so why define a placement delete? The answer is that C++ stipulates that operator overloading of new and delete must be implemented in pairs. And as mentioned earlier, the use of delete with the operator prefix is just a normal function call. Therefore, in order to complete the destructor and match with the new operator, it is necessary to artificially call the object's destructor and the placement delete function. In addition to the above examples, the use of placement technology can also reduce frequent memory allocation and improve system performance.

Void main () {for (int I = 0; I)

Foo (); delete p;}}

There are 10000 loops in the example, each of which creates a heap memory object, and then calls the virtual function foo before destroying it. The end result is frequent heap memory allocation and destruction 10000 times when the program is running. It is obvious that this may affect system performance and heap memory allocation failures may also occur. And if we use placement technology, we can easily solve these problems.

Void main () {char * buf = new [] (sizeof (CA)); for (int I = 0; I

Foo (); p-> ~ CA (); operator delete (p, buf);} delete [] buf;}

In the above example, there is only one heap memory allocation, and in the loop, objects are built with existing memory, and memory is no longer allocated. In this way, the reuse of memory makes the performance of the program greatly improved.

3. New and delete operator overloading

It is interesting to find that the more advanced the language is, the more likely it is to encapsulate some of the things at the bottom of the system and form a language-level keyword to use. For example, new and delete in C++ are keywords used to build and release heap memory objects, and the chan keyword in go language is used for synchronous or asynchronous queue data transfer channel. C++ language implements a set of global new and delete operator functions as well as placement new/delete operator functions by default. Both classes and built-in types can allocate and release heap memory objects through new/delete. For a class, when we use new to build an object, we first check to see if the class overloads the new operator, and if the class overloads the new operator, it invokes the new operator provided by the class for memory allocation, and if no new operator is provided, the global new operator provided by the system is used for memory allocation. Built-in types always allocate memory using the global new operator provided by the system. The memory destruction process of the object is also consistent with the allocation. The new and delete operators support both global overloading and class-level function overloading. The following is the format of the definition of this operator:

/ / Global operator definition format void * operator new (size_t size [, param1, param2,....]); void operator delete (void * p [, param1, param2,...]); / / in-class operator definition format class CA {void * operator new (size_t size [, param1, param2,....]); void operator delete (void * p [, param1, param2,...]);}

There are always rules for new/delete operator overloading:

New and delete operator overloads must occur in pairs

The first parameter of the new operator must be of type size_t, which specifies the size size of the allocated memory; the first parameter of the delete operator must be the memory object to be destroyed. Other parameters can be defined at will.

The system implements six operator functions: new/delete, new [] / delete [] and placement new/delete by default. They all have a specific meaning.

You can override the default implementation of the global operator, such as you want to customize the memory allocation policy, or you want to monitor the allocation of heap memory or you want to do memory leak monitoring for heap memory. But the global operator you rewrite must meet the default rule definition.

If you want to do special handling on objects allocated to the heap memory of a class, you can overload the class's new/delete operator. Although there is no static attribute when these two operators are overloaded, overloading the class's new/delete operator is always considered a static member function anyway.

When the parameters of the delete operator are > = 2, you are responsible for calling the object destructor and calling the delete operator as an operator function.

In general, you don't need to overload the new/delete operator, unless your entire application or a class has special requirements. In the following example, you can see the overloading and use of my various operators:

/ / CA.hclass CA {public: / / Class member function void * operator new (size_t size); void * operator new [] (size_t size); void * operator new (size_t size, void * p); void * operator new (size_t size, int a, int b); void operator delete (void * p); void operator delete [] (void * p); void operator delete (void * p, void * p1) Void operator delete (void * p, int a, int b);}; class CB {public: CB () {}}; / / Global operator function, please be careful to override the global operator function. Void * operator new (size_t size); void * operator new [] (size_t size); void * operator new (size_t size, void * p) noexcept;void * operator new (size_t size, int a, int b); void operator delete (void * p); void operator delete [] (void * p); void operator delete (void * p, void * p1); void operator delete (void * p, int a, int b) . / / CA.cppvoid * CA::operator new (size_t size) {return malloc (size);} void * CA::operator new [] (size_t size) {return malloc (size);} void * CA::operator new (size_t size, void * p) {return p } void* CA::operator new (size_t size, int a, int b) {return malloc (size);} void CA::operator delete (void* p) {free (p);} void CA::operator delete [] (void* p) {free (p);} void CA::operator delete (void* p, void* p1) {} void CA::operator delete (void* p, int a, int b) {free (p) } void* operator new (size_t size) {return malloc (size);} void* operator new [] (size_t size) {return malloc (size);} void* operator new (size_t size, void* p) noexcept {return p;} void* operator new (size_t size, int a, int b) {return malloc (size);} void operator delete (void* p) {free (p);} void operator delete [] (void* p) {free (p) } void operator delete (void * p, void * p1) {} void operator delete (void * p, int a, int b) {free (p);}.. / / main.cppint main (int argc, const char * argv []) {char buf [100]; CA * A1 = new CA () / / call void * CA::operator new (size_t size) CA * a2 = new CA [10]; / / call void * CA::operator new [] (size_t size) CA * a3 = new (buf) CA (); / / call void * CA::operator new (size_t size, void * p) CA * a4 = new (10,20) CA () / / call void* CA::operator new (size_t size, int a, int b) delete A1; / call void CA::operator delete (void* p) delete [] a2; / / call void CA::operator delete [] (void* p) / / a3 is allocated in the way of placement new, so you need to call the object's destructor. A3-> ~ CA (); CA::operator delete (A3, buf); / / call void CA::operator delete (void * p, void * p1), remember to bring the class namespace. / / a4 has operator parameters greater than or equal to 2, so you need to call the object's destructor yourself. A4-> ~ CA (); CA::operator delete (a4, 10, 20); / / call the void CA::operator delete (void * p, int a, int b) / / CB class does not have an overloaded operator, so a globally overloaded operator is used. CB * b1 = new CB (); / / call void * operator new (size_t size) CB * b2 = new CB [10]; / / call void * operator new [] (size_t size) / / you can see here that the same block of memory can be used to build objects of CA classes as well as objects of CB classes CB * b3 = new (buf) CB () / call void* operator new (size_t size, void* p) CB * b4 = new (10,20) CB (); / / call void* operator new (size_t size, int a, int b) delete b1; / / call void operator delete (void* p) delete [] b2 / / call void operator delete [] (void * p) / / b3 is allocated in the way of placement new, so you need to call the object's destructor yourself. B3-> ~ CB ();:: operator delete (b3, buf); / / call void operator delete (void * p, void * p1) / / b4 operator parameters are greater than or equal to 2, so you need to call the object's destructor. B4-> ~ CB ();:: operator delete (b4,10,20); / / call void operator delete (void * p, int a, int b) return 0;}

I tested the above code on XCODE, because the global new/delete operator is rewritten, and the heap memory allocation is internally achieved through malloc, the malloc function states that the return result detection that cannot return NULL: void * malloc (size_t _ _ size) _ _ result_use_check _ alloc_size (1); so it is possible that you will crash during the test. If this problem occurs, you can try to comment out the code rewritten to the global new/delete, and then run to see the results. It can be seen that there may be risks if you try to overwrite the global new/delete.

4. Automatic deletion of objects.

Generally speaking, the default implementation of new/delete in the system can meet our needs, and we no longer need to overload these two operators. So why does C++ provide overloading support for these two operators? The answer lies in the flaws in the operator itself. We know that using the new keyword to create a heap memory object is divided into two steps: 1. Is heap memory allocation, 2. Is a call to the object constructor. Either of these two steps can lead to an exception. If there is a problem in the first step and the memory allocation fails, the constructor will not be called, which is no problem. If it is said that an exception occurred during the execution of the second-step constructor and the normal construction cannot be completed, then the heap memory allocated in the first step should be destroyed. C++ states that if an object cannot be fully constructed, then the object will be an invalid object and the destructor will not be called. In order to ensure the integrity of the object, when the heap memory object allocated through new has an exception during the execution of the constructor, it will stop the execution of the constructor and automatically call the corresponding delete operator to destroy the allocated heap memory. This is the so-called automatic deletion technology of objects. It is precisely because of the automatic deletion technology of objects that the problem of memory leakage caused by incomplete object construction can be solved.

When an exception is thrown during object construction, C++ 's exception handling mechanism inserts code in a specific place to call the object's delete operator. If you want to know more about the situation, please refer to C++ 's relevant knowledge about exception handling.

Although the automatic deletion of objects supported by the global delete operator function can solve the problem of memory leakage of the object itself, it cannot solve the problem of memory allocation leakage of data members within the object constructor. Let's take a look at the following code:

Class CA {public: CA () {m_pa = new int; throw 1;} ~ CA () {delete private; m_pa = NULL;} private: int * myogpa;}; void main () {try {CA * p = new CA (); delete p / / this code will never execute} catch (int) {cout masked pas; free (p);} private: int * mendpa;}

Because of C++ 's support for automatic deletion, when an exception occurs in the CA object during construction, we can overload the delete operator to solve the memory problem of the data members allocated in the constructor without calling the destructor to destroy it. I think that's why overloading new/delete operators in classes is supported in C++.

These are the new and delete details of C++. The editor believes that there are some knowledge points that we may see or use in our daily work. I hope you can learn more from this article. For more details, please follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.