C ++-需要帮助了解删除功能

Question

I've been having trouble understanding the delete and delete [] functions in C++. Here's what I know so far:

aClass *ptr = new aClass();    //Allocates memory on the heap for a aClass object
                               //Adds a pointer to that object
...
delete ptr;                    //ptr is still a pointer, but the object that it
                               //was pointing to is now destroyed. ptr is 
                               //pointing to memory garbage at this point
ptr = anotehrOjbectPtr         //ptr is now pointing to something else

In the case that this happens,

aClass *ptr new aClass();
...
ptr = anotherObjectPtr 

the object that pointer was pointing to, is now lost in memory, adn this will cause a memory leak. The object should've been deleted first.

I hope the above is correct

But I wrote this small program, where I'm getting some unexpected behaviour

#include <iostream>
#include <string>
using namespace std;

class Database {
    private:
        Database() {
                arrNames = NULL;
                capacity = 1;
                size = 0;
        }
        Database(const Database &db) {}
        Database &operator=(const Database &db) {}
        string *arrNames;
        int capacity, size;
    public:
        static Database &getDB() {
                static Database database;
                return database;
        }
        void addName(string name) {
                if (arrNames == NULL) {
                    arrNames = new string[capacity];  
                }
                if (size == capacity - 1) {  
                    capacity *= 2;  
                    string *temp = new string[capacity];
                    int i = 0;
                    while (i <= size) {   
                        temp[i] = arrNames[i];
                        i++;
                    }
                    delete [] arrNames; 
                    arrNames = temp;  
                }
                arrNames[size] = name;
                size++;
            }
            void print() {
                int i = 0;
                while (i <= size) {
                    cout << arrNames[i] << endl;
                    i++;
                }
            }
};

int main() {
        Database &database = Database::getDB();
        Database &db = Database::getDB();
        Database &info = Database::getDB();

        database.addName("Neo");
        db.addName("Morpheus");
        info.addName("Agent Smith");

        database.print();
        db.print();
        info.print();
}

In the addName function, when I call delete [] arrNames, what I think is happening is that the memory associated with the current array arrNames is destroyed, so arrNames is now pointing at garbage, Then arrNames is directed to point to another location in memory that is pointed to by temp. So if I hadn't called delete [] arrNames, then that location in memory would've been invalid, causing a memory leak. However, when I comment out that line, the code still works without problems. Am I not understanding something here?

Sorry that this si so long Thanks for the halp

Answer 1

However, when I comment out that line, the code still works without problems. Am I not understanding something here?

An important thing to know about programming is that doing things correctly is not merely a matter of having things apparently work.

Often times you can try something out hand have things appear to work, but then some outside circumstances change, something you're not explicitly controlling or accounting for, and things stop working. For example you might write a program and it runs find on your computer, then you try to demo it to someone and happen to run it on their computer, and the program crashes. This idea is the basis of the running joke among programmers: "It works for me."

So things might appear to work, but in order to know that things will work even when conditions change you have to meet a higher standard.

You've been told how to do things correctly with delete , but that doesn't necessarily mean that things will break in an obvious way if you fail to do so. You need to abandon the idea that you can definitively determine whether something is correct or not by trying it out.

Answer 2

From what I think I see in your code, it looks like addName() is meant to append the new name onto the dynamic array. Doing this yourself can be headache inducing, and there is an existing convenient STL template for just this which I strongly recommend, called vector , from the <vector> header. If you add #include <vector> and change string *arrNames to vector<string> arrNames , then your entire addName() function can be reduced to:

void addName(string name){
    arrNames.push_back(name);
}

From the vector.size() method, you can determine the current length of the vector as well, and your members capacity and size are no longer needed.

Answer 3

A memory leak doesn't involve anything being made invalid. Quite the reverse, it's a failure to make a memory location invalid, causing it to remain in use even when it shouldn't be.

Answer 4

First of all, when you delete something, you are not destroying it in memory, just making it available for some further allocation. This is somewhat similar to filesystem - when you delete file, you just say space it occupied is now available for some new data. You could actually retrieve unmodified data after you called delete on them, but this is undefined behavior and will be compiler/OS specific.

If you don´t delete[] arrNames , you leave its data forgotten in your process´s memory, and creating memory leak. But beside this fatal flaw, there is no more magic happening.