Re: Why does C/C++ programs crash
"Ian Collins" <ian-news@hotmail.com> wrote in message
news:4h5p1gF1phdo1U5@individual.net...
NewToCPP wrote:
Hi,
Why does a C/C++ programs crash?
When there is access to a null pointer or some thing like that programs
crash, but why do they crash?
What would you suggest as an alternative?
Normally it isn't the program that crashes, but the operating
environment that terminates the program when it attempts to access
something that doesn't belong to it. The contents of address 0 for
example.
Well, consider this (untested) program.
int main()
{
int MyInt = 10;
int* MyIntP;
MyIntP = &MyInt;
MyIntP = 20; // Ooops, meant *MyIntP = 20 here
std::cout << MyIntP << std::endl;
*MyIntP = 30; // Got syntax right this time, but pointer is wrong
}
What would you suggest this program to do? Given the proper headers it
should compile and run as it is all legal code. But the programmer made a
mistake on one line. Instead of changing the contents of a pointer to a
value, they accidently changed the pointer itself. Then they tried to view
to the contents of the pointer, and then change the contents of the ponter.
What is the computer supposed to do? MyIntP = 20; is legal. There may be
cases where it's actually valid and is what was meant to do. But in this
case it's just wrong logically.
The next line the program is supposed to output the contents at the pointer,
but the pointer is pointing to memory the program doesn't "own". In fact,
depending on how the architecture and OS is set up, it may not even be
pointing to memory at all. What would you have the program do when it gets
to this point? On windows an error message will pop up stating that the
program attempted to read memory it doesn't "own". That is a crash. What
alternative is there?
If that last line was commented out, what would you have the next line do?
It is attempting to write to memory the program doesn't "own" Windows again
pops up with an error, this time saying the program is trying to write to
memory the program doesn't "own".
There are many reasons that the OS doesn't allow you to just write to memory
willy nilly. Mostly because it's usually a bug when you try to do so as
this shows.
Do you have an alternative? Of course, I could put in try ... catch blocks
and catch the errors in my program, but what could I do more than give my
own message saying I'm trying to use memory I don't own? The program
obvoiusly can't continue at this point, because the compiler/OS/program has
no way of knowing if the line that was trying to run was critical to the
program or not.