Question

From:
http://stackoverflow.com/questions/6337294/creating-an-object-with-or-without-new

This is probably a basic question, and might have already been asked (say, here); yet I still don't understand it. So, let me ask it.

Consider the following C++ class:

class Obj{
    char* str;
public:
    Obj(char* s){
        str = s;
        cout << str;
    }
    ~Obj(){
        cout << "Done!\n";
        delete str;
    }
};

what's the difference between the following code snippets:

Obj o1 ("Hi\n");

and

Obj* o2 = new Obj("Hi\n");

Why the former calls the destructor, but the latter doesn't (without explicit call todestroy)?

Which one is preferred?

Which C++ text book are you using? And have you looked at the "related" questions over there =======>>>>>>
Both are borken as they try and delete a pointer they do not own. You can not delete a pointe that was retrieved from "Hi there"
Even if they owned the pointers, the class itself would still be broken due to deleting the pointer in the destructor, but having compiler generated copy constructor and assignment operator (violation of the rule of the three). So any copy of the class would mean two objects trying to delete the same pointer
I hope you mean delete instead of destroy (which doesn't exist).
Along with the suggestions from others, you should be treating char* as array. So, use delete[] instead of delete.

Lightness Races in Orbit · Accepted Answer · 2011-06-13 22:52:07Z

Both do different things.

The first creates an object with automatic storage duration. It is created, used, and then goes out of scope when the current block ({ ... }) ends. It's the simplest way to create an object, and is just the same as when you write int x = 0;

The second creates an object with dynamic storage duration and allows two things:

Fine control over the lifetime of the object, since it does not go out of scope automatically; you must destroy it explicitly using the keyword delete;
Creating arrays with a size known only at runtime, since the object creation occurs at runtime. (I won't go into the specifics of allocating dynamic arrays here.)

Neither is preferred; it depends on what you're doing as to which is most appropriate.

Use the former unless you need to use the latter.

Your C++ book should cover this pretty well. If you don't have one, go no further until you have bought and read, several times, one of these.

Good luck.

Your original code is broken, as it deletes a char array that it did not new. In fact,nothing newd the C-style string; it came from a string literal. deleteing that is an error (albeit one that will not generate a compilation error, but instead unpredictable behaviour at runtime).

Usually an object should not have the responsibility of deleteing anything that it didn't itself new. This behaviour should be well-documented. In this case, the rule is being completely broken.

"Automatic storage duration" is colloquially known as "on the stack", (since this storage is usually part of the thread's function call stack, and is discarded when the function exits) and "dynamic storage duration" is colloquially known as "on the heap".
@Mike: Yes, and I despise those terms with an astronomical passion. It's quite deliberate that I did not employ them; I'm the last person that you'll ever see propagating those inaccurate phrases.
@Mike: (Still, I understand that it may be useful for the OP to be aware of the connection; so, thanks for that.)
I posted them because they're in the vernacular and Sadeq's going to see them. That's all. I don't care for them either, but I use both since I usually have to document embedded systems, where you really do need to know if something is on the stack or not.

Alston Chang codebook

2013/04/13

Stackoverflow history: 弄清楚 new/delete 是dynamic 在run time 且是heap, local 則是在stack

marked as duplicate by TheVillageIdiot, cobbal, Steve Fenton, Mehrdad Afshari, In silico Jun 14 '11 at 7:33

2 Answers

追蹤者