What is the difference between using [the `delete` operator][1] on the array element as opposed to using [the `Array.splice` method][2]? 

For example:

    myArray = [&#39;a&#39;, &#39;b&#39;, &#39;c&#39;, &#39;d&#39;];

    delete myArray[1];
    //  or
    myArray.splice (1, 1);

Why even have the splice method if I can delete array elements like I can with objects?

  [1]: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/delete
  [2]: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/splice


Deleting array elements in JavaScript - delete vs splice

Is it safe to delete a NULL pointer?

And is it a good coding style?

Is it safe to delete a NULL pointer?

    class my_class
    {
    	...
    	my_class(my_class const &amp;) = delete;
    	...
    };

What does `= delete` mean in that context?

Are there any other &quot;modifiers&quot; (other than `= 0` and `= delete`)?

Meaning of = delete after function declaration

Is it allowed to `delete this;` if the delete-statement is the last statement that will be executed on that instance of the class? Of course I&#39;m sure that the object represented by the `this`-pointer is `new`ly-created.

I&#39;m thinking about something like this:

    void SomeModule::doStuff()
    {
        // in the controller, &quot;this&quot; object of SomeModule is the &quot;current module&quot;
        // now, if I want to switch over to a new Module, eg:

        controller-&gt;setWorkingModule(new OtherModule());

        // since the new &quot;OtherModule&quot; object will take the lead, 
        // I want to get rid of this &quot;SomeModule&quot; object:

        delete this;
    }

Can I do this?

Is &quot;delete this&quot; allowed in C++?

What is the difference between `delete` and `delete[]` operators in C++?

delete vs delete[] operators in C++

I have an `class A` which uses a heap memory allocation for one of its fields. Class A  is instantiated and stored as a pointer field in another class (`class B`.

When I&#39;m done with an object of class B, I call `delete`, which I assume calls the destructor... But does this call the destructor of class A as well?

### Edit:
From the answers, I take that (please edit if incorrect):

1. `delete` of an instance of B calls B::~B();
2. which calls `A::~A();`
3. `A::~A` *should* explicitly `delete` all heap-allocated member variables of the A object;
4. Finally the memory block storing said instance of class B is returned to the heap - when *new* was used, it first allocated a block of memory on heap, then invoked constructors to initialize it, now after all destructors have been invoked to finalize the object the block where the object resided is returned to the heap.

Does delete on a pointer to a subclass call the base class destructor?

Alright, I think we all agree that what happens with the following code is undefined, depending on what is passed,

    void deleteForMe(int* pointer)
    {
         delete[] pointer;
    }

The pointer could be all sorts of different things, and so performing an unconditional `delete[]` on it is undefined. However, let&#39;s assume that we are indeed passing an array pointer,

    int main()
    {
         int* arr = new int[5];
         deleteForMe(arr);
         return 0;
    }

My question is, in this case where the pointer __is__ an array, who is it that knows this? I mean, from the language/compiler&#39;s point of view, it has no idea whether or not `arr` is an array pointer versus a pointer to a single int. Heck, it doesn&#39;t even know whether `arr` was dynamically created. Yet, if I do the following instead,

    int main()
    {
         int* num = new int(1);
         deleteForMe(num);
         return 0;
    }

The OS is smart enough to only delete one int and not go on some type of &#39;killing spree&#39; by deleting the rest of the memory beyond that point (contrast that with `strlen` and a non-`\0`-terminated string -- it will keep going until it hits 0).

So whose job is it to remember these things? Does the OS keep some type of record in the background? (I mean, I realise that I started this post by saying that what happens is undefined, but the fact is, the &#39;killing spree&#39; scenario doesn&#39;t happen, so therefore in the practical world _someone_ is remembering.)


How does delete[] know it&#39;s an array?

I always wondered why automatic setting of the pointer to NULL after *delete* is not part of the standard. If this gets taken care of then many of the crashes due to an invalid pointer would not occur. But having said that I can think of couple of reasons why the standard would have restricted this:

&gt;    1. Performance:
&gt;
&gt;       An additional instruction could slow down the `delete` performance. 
&gt;    
&gt;    2. Could it be because of `const` pointers. 
&gt;
&gt;       Then again standard could have done something for this special case I guess. 

Does anyone know exact reasons for not allowing this? 




Why doesn&#39;t delete set the pointer to NULL?

A C++ book I have been reading states that when a pointer is deleted using the `delete` operator the memory at the location it is pointing to is &quot;freed&quot; and it can be overwritten.  It also states that the pointer will continue to point to the same location until it is reassigned or set to `NULL`.

In Visual Studio 2012 however; this doesn&#39;t seem to be the case!

**Example:**

    #include &lt;iostream&gt;

    using namespace std;

    int main()
    {
        int* ptr = new int;
        cout &lt;&lt; &quot;ptr = &quot; &lt;&lt; ptr &lt;&lt; endl;
        delete ptr;
        cout &lt;&lt; &quot;ptr = &quot; &lt;&lt; ptr &lt;&lt; endl;

        system(&quot;pause&quot;);

        return 0;
    }

When I compile and run this program I get the following output:

    ptr = 0050BC10
    ptr = 00008123
    Press any key to continue....

___
Clearly the address that the pointer is pointing to changes when delete is called!

Why is this happening?  Does this have something to do with Visual Studio specifically?

And if delete can change the address it is pointing to anyways, why wouldn&#39;t delete automatically set the pointer to `NULL` instead of some random address?

  [1]: http://i.stack.imgur.com/1jDUY.png


What does Visual Studio do with a deleted pointer and why?

Context: I&#39;m trying to wrap my head around pointers, we just saw them a couple of weeks ago in school and while practicing today I ran into a silly? issue, it can be super straightforward to you but I have little to none programming experience.

I&#39;ve seen quite a few questions over in SO about deleting pointers but they all seem to be related to deleting a class and not a &#39;simple&#39; pointer (or whatever the proper term might be), here&#39;s the code I&#39;m trying to run:

    #include &lt;iostream&gt;;
    
    using namespace std;
    
    int main() {
      int myVar,
          *myPointer;
    
      myVar = 8;
      myPointer = &amp;myVar;
    
      cout &lt;&lt; &quot;delete-ing pointers &quot; &lt;&lt; endl;
      cout &lt;&lt; &quot;Memory address: &quot; &lt;&lt; myPointer &lt;&lt; endl;
    
      // Seems I can&#39;t *just* delete it, as it triggers an error 
      delete myPointer;
      cout &lt;&lt; &quot;myPointer: &quot; &lt;&lt; myPointer &lt;&lt; endl;
      // Error: a.out(14399) malloc: *** error for object 0x7fff61e537f4:
      // pointer being freed was not allocated
      // *** set a breakpoint in malloc_error_break to debug
      // Abort trap: 6
    
      // Using the new keyword befor deleting it works, but
      // does it really frees up the space? 
      myPointer = new int;
      delete myPointer;
      cout &lt;&lt; &quot;myPointer: &quot; &lt;&lt; myPointer &lt;&lt; endl;
      // myPointer continues to store a memory address.
    
      // Using NULL before deleting it, seems to work. 
      myPointer = NULL;
      delete myPointer;
      cout &lt;&lt; &quot;myPointer: &quot; &lt;&lt; myPointer &lt;&lt; endl;
      // myPointer returns 0.
    
    }

So my questions are:

 1. Why won&#39;t the first case work? Seems the most straightforward use to use and delete a pointer? The error says the memory wasn&#39;t allocated but &#39;cout&#39; returned an address.
 2. On the second example the error is not being triggered but doing a cout of the value of myPointer **still** returns a memory address?
 3. Does #3 really work? Seems to work to me, the pointer is no longer storing an address, is this the proper way to delete a pointer?

Sorry for the long question, wanted to make this as clear as possible, also to reiterate, I have little programming experience, so if someone could answer this using layman&#39;s terms, it would be greatly appreciated!


Deleting a pointer in C++

&gt; **Possible Duplicate:**  
&gt; [( POD )freeing memory : is delete[] equal to delete ?](https://stackoverflow.com/questions/1553382/pod-freeing-memory-is-delete-equal-to-delete)  

&lt;!-- End of automatically inserted text --&gt;

When I was taught C++, this was a long time ago. I was told to never use `delete` but `delete[]` as performing `delete[]` on a single object will be equivalent to `delete`. Knowing not to trust teachers too much I wonder, Is this true?

Is there ever a reason to call `delete` instead of `delete[]`?

I&#39;ve scanned the possibly related questions in SO, but haven&#39;t found any clear answer.

delete vs delete[]

I have a basic question regarding the const pointers. I am not allowed to call any non-const member functions using a const pointer. However, I am allowed to do this on a const pointer:

    delete p;

This will call the destructor of the class which in essence is a non-const &#39;method&#39;. Why is this allowed? Is it just to support this:

    delete this;

Or is there some other reason?

Deleting a pointer to const (T const*)

In `c++03` it is pretty clear that deleting a null pointer has no effect. Indeed, it is explicitly stated in `&#167;5.3.5/2` that:

&gt; In either alternative, if the value of the operand of delete is the null pointer the operation has no effect.

However, in the current [draft][1] for `c++0x` this sentence seems to be missing. In the rest of the draft I could only find sentences stating what happens if the operand of the *delete-expression* is not the null pointer constant. Is deleting the null pointer still defined in `c++0x`, and if so, where?

**Notes:**

There is significant circumstantial evidence to suggest that it is still well defined. 

First, there are the two sentences in `&#167;5.3.5/2` stating that 

&gt;In the first alternative (delete object), the value of the operand of delete may be a null pointer value, ...

and
&gt;In the second alternative (delete array), the value of the operand of delete may be a null pointer value or ...

These say that the operand is allowed to be null, but on their own do not actually define what happens if it is.

Second, changing the meaning of `delete 0` is a major breaking change, and the standards committee would be very unlikely make this particular change. Furthermore there is no mention of this being a breaking change in the Compatibility Annex (Annex C) of the `c++0x` draft. Annex C is however an Informative section, so this has no bearing no the interpretation of the standard.

On the other hand, the fact that deleting the null pointer is required to have no effect implies an additional run-time check. In a lot of code the operand can never be null, so this runtime check is in conflict with the zero overhead principle. Maybe the committee just decided to change the behaviour to bring standard c++ more in line with the stated design goals of the language.

[1]: http://www.open-std.org/jtc1/sc22/WG21/prot/14882fdis/n3291.pdf

Is it still safe to delete nullptr in c++0x?

How can I `realloc` in C++? It seems to be missing from the language - there is `new` and `delete` but not `resize`!

I need it because as my program reads more data, I need to reallocate the buffer to hold it. I don&#39;t think `delete`ing the old pointer and `new`ing a new, bigger one, is the right option. 

How do you &#39;realloc&#39; in C++?

Ignoring programming style and design, is it &quot;safe&quot; to call delete on a variable allocated on the stack?

For example:
 

       int nAmount;
       delete &amp;nAmount;

or

    class sample
    {
    public:
        sample();
        ~sample() { delete &amp;nAmount;}
        int nAmount;
    }

Calling delete on variable allocated on the stack

***Why &lt;strike&gt;should&lt;/strike&gt; would one replace the default operator `new` and `delete` with a custom `new` and `delete` operators?***  

This is in continuation of [Overloading new and delete](https://stackoverflow.com/questions/4421706/operator-overloading/4421791#4421791) in the immensely illuminating C++ FAQ:  
[Operator overloading.](https://stackoverflow.com/questions/4421706/operator-overloading )

An followup entry to this FAQ is:  
[How should I write ISO C++ standard conformant custom `new` and `delete` operators?](https://stackoverflow.com/questions/7194127/how-should-i-write-iso-c-standard-conformant-custom-new-and-delete-operators/)


&lt;sub&gt;
Note:  The answer is based on lessons from Scott Meyers&#39; More Effective C++.  
_(Note: This is meant to be an entry to [Stack Overflow&#39;s C++ FAQ](https://stackoverflow.com/questions/tagged/c++-faq). If you want to critique the idea of providing an FAQ in this form, then [the posting on meta that started all this](https://meta.stackexchange.com/questions/68647/setting-up-a-faq-for-the-c-tag) would be the place to do that. Answers to that question are monitored in the [C++ chatroom](https://chat.stackoverflow.com/rooms/10/c-lounge), where the FAQ idea started out in the first place, so your answer is very likely to get read by those who came up with the idea.)_
&lt;/sub&gt;



Why would one replace default new and delete operators?

### How should I write ISO C++ standard conformant custom `new` and `delete` operators? 

This is in continuation of [Overloading new and delete](https://stackoverflow.com/questions/4421706/operator-overloading/4421791#4421791) in the immensely illuminating C++ FAQ, [Operator overloading](https://stackoverflow.com/questions/4421706/operator-overloading), and its follow-up, [Why should one replace default new and delete operators?](https://stackoverflow.com/questions/7149461/why-should-one-replace-default-new-and-delete-operators)

**Section 1:** Writing a standard-conformant `new` operator

 - [Part 1: Understanding the requirements for writing a custom `new` operator](https://stackoverflow.com/questions/7194127/7194137#7194137)
 - [Part 2: Understanding the `new_handler` requirements](https://stackoverflow.com/questions/7194127/7194149#7194149)
 - [Part 3: Understanding specific scenario requirements](https://stackoverflow.com/questions/7194127/7194154#7194154)

**Section 2:** Writing a standard-conformant `delete` operator  

 - 

[Implementing Custom delete operator](https://stackoverflow.com/questions/7194127/how-should-i-write-iso-c-standard-conformant-custom-new-and-delete-operators/7195226#7195226)


&lt;sub&gt;
_(Note: This is meant to be an entry to [Stack Overflow&#39;s C++ FAQ](https://stackoverflow.com/questions/tagged/c++-faq). If you want to critique the idea of providing an FAQ in this form, then [the posting on meta that started all this](https://meta.stackexchange.com/questions/68647/setting-up-a-faq-for-the-c-tag) would be the place to do that. Answers to that question are monitored in the [C++ chatroom](https://chat.stackoverflow.com/rooms/10/c-lounge), where the FAQ idea started out in the first place, so your answer is very likely to get read by those who came up with the idea.)_  
*Note: The answer is based on learnings from Scott Meyers&#39; More Effective C++ and the ISO C++ Standard.*

&lt;/sub&gt;


How should I write ISO C++ Standard conformant custom new and delete operators?

I am totally confused with regards to deleting things in C++. If I declare an array of objects and if I use the `clear()` member function. Can I be sure that the memory was released?

For example : 

    tempObject obj1;
    tempObject obj2;
    vector&lt;tempObject&gt; tempVector;

    tempVector.pushback(obj1);
    tempVector.pushback(obj2);

Can I safely call clear to free up all the memory? Or do I need to iterate through to delete one by one?

    tempVector.clear();

If this scenario is changed to a pointer of objects, will the answer be the same as above?

    vector&lt;tempObject&gt; *tempVector;
    //push objects....
    tempVector-&gt;clear();

C++ delete vector, objects, free memory

C++20 introduced &quot;destroying [`operator delete`](https://en.cppreference.com/w/cpp/memory/new/operator_delete)&quot;: new overloads of `operator delete` that take a tag-type [`std::destroying_delete_t`](https://en.cppreference.com/w/cpp/memory/new/destroying_delete_t) parameter.

What exactly is this and when is it useful?

What is &quot;destroying operator delete&quot; in C++20?

Cosider the following code:

    class Foo
    {
        Monster* monsters[6];
        
        Foo()
        {
            for (int i = 0; i &lt; 6; i++)
            {
                monsters[i] = new Monster();
            }
        }

        virtual ~Foo();
    }

What is the correct destructor?

this:

    Foo::~Foo()
    {
        delete [] monsters;
    }

or this:

    Foo::~Foo()
    {
        for (int i = 0; i &lt; 6; i++)
        {
            delete monsters[i];
        }
    }

I currently have the uppermost constructor and everything is working okey, but of course I cannot see if it happens to be leaking...

Personally, I think the second version is much more logical considering what I am doing. Anyway, what is the &quot;proper&quot; way to do this?

C++ Array of pointers: delete or delete []?

According to N3290, `std::unique_ptr` accepts a deleter argument in its constructor.

However, I can&#39;t get that to work with Visual C++ 10.0 or MinGW g++ 4.4.1 in Windows, nor with g++ 4.6.1 in Ubuntu.

I therefore fear that my understanding of it is incomplete or wrong. I can&#39;t see the point of a deleter argument that&#39;s apparently ignored, so can anyone provide a working example?

Preferably I&#39;d like to see also how that works for `unique_ptr&lt;Base&gt; p = unique_ptr&lt;Derived&gt;( new Derived )`.

Possibly with some wording from the standard to back up the example, i.e. that with whatever compiler you&#39;re using, it actually does what it&#39;s supposed to do?

How does the custom deleter of std::unique_ptr work?

I often see legacy code checking for `NULL` before deleting a pointer, similar to,

    if (NULL != pSomeObject) 
    {
        delete pSomeObject;
        pSomeObject = NULL;
    }

Is there any reason to checking for a `NULL` pointer before deleting it? What is the reason for setting the pointer to `NULL` afterwards?

Is there any reason to check for a NULL pointer before deleting?

    #include &lt;queue&gt;
    using namespace std;

    class Test{
	    int *myArray;

            public:
	    Test(){
		    myArray = new int[10];
	    }
	
	    ~Test(){
		    delete[] myArray;
        }

    };


    int main(){
        queue&lt;Test&gt; q
        Test t;
        q.push(t);
    }

After I run this, I get a runtime error &quot;double free or corruption&quot;. If I get rid of the destructor content (the `delete`) it works fine. What&#39;s wrong?




All Delete Operator Solutions on Gang of Coders

Total of 23 Delete Operator Solutions