Path: utzoo!utgpu!water!watmath!clyde!cbosgd!ucbvax!husc6!cca!g-rh
From: g-rh@cca.CCA.COM (Richard Harter)
Newsgroups: comp.lang.c
Subject: Re: exit(-1), 0 is sometimes magic
Summary: What is a magic number?
Keywords: exit, zero, flaming
Message-ID: <23329@cca.CCA.COM>
Date: 17 Jan 88 05:54:39 GMT
References: <502@cresswell.quintus.UUCP> <6935@brl-smoke.ARPA> <1179@wjvax.UUCP> <6983@brl-smoke.ARPA> <7208@ki4pv.uucp> <23160@cca.CCA.COM> <1843@bsu-cs.UUCP> <2305@bloom-beacon.MIT.EDU> <1868@bsu-cs.UUCP>
Reply-To: g-rh@CCA.CCA.COM.UUCP (Richard Harter)
Organization: Computer Corp. of America, Cambridge, MA
Lines: 92

In article <1868@bsu-cs.UUCP> dhesi@bsu-cs.UUCP (Rahul Dhesi) writes:
>I gave a number of example attempting to show that zero is inherently
>a unique integer and therefore not a "magic number" in the usual
>sense of the term.
>
	... Discussion of the properties of zero deleted ...
>
>It seems to make perfect sense to me that in the non-VMS world in which
>a single successful termination value, and multiple failure termination
>values, are needed, zero should be the successful termination value.
>
>Therefore the use of exit(0) for successful termination is not
>arbitrary.  It is intuitively correct.

	This is perhaps my fault for assuming that everyone knows
what is meant by a magic number, as in "don't use magic numbers".
Let me give an example.  Look at the following code:

	char foo[57];
	....
	for(i=0;i<57;i++) {...}
        foo[55]='\n';
	foo[56]='\0';

As we all know, this kind of code is likely to create maintenance
problems.  If, for some reason, we want to change the size of foo,
we must identify and change every occurence of 57, including the
indirect ones.  Experienced programmers will prefer something like
this

	#define size 57
	....
	char foo[size];
	....
	for (i=0;i<size;i++) {...}
	foo[size-2]='\n';
	foo[size-1]='\0';

This has two advantages.  The number, 57, is explicitly referenced only
once, which makes it much easier to alter.  The name, size, has a specific
meaning that is relevant to, and limited to, its actual usage.  A magic
number is a number embedded in code that has a special meaning in the
context of the code.  In this context 57 is a magic number.  0,1, and
2, as used, are not, because they are implied by the conventions of the
language.  Note that it is the usage and meaning that determines whether
a number is a magic number or not.  It is considered good programming
practice to avoid using magic numbers.

Numbers which represent encoded values are magic numbers.  For example,
if I write a function which returns a number returning a color, with
0=red, 1=blue, and 2=green, I will do better if my code says

	return red;

(with read appropriately defined) than if I say

	return 0;

In addition to the two advantages I cited above, there is a third
advantage in this case.  If I hard code the encoded values, the encodings
have to be known in two places -- in my function and in the program(s)
calling my function.  Life will clearly be simpler if the encodings
are in a common place shared by my function and the program(s) that
call my function.  This will be particularly true if my function is
going to be used by several different programs which may use different
encodings.

My apologies for going on at length about basic principles, but it would
appear that these thoughts are novel for some people.

Rahul argues above that zero has various special properties, and that
it is therefore the "best" choice for representing successful termination.
This is irrelevant.  It doesn't matter whether zero is the "best"
choice or not.  It would still be bad practice to return zero, even
if all operating systems accepted it as meaning successful termination.
As we know, some do, and some do not.

I will concede that 'exit(0)' is standard practice in UNIX environments,
and that there has been, heretofore, for standard for sharing encodings
of the returned value with the host operating system.  I also recognize
that if you are only concerned with C programs running under UNIX, then
it won't matter if you write exit(0).  If it doesn't matter in your
case, and you are not a purist about good programming practice, then
the issue is moot.

If, however, you are dealing with software that will have to run on
a variety of machines and operating systems then it matters very much.
-- 

In the fields of Hell where the grass grows high
Are the graves of dreams allowed to die.
	Richard Harter, SMDS  Inc.