Two ways, Which one is better?

[wysota]

ok, i can follow this chain of thoughts..but one thing still bugs me..i read on some of the threads here that one should ALWAYS create widgets and dialogs on heap, layouts also..cuz once they go out of scope and parents try to delete them, crash occurs(obviously!)..

Only when both the parent and the child are created on the same frame of the stack or the child is created on the stack, the parent on the heap and you delete the parent while the stack frame holding the child is still valid. This is not the case here and it's one of few exceptions when it's ok to create a widget on stack.

so when u say child "detaches" itself from parent when goin out of scope..wont that occur in other cases too and parent wont try to delete ths child?

The problem is with double deleting the same object. Consider a situation when the parent is on the heap, the child is on the stack and you delete the parent. When this happens, the parent deletes all its children including the one child residing on the stack. So far this is fine. The trouble begins when the stack frame holding the child widget goes out of scope. The compiler calls destructors of all object residing in the frame including the child widget. Unfortunately the child has already been deleted earlier so we're trying to destroy an object that has already been destroyed which results in aborting the process.

and why the recommendation(in multiple threads) that these things SHOULD be created on stack.

With modal dialogs it is easier to create them on the stack because you don't have to worry about deleting them afterwards because the compiler does that for you.

.how and when(in what cases) would a child detach from parent?

When it's deleted. The case we're talking about is not related to not detaching from the parent but to double deletion caused by the compiler. And we can't overcome that so you shouldn't create widgets on the stack if you fear the parent might be deleted before the child is deleted.

my main concern is how would a parent know the child has already gone out of scope and not try to delete it?

The parent (during runtime) knows. The compiler (during compile time) does not.

i mean once u give a widget a parent, deleting it yourself should be kinda foolish?

I'd say it would be foolish if you couldn't delete an object if you wanted to.

[talk2amulya]

thanks wysota, so i was thinkin that parent might try to delete a child created on stack which should produce crash..so in nutshell, parent would know when a child is deleted and it wont try to delete it..but still, if i create an object on stack like this

QWidget *someWidget = new QWidget();
QDialog dialog(someWidget);
delete someWidget; // crash here?

QWidget *someWidget = new QWidget();
QDialog dialog(someWidget);
delete someWidget; // crash here?

To copy to clipboard, switch view to plain text mode 

in the destructor of parent class(QWidget), they are calling delete on children even when they r created on stack which should produce instantaneous crash..it shouldnt even reach the compiler created code for removing the dialog object or would it? i tried something similar and although it sort off showed a weird crash at delete of child..but somehow it went ahead and executed the code further and then crashed later when the stack tried to delete the dialog object..how was this possible? plus doesnt this show real proof that creating qobjects on stack with a parent should be a big no-no? i mean yeh, the case of hellodan survives this, but shouldnt doing this be discouraged?

[wysota]

in the destructor of parent class(QWidget), they are calling delete on children even when they r created on stack which should produce instantaneous crash.

it shouldnt even reach the compiler created code for removing the dialog object or would it?

Hmm... I guess it depends on the operating system. It might detect you are trying to delete a pointer that is in stack address space which is obviously going to lead to a crash anyway and might terminate your process. But I guess it doesn't have to at least I'm not aware of any C++ rule about what happens after you delete a non-heap pointer.

i tried something similar and although it sort off showed a weird crash at delete of child..but somehow it went ahead and executed the code further and then crashed later when the stack tried to delete the dialog object..how was this possible?

That's the variant I described earlier - a double delete caused by the compiler.

plus doesnt this show real proof that creating qobjects on stack with a parent should be a big no-no? i mean yeh, the case of hellodan survives this, but shouldnt doing this be discouraged?

It is discouraged My opinion is that you can use any mechanism the language supports if you know what you are doing. You might even use "goto" if you want. And there is always a chance of shooting yourself in the foot and yet nobody prevents you from doing that. Consider this:

Object o;
delete &o;

Object o;
delete &o;

To copy to clipboard, switch view to plain text mode 

or:

Object *o;
delete o; // with a bit of luck this will not always crash...

Object *o;
delete o; // with a bit of luck this will not always crash...

To copy to clipboard, switch view to plain text mode 

I might offend some of the people here but in general I'm against "enlightened users" writing software. If they implement crashing code, that's their choice, they have been warned. Someone who knows the language well and knows the internal behaviour of computer systems will know when to create something on the heap and when to create it on the stack.

[talk2amulya]

Hmm... I guess it depends on the operating system. It might detect you are trying to delete a pointer that is in stack address space which is obviously going to lead to a crash anyway and might terminate your process. But I guess it doesn't have to at least I'm not aware of any C++ rule about what happens after you delete a non-heap pointer.

i believe its not dependent upon operating system. I tried my example with minGW compiler and VC++ compiler, both gave different results. on VC++ compiler, the application crashes while deleting an object created on stack, whereas when using minGW compiler, on the same operating system(Windows xp), it didnt crash there but when compiler is double deleting. Perhaps VC++ takes a stand on the deleting of non-heap pointers. Anyways, i think to answer the question of hellodan, one would say the creation of object on heap would be a better solution but thats just me

[wysota]

i believe its not dependent upon operating system. I tried my example with minGW compiler and VC++ compiler, both gave different results. on VC++ compiler, the application crashes while deleting an object created on stack, whereas when using minGW compiler, on the same operating system(Windows xp), it didnt crash there but when compiler is double deleting. Perhaps VC++ takes a stand on the deleting of non-heap pointers. Anyways, i think to answer the question of hellodan, one would say the creation of object on heap would be a better solution but thats just me

It only means it is also dependent on the compiler.