Why to put argc argv arguments in main when they never accessed?

Question

I often see programs where people put argc and argv in main , but never make any use of these parameters.

int main(int argc, char *argv[]) {
    // never touches any of the parameters
}

Should I do so too? What is the reason for that?

Answer 1

The arguments to the main function can be omitted if you do not need to use them. You can define main this way:

int main(void) {
    // never touches any of the parameters
}

Or simply:

int main() {
    // never touches any of the parameters
}

Regarding why some programmers do that , it could be to conform to local style guides, because they are used to it, or simply a side effect of their IDE's source template system.

Answer 2

When you have a function, it's obviously important that the arguments passed by the caller always match up properly with the arguments expected by the function.

When you define and call one of your own functions, you can pick whatever arguments make sense to you for the function to accept, and then it's your job to call your function with the arguments you've decided on.

When you call a function that somebody else defined — like a standard library function — somebody else picked the arguments that function would accept, and it's your job to pass them correctly. For example, if you call the standard library function strcpy , you just have to pass it a destination string, and a source string, in that order. If you think it would make sense to pass three arguments, like the destination string, and the size of the destination string, and the source string, it won't work. You don't get to make up the way you'll call the function, because it's already defined.

And then there are a few cases where somebody else is going to call a function that you defined, and the way they're going to call it is fixed, such that you don't have any choice in the way you define it. The best example of this (except it turns out it's not such a good example after all, as we'll see) is main() . It's your job to define this function. It's not a standard library function that somebody else is going to define. But , it is a function that somebody else — namely, the C start-up code — is going to call. That code was written a while ago, by somebody else, and you have no control over it. It's going to call your main function in a certain way. So you're constrained to write your main function in a way that's compatible with the way it's going to be called. You can put whatever you want in the body of your main function, but you don't get to pick your own arguments: there are supposed to be two of those, an int and a char ** , in that order.

Now, it also turns out that there's a very special exception for main . Even though the caller is going to be calling it with those two predefined arguments, if you're not interested in them, and if you define main with no arguments, instead, like this:

int main()
{
    /* ... */
}

your C implementation is required to set things up so that nothing will go wrong, no problems will be caused by the caller passing those two arguments that your main function doesn't accept.

So, in answer to your question, many programs are written to accept int argc and char **argv because they're complying with the simple rule: those are the arguments the caller is accepting, so those are the arguments they believe their main function should be defined as accepting, even if it doesn't actually use them .

Programmers who define main functions that accept argc and argv without using them either haven't heard of, or choose not to make use of, the special exception that says they don't have to. Personally, I don't blame them: that special exception for main is a strange one, which didn't always exist, so since it's not wrong to define main as taking two required arguments but not using them, that could be considered "better style".

(Yes, if you define a function that fails to actually use the arguments it defines, your compiler might warn you about this, but that's a separate question.)