Can it make a difference? Will be the compiler browsing place an error?
8 Solutions 8
It causes undefined actions. Such a thing sometimes happens. Used, a runtime accident is most likely the thing I’d expect.
Undefined attitude. There are no guarantees at all created by the conventional. Probably your operating-system helps make some guarantees, like “you don’t corrupt another processes”, but it doesn’t assist your own plan really.
Their system could crash. Your data maybe corrupted. The drive deposit of your subsequent paycheck could alternatively bring 5 million cash through your account.
It is vague actions, therefore the genuine benefit may differ according to compiler & runtime atmosphere.
In most cases, the compiler won’t notice. A number of, otherwise the majority of, cases, the runtime memories administration library will freeze.
Under the bonnet, any memory supervisor has to keep some metadata about each block of information it allocates, in a manner that allows it to look-up the metadata from pointer that malloc/new returned. Typically this takes the form of a structure at fixed offset before the allocated block. This design can include a “magic numbers” — a consistent that’s unlikely to happen by pure odds. If memory space supervisor sees the miraculous amounts in forecasted room, they understands that the pointer provided to free/delete is probably appropriate. Whether or not it does not begin to see the magic number, or if perhaps they sees a unique wide variety it means “this tip got not too long ago freed”, it could possibly calmly ignore the free of charge demand, or it may reproduce a helpful message and abort. Either is actually legal underneath the specification, and there tend to be pro/con arguments to either strategy.
In the event that memories supervisor does not hold a miracle wide variety from inside the metadata block, or doesn’t usually check out the sanity for the metadata, next something can occur. Based the way the memory supervisor try applied, the result is almost certainly a collision without a helpful message, either instantly from inside the memories management logic, rather later the next time the memory management tries to set aside or no-cost memories, or a lot later and faraway whenever two some other part of this system each consider they have possession of the identical amount of mind.
Why don’t we test it. Rotate their signal into a whole regimen in so.cpp:
Compile it (I’m using gcc 4.2.1 on OSX 10.6.8, but YMMV):
Lookie there, the gcc runtime actually finds it absolutely was a double remove and is fairly useful earlier crashes.
While this is vague:
that is well-defined:
Thought i will send they since not one person else got mentioning they
The compiler can provide a caution or something, especially in obvious (like inside sample) but it’s difficult because of it to always recognize. (You are able to something like valgrind, which at runtime can detect it though). When it comes to habits, it can be anything. Some safe collection might examine, and take care of it good — but different runtimes (for performance) makes the expectation your contact are appropriate (which it’s maybe not) immediately after which freeze or even worse. The runtime was permitted to make assumption you aren’t dual deleting (regardless of if dual deleting would do one thing bad, e.g. crashing your computer)
People already told you that you must not do this and this can cause vague conduct. Definitely well known, very let’s elaborate on this on a diminished degree and let us see what really occurs.
Regular universal answer is that nothing can occur, that’s not totally genuine. Eg, the computer cannot attempt to destroy your for this (unless you might be programming AI for a robot) 🙂
The key reason why there can not be any worldwide answer is that as this is undefined, it could change from compiler to compiler and even across various variations of exact same compiler.
But this is what “roughly” happens in many cases:
delete feature 2 primary surgery:
- it phone calls the destructor whether it’s explained
- they in some way frees the memories allocated to the thing
So, should your destructor has any signal that accessibility any data of course that currently was actually deleted, it might segfault otherwise (likely) you certainly will browse some rubbish facts. If these removed information tend to be tips this may be will likely segfault, because you will attempt to access memory which has something else, or does not are part of you.
If the constructor does not touching any facts or perhaps isn’t present (why don’t we maybe not start thinking about digital destructors here for convenience), may possibly not getting a real reason for collision in most compiler implementations. But phoning a destructor is not the best procedure which is going to occur here.
The memories needs to be free’d. How it’s finished relies on implementation in compiler, it might as well execute some cost-free like function, offering they the pointer and measurements of their item. Phoning complimentary on memory space which was already erased may crash, because memory may not participate in you any longer. If it does participate in your, it may not freeze right away, but it may overwrite memory which was currently allocated for a few various item of your own program.
That means one or more of one’s memories tissues just got corrupted and your system will likely freeze at some point or this may behave very weirdly. The reasons will not be apparent inside debugger and you might spend weeks figuring out what the hell just occurred.
Very, as other people said, it’s normally an awful idea, but i guess you are already aware that. Don’t be concerned though, innocent kitten does not really pass away should you delete an object two times.
Listed here is example rule that will be wrong but may operate just fine nicely (it functions OK with GCC on linux):
Basically don’t produce advanced incidences of these class between deletes, 2 calls to release in same memory space occurs not surprisingly:
To respond to your questions straight:
What’s the worst that will occur:
In principle, your plan causes something fatal. It might actually randomly make an effort to sugar baby in Arizona clean the hard drive in certain extreme cases. The possibilities is dependent upon exactly what your system actually is (kernel drivers? consumer room plan?).
Used, it might almost certainly merely freeze with segfault. But something notably worse might occur.
Will be the compiler gonna put one?