Thread: Strange main function

This main() does not conform to anything I can find in K&R, or any textbook, or C draft standard, but GCC compiles it with no complaints & it runs without errors. (Call it with no arguments.)

Code:

#include <stdio.h>

main(x,y,z) 
{
  printf("Hello world!\n");
  printf("x = %d, y = %d, z = %d\n",x,y,z);
  y = 2*x;
  if(x == 5)
    return;
  else 
    main( x+1,y,100 );
}

I also find that I can specify other types for the parameters, as in

Code:

main(x,y,z) double y; char z;
{
//...
}

or add any number and type of additional parameters -- in fact, apparently to do anything with main that I can with any other function, plus it seems that the parameters are ints by default, with no need to specify a type unless I want some non-numeric type.

Why does this work? Is this just a nonstandard "feature" to let us have fun obfuscating code, or is there a better explanation?

Why does this work? Is this just a nonstandard "feature" to let us have fun obfuscating code, or is there a better explanation?

It's standard, and it's not for fun. That's the way C used to work back in the bad old days (i.e., before 1989).

Well, actually, your definition of main() is nonstandard (too many parameters), but that sort of function declaration is standard. It's called K&R-style, and it should absolutely not be used in modern code. K&R-style declarations are not prototypes, and thus there is no type checking. That is a bad thing. The only reason the standard still allows K&R declarations is for backward compatibility.

The reason you can leave the types off is the same reason you don't have to declare main() as returning int. Before C99 there was another C misfeature, and that's implicit int. In a lot of places, if you don't specify a type, int is assumed. A K&R declaration is one of those places.

Code:

this_is_bad(x, y, z)
char *y;
double z;
{
}
void this_is_good(int x, char *y, double z)
{
}
int main(void)
{
  /* diagnostics not required */
  this_is_bad();
  this_is_bad(10, 20, 30);

  /* diagnostics required */
  this_is_good();
  this_is_good(10, 20, 30);

  return 0;
}

For the record, when I tested the above:

• gcc complains only about calls to this_is_good()
• sunstudio is the same as gcc
• clang complains about the first call to this_is_bad() and both calls to this_is_good()
• icc complains about all four calls

Each of the compilers is conforming, in that the required diagnostics are performed. They also variously complain about things with the K&R declaration, which is nice. Even if the code complies with the standard, it is terrible, and compilers are right to make noise.

I thought you could also declare main as "int main(int argc, char **argv, char **envp)". Or is that only valid any extension standard, such as in POSIX?

cas: Thanks for the explanation. Compiling my code with GCC 4.2.4. with option -W only gives these warnings:

Code:

 gcc -W xyz.c
xyz.c: In function ‘main’:
xyz.c:4: warning: type of ‘x’ defaults to ‘int’
xyz.c:4: warning: type of ‘y’ defaults to ‘int’
xyz.c:4: warning: type of ‘z’ defaults to ‘int’

and compiling with -Wall only warns about the return:

Code:

 gcc -Wall xyz.c
xyz.c:4: warning: return type defaults to ‘int’
xyz.c: In function ‘main’:
xyz.c:9: warning: ‘return’ with no value, in function returning non-void

I finally found some info about "old style" function declarations and calls in Appendix A7.3.2 and A8.6.3 of my K&R second edition , but nothing specific about main. It seems that there is nothing built into the compiler that restricts the parameter list of main to be only (void) or (int, char**). Is there anything actually written in the standard that requires main to only those two parameter lists?

Obviously I agree that this is horrible programming style. I only stumbled across it while trying to understand some intentionally obfuscated code.


Brafil: apparently you can declare main to be anything you want. It may be nonstandard, but the compiler doesn't seem to care. Can you compile this in MSVC?

Code:

#include <stdio.h>

main(x,y,z,a,b) double y; char z; char *a; double b;  // x will default to int
{
  if( x == 1 )
    printf("Hello world\n");
  else
    printf("x = %d, y = %f, z = %c, a = %s, b = %f\n",x,y,z,a,b);
  y = 2*x;
  if(x == 5)
    return;
  else 
    main( x+1,y,'c',"hello",3.3*x );

The standard requires a compiler to understand those two forms of main, and any other forms it feels could be handy (as mentioned above there is a third available in POSIX) (just as a compiler is allowed to do other extensions as long as it compiles "strictly conforming" code correctly).

Dunno. I would have to restart (using linux at the moment). It's not standard to me. At least, you can call main from main. return without a value is not allowed, neither is 5 parameters to main. y is a double, b too. etc etc.

In what sense is the "true prototype" of main

Code:

int main(int, char  **, char **)

?

According to my compiler warnings, not only does the return type default to int, but if I don't declare any argument types, all of the arguments default to int.

Would it be more accurate to say that the conventional prototype of main is "int main (int, char**)" and the standard prototype of main is "int main (int, char**, char**)"?

Yes, your example is legal but pointless, but my examples, posted earlier, may be non-standard, confusing, ugly, evil, etc., but not pointless, in that they actually do something.

The C standard specifies int main(void) or int main(int, char**) (or moral equivalents). POSIX also specifies int main(int, char**, char**), but not everybody cares about POSIX.

Would it be more accurate to say that the conventional prototype of main is "int main (int, char**)" and the standard prototype of main is "int main (int, char**, char**)"?

No. The two standard forms of main are: "int main(void)" and "int main(int, char **)". Implementations may accept others, but they would be non-standard. Unix-like systems accept a third parameter, in the form of an environment pointer, but it is not standard C.

Thanks, I finally found the full discussion of main in the "program startup" section of the draft standard (I don't have access to the actual current standard).

I guess GCC and other compilers allow alternate forms of main in order to maintain compatibility with old (pre-ANSI-C) code? The (draft) standard doesn't seem to be concerned at all with backward compatibility.