college needs help again...ya diggg

The only reason there would be stack corruption based on the parameters to main is if it's a "callee clean stack" function. In x86 that isn't the common case, although Windows __stdcall calling convention does that. However, main is not a __stdcall function, so it's the responsibility of the caller to clean up the stack.

Other architectures may vary of course, depending on what the functionality that different instructions offer. But C-code basicly requires caller-stack-cleanup because of the ability to take variable number of arguments - the called function may not know [from a static analysis standpoint] the number of arguments, so the clean-up will need to be in the calling code for these functions at the very least.

--
Mats

So even in C int main() is the same as int main(void)? Strange, I could have sworn that someone said they were different. Actually, I thought it was you.

Here's the "int main()" vs. "int main(void)" thread.

i need help with sorting an array

Edit: The only dispute is regarding the situation in C - in C++ they are definitely the same, since in C++ the absence of an argument in a function declaration means unambiguously that there aren't any.

Oh, it wasn't matsp. Sorry. Mistaken identity.

The only dispute is regarding the situation in C - in C++ they are definitely the same, since in C++ the absence of an argument in a function declaration means unambiguously that there aren't any.

I don't understand.

In C, int main() is okay, because it means that main()'s arguments are unknown, and when it's passed argc and argv, the code won't toast the stack because, not knowing if it would be passed arguments or not, it made allowances for being passed arguments; whereas int main(void) is not okay, because the code could assume that it's not being passed any arguments, and mess up the stack when it is passed argc and argv.

Am I right so far? brewbuck's post supports me, as far as I can tell.

Originally Posted by brewbuck

In case you're wondering... The reason you must not declare main(void) is because of parameter passing conventions. Under most ABI's, C parameters are evaluated and passed right-to-left, with the CALLER of the function being responsible for managing the stack. However it is conceivable that on some platform somewhere it is the CALLEE's responsibility to clean the stack.

The problem is, if the function is specifically declared to take a void argument list, the compiler (rightly) assumes that it will never be passed any arguments, so it will not produce the code necessary to fix the stack if arguments had been passed. Then, when the main(void) gets invoked, the C library DOES pass arguments (argc, argv), but main is not aware of this. So when main() returns, the stack becomes corrupt and things go wrong.

Okay. So when prototypes like int fputc() (that is, prototypes without parameters) were excluded from C++, int fputc() became the same as int fputc(void) -- that is, the function takes no arguments, rather than "this function takes an unknown number and type of arguments".

Wouldn't functions, such as main(), be the same way? int main() in C has suddenly become int main(void) in both C and C++. int main(void) is not good in C, so why should it be good in C++?

There must be a hole in my reasoning somewhere. Feel free to point it out.

[edit] It's probably that empty-function-prototypes-are-the-same-as-empty-function-declarations thing. [/edit]

A quick glance through that thread indicates that int main() is not valid in C because the C99 standard says so.

The C++98 standard says int main() is valid, and so we're done. C++ obviously has different requirements that force implementations to make it work.

If you do a prototype for a C function in C++, you should use

Code:

extern "C" int somefunction();

, which tells the compiler to use "classic C" prototype interpretation, rather than C++ interpretation.

Of course, it doesn't really matter if you use main() or main(void) in the case where the callee cleans up the stack - it's impossible for the callee to know how many arguments where passed - there is also

Code:

int main(int argc, char **argv, char **envp);

, where three arguments are passed.

--
Mats

Okay, good to know. Sorry, everyone, for hijacking the thread and all that.

Originally Posted by Daved

A quick glance through that thread indicates that int main(void) is not valid in C because the C99 standard says so.

The C99 standard explicitly mentions "int main(void)" but says nothing about "int main()".

http://c0x.coding-guidelines.com/5.1.2.2.1.html

Of course in C++ there's no need for "void" to indicate the absence of arguments. I think someone once called the use of "void" for this purpose an "abomination" that was only necessary because of the old-style K&R function declarations in C, which are not allowed in C99 or C++.

Originally Posted by robatino

Of course in C++ there's no need for "void" to indicate the absence of arguments. I think someone once called the use of "void" for this purpose an "abomination" that was only necessary because of the old-style K&R function declarations in C, which are not allowed in C99 or C++.

Several people in fact.. most notably, Bjarne Stroustrup said this about (void) between function parenthesis.
http://www.parashift.com/c++-faq-lit....html#faq-29.4