The main argument (no pun intended) is that the programming usage
follows from mathematics: f(x) and so on. Even having seen the inserted
space for some time (I thinks it's relatively new) I still can't shake
off the sense it gives of a parenthetical remark:
f(x) + y // f applied to x plus y
f (x) + y // f plus y (and by the way, x)
Silly, I know, but it's only fair that there be a comment from someone
who hates this style!
In said:That was the question, can you think of a single case where somebody
died as a result of an incorrect return value of main()? Can you
even come up with a far-fetched hypothetical (primarily for amusement
value, of course)?
Wrong, this is a program that contains numerous basic/*
Here's a program which enhances a medical X-ray image, essential so
a human expert can analyse the image to see if a disease is present.
*/
int main(int argc, char **argv)
{
unsigned char *image;
int width, height;
int err;
if(argc != 3)
{
/* we were called with the incorrect number of arguments. Tell
user how to use program */
printf("Usage: enhanceimage <xrayimage.jpeg> <enahncedoutput.jpeg>
\n");
return EXIT_FAILURE;
}
image = loadjpeg(argv[1], &width, &height);
if(!image)
return EXIT_FAILURE;
err = enhanceimage(image, width, height);
if(err != 0)
return EXIT_FAILURE; /* for some reason algorithm to enhance image
fell over */
err = savejpeg(argv[2], image, width, height);
if(err != 0)
return EXIT_FAILURE;
free(image);
Did you even bother to link the relevant libraries?/* image loaded, enhanced and saved correctly */
return 0;
}
Now some medical programming person is using a high-level language,
maybe Perl, to dish up the enhanced images to a webserver.
Patient DEAD, and not just because of all YOURHe writes
$enhancedimagename = "temp.jpeg"; # put the enhanced image in a
temporary buffer
$err = system($rawimagename, $enhancedimagename);
if($err == 0)
diplayimage(enhancedimagename);
else
# do something here to indicate that the image held in temp.jpeg is
NOT an enhanced image for the correct patient.
This might not be the best-designed system in the world.
But it is
correct.
This is why I don't like to go to the doctor; the sameThe return provides an easy way to tell the calling script
whether the image was correctly enhanced or not.
Got anything for mpegs? Including the Dolby Digital(TM)For implementations of savejpeg() and loadjpeg() read Basic Algorithmshttp://www.malcolmmclean.site11.com/www
That's a very low-level detail, unlikely to be known by anyone who wasn't
directly involved in such an incident.
Not to mention immoral and fattening...no honest decent personAsking for such information seems
dishonest.
Well, it's a little amusing, I give you that, but mostly just sad,Imagine a medical device that emits radiation for treatment of cancer.
Imagine that the device determines the amount of radiation to be emitted
by calling a program and inspecting the exit value. One day the called
program exits with an incorrect value and the device emits too much
radiation, killing a patient.
That's a detail that would be well and fully hashed out in
a wrongful death/malpractice suit, IN PUBLIC COURT...
Not to mention immoral and fattening...no honest decent person
would ever inquire about the exact causes of another person's
death, it's just unseemly...autopsies and coroner's reports
should be banned, FREE THE HONORABLE CONRAD MURRAY!!!
In said:What I keep coming away with from this group is how completely,
totally, and absolutely irrational and illogical the regular posters
are; what's really scary is if you think that the poster might
actually try to implement a safe radiological machine as described
above...
I forgot. Fortunately modern compilers will pick up that error, andWhat's "printf()"? Where did you prototype it?
If the program doesn't link, no executable will be generated at all.Did you even bother to link the relevant libraries?
Now some medical programming person is cursing your
complete incompetence...
The patient can't die because of my personal incompetence. That's thePatient DEAD, and not just because of all YOUR
egregious programming errors...also, couldn't he
have just used "enhanceimage()" in the script if
you had merely compiled THAT as a complete program?
The trivial is important. If you set up an expectation that programsYou think? Sheesh...you're the Conrad Murray of medical
programmers...
For very small or inverse values of "correct"...
This is why I don't like to go to the doctor; the same
kinds of goofballs who can't write a simple Internet
browser that works properly hold my life in their hands...
I also explicitly said I only wanted it to laugh at...You explicitly asked for a "far-fetched hypothetical" example.
You took the bait...SUCKER!!!I gave you one.
Thanks for playing...You criticised it for being "scary" and unsafe.
Obviously the person who is so desperate to proveWho is being irrational and illogical here?
Well, as always, thank you for making my point for me, thoughCourts are going to care that a program failed specifically due to an
erroneous return value from main(), and not any of the other million
ways a program can fail?
Anybody who has been following the Conrad Murray trialSince you put such stock in this information being public, please be so
kind as to supply a few examples.
What are you saying, you reject the findings of theSigh.
Your code layout makes my eyes bleed, especially with long lines being
folded (probably by some news software somewhere).
Here's a reformatted version of your program, with some bugs correct.
It's still not perfect (I find that I have to type control-D twice to
exit). Study the changes I've made and the comments I've added. Note
in particular that I've dropped the call to getch(), which is
non-standard.
#include <stdio.h>
#include <math.h>
const long double Pi = 3.14159265358979323846;
float area(float r) {
return r*r*Pi;
}
float perimeter(float r) {
return 2*Pi*r;
}
int main(void) {
/* system("cls"); */
/*
* Why do you want to clear my screen when I run your program?
* And what if I run it on a system that doesn't have a "cls"
* command -- or, worse, that has a "cls" command that does
* something else? If I want to erase my screen, possibly
* destroying information that has nothing to do with your
* program, I can do it myself, thankyouverymuch.
*/
float r=0;
int c;
int items_read;
/* define radius and c variable used to control the behaviour
of program; 'i' needs to clean input buffer*/
printf("This programm calculate Area and Perimenter of a Circle");
do {
printf("\n\nPlease insert radius value (in cm): ");
fflush(stdout);
items_read = scanf("%f", &r); /*input of the radius value*/
if (items_read == 1 && r > 0.0) {
printf("\nArea is cm2: %.2f \n\nPerimeter is cm: %.2f\n",
area(r),
perimeter(r));
}
else {
printf("\nValue must to be a valid number\n");
}
while ((c=getchar()) != '\n' && c != EOF)
;
} while (c != EOF);
return 0;
}
Gordon Burditt said:*For further details, consult the documentation of the program you
are running.*
In a very real sense, the OS doesn't *use* the return value from
main() much (although it might log it). It provides the information
to applications, so *applications* can use it. The applications
generally know what they are invoking, and can use program-specific
knowledge of what the program they are invoking does (and they need
similar knowledge to correctly invoke the program in the first
place). I am taking a somewhat narrower view of "OS" and a wider
view of "applications" than some may be used to. The kernel, command
interpreters, and such are included, but program development software
like compilers isn't, even if it comes with the OS distribution.
For many programs the binary SUCCESS/FAILURE return is useful. One
that uses it extensively is "make": it stops a program build if a
step fails. There is a syntax to avoid the abort, if desired, for
specific commands. Compilers, assemblers, linkers, etc. return an
appropriate values. GCC's -Werror option lets you decide to stop
builds on warnings if compiling from "make". If a program *aborts*,
say by calling abort(), segmentation violation, manually being
killed, or being interrupted with a character typed from the keyboard
(e.g. ^C), etc., it is given an exit status which is treated as a
failure, so it may still be useful to test the status even if the
program never does exit(EXIT_FAILURE). Shells use this so they
(not the program that crashed) can print "Segmentation violation"
when it happens.
There are also a bunch of little UNIX shell commands like test,
expr, etc. whose primary function is to test something and set the
return code accordingly, so shell scripts can do conditional testing.
This is one thing that makes shell scripts powerful. Shells make
the return code available to shell scripts, which can use it to
take action to notify of failures or recover from them.
Program termination codes go back at least as far as OS/360 JCL,
where "error" status from a compiler indicated that you shouldn't
bother trying to link the resulting object code (if any was produced).
It's unfortunate that UNIX really only had one standard "success"
value. For example, there are a number of "file compare" programs
(cmp, diff, rcsdiff, etc.) which are usable from shell scripts and
other programs that want to give one of 3 possible results:
files compare equal (0)
files compare unequal (1)
comparison failed (e.g. file does not exist, permission denied,
i/o error, etc.) (2)
where the first two are really two different kinds of "success",
but you can't indicate that, so "files unequal" is treated as a
different subtype of failure. File search programs like "grep" and
family also use this return code pattern (match found / no match
found / problems scanning file). I have sometimes wished for two
different symbols:
EXIT_SUCCESS_WITH_PROMOTION_AND_RAISE
and
EXIT_SUCCESS_YOU_GET_TO_KEEP_YOUR_JOB_ANOTHER_WEEK
which denote two different levels of "success".
Many programs will report obvious failures to do what was requested
with EXIT_FAILURE if the OS returns errors like I/O error, permission
error, file does not exist, out of memory, out of disk space, etc.,
and it wasn't able to work around it. Testing the return status
of a "file copy" program should provide an indication of whether
it worked or not, to the extent that the OS reports problems back
to the program.
Programs that need more complex status returned to their invoker
can go beyond the C standard and use the POSIX guarantee of being
able to return 0 - 255. (Other programs have been known to use
standard output or standard error, which the invoker redirects and
parses). Return codes are not a substitute for error messages
giving specific detail (like the name of the file the operation
failed on, what operation was attempted, and what error you got).
There is a whole include file, <sysexits.h> (not specified by any
standard as far as I know, and used extensively by Sendmail), full
of exit return codes for *MAIL TRANSPORT PROGRAMS*. Mail transport
programs try to deliver mail using various methods and use specific
exit codes (forms of failure) beyond those specified by the C
standard, and programs that call them can either treat any value
not equal to 0 or EXIT_SUCCESS as a failure, or they can use specific
knowledge of the failure type to determine remedial action (for
example, retrying the exact same request again later is highly
appropriate for some error classes and pointless for others). The
return codes in <sysexits.h> might be stretched to deal with some
other network-oriented program but they are not useful for programs
in general.
Some examples:
EX_NOHOST - the host specified did not exist.
EX_NOUSER - the user specified did not exist.
EX_USAGE - the command was used incorrectly, e.g. with the wrong
number of arguments, a bad flag, or bad syntax.
EX_TEMPFAIL - a temporary failure, such as not being able to create
a network connection, and the request should be retried.
EX_OSFILE - some system file does not exist, cannot be opened, or
has some sort of error.
EX_IOERR - An error occurred while doing I/O on some file.
It's impossible to come up with a useful set of universal exit
codes. Programs have too much variety. A program "identifylanguage"
given a text file might use exit(54) to mean "Vietnamese". Also,
any blatantly obvious success condition (like "file *DOES* exist")
can be a fatal error. Beyond the class of "success" or "failure",
code meanings will be individual by program (or perhaps group of similar
programs) if you want to use under 128 bits for an exit code.
A hopelessly interactive program (such as an editor) should report
errors to the user via stderr (or a window pop-up, or whatever)
instead of exiting, although having an editor being fed a script
report blatant problems like not being able to open or save files
or running out of memory or disk space via return code (in addition
to an error message) is useful.
A co-worker once decided (well before C89) that a program that
dropped off the end of main() should return 0, rather than random
status. Unfortunately, the unauthorized and untested change he
made also had the effect that "return N;" in main() also returned
0. The change he made affected the cross-compiler, meaning it would
return successful status for anything it tried to compile whether
it worked or not. Someone introduced a typo into a critical part
of the C library for the target system. The result: an overnight
build which *apparently* succeeded, (as opposed to a build which
should have died in half an hour) yet not one program in the whole
build worked. I detected this problem before the resulting build
was actually shipped over to QA - otherwise management might have
killed someone.
My stile is my stile, i will try to improve it but it is going to take<snip>
your code is still rather poorly laid out.
"write as little as possible" or "write as few lines as possible"?
Sounds like a variant on
"everything should be made as simple as possible, but no simpler"
Some Scientist
I'd say strive for clarity. So don't pack your code really tightly if
it obscures your purpose. Write simple straightforward code. Only
deviate from this if you need (*really* need) the performance or some
other constraint pushes you away from perfect clarity.
I wish I was decended from bears but my wishes don't change the facts.
layout, clarity etc. if your progarm is going to have any sort of
extended lifetime. Unlikely in this case but it's sensible to start
with good habbits.
Yes, a court is going to be very rigorous in assigning BLAME
for a wrongful death (or in the current high-profile Conrad
Murray case, involuntary manslaughter due to criminal negligence).
What are you saying, you reject the findings of the
defense expert regarding the levels of unmetabolized
propofol in Michael Jackson's urine at autopsy as being
My stile is my stile, i will try to improve it but it is going to take
its way.
I always will comment my code, if in the future you should read some
my program, it is sure you find all needs to understand and to change
it!
As short, as clear, as well as possible.
Oh great, somebody who knows how computers work, I've been looking
for somebody like that to explain something...
Oh yes, people could die...soooooooo, please explain how a
common OS, such as say, Windows(TM), uses the return value
from main()? Or for that matter, a TRUE Unix(TM)? Or any
other OSs that you are an expert on?
And while you're on the subject, how should a computer
expert such as yourself set the return value of main() to be
correct?
Can you define what conditions would cause me to set it one
way or another? Of course, I'm assuming that since the
ANSI C committee decreed that main() have a specific set
of return values, every computer in the world conforms
to those values and does something useful with them, so
I would have perfect "portability" between platforms
for my "correct" C code, and nobody would die as a result
of my using an incorrect return value...
Also, what's "winmain()"? I've seen that a lot, returns
something called a "Windows handle", what's up with that?
You know, I've asked these questions here before, but
never received an answer, but I'm sure that's because
there wasn't a computer expert such as yourself to answer
them...
P.S. Note carefully that I didn't ask if it was OK
to return a value from main() (or any function) when
the function prototype does not have a return value,
and I always use the correct prototype for main(),
just because it's annoying to have the error messages
from the compiler, just like this topic is annoying...
*For further details, consult the documentation of the program you
are running.*
In a very real sense, the OS doesn't *use* the return value from
I'm curious about the whole 'int' return type placed on 'main' as
well. The only idea that I can come up with is that since Ritchie
designed C to support the Unix operating system, and the Unix
operating system wanted to implement pipes for inter-program
communication, 'int main(...)' became the de-facto standard to use the
return value in that sense.
What's interesting is that there are
other scenarios where returning a value from 'main' makes little to no
sense, like in embedded systems designed to run a single stand-alone
application "forever", with no opportunity for inter-process
communication, and yet 'void main(...)' is ridiculed even though it
seems to have a logical place in some application design domains.
I'm curious about the whole 'int' return type placed on 'main' as
well. The only idea that I can come up with is that since Ritchie
designed C to support the Unix operating system, and the Unix
operating system wanted to implement pipes for inter-program
communication, 'int main(...)' became the de-facto standard to use the
return value in that sense. What's interesting is that there are
other scenarios where returning a value from 'main' makes little to no
sense, like in embedded systems designed to run a single stand-alone
application "forever", with no opportunity for inter-process
communication, and yet 'void main(...)' is ridiculed even though it
seems to have a logical place in some application design domains.
Pasquale Frega said:Hi all, a simple question about "scanf":
can i set it in manner to read a simple return with nothing or an
escape?
If no, what can i use?
Thanks!
Want to reply to this thread or ask your own question?
You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.