argc is an int representing the number of arguments in argv. argv is an array of pointers to the arguments the program expects. If you don't plan on using them they can be omitted. Here's a more involved explanation
Also, argv should be a const char* not a char*. There are two main ways to process command line arguments. One is to loop from 1 to argc and process each argument (old style). The other is to call the function getopt() for each supported argument. These days, the preferred method is to use getopt(), though I must confess to usually using the old style, simply because of 30 years of bad habits! :-)
Yes, I know they (argv strings) are modifiable, but IMO not a good idea! It is easy to force a buffer overrun, creating a potential security breach! :-)
Agreed, certainly. I've never encountered a situation where it was necessary to modify one of the argv strings, and honestly I agree that it's a bug waiting to happen. However, you don't have much flexibility in the signature of main(). Equivalent types are allowed, but char* and const char* are NOT equivalent types. So there's no guarantee that the compiler will accept this definition of main():
int main(int argc, const char *argv)
If it does, all is well (such support is implementation-defined), but the code won't be portable. If it doesn't, you've invoked undefined behavior just as readily as using void main() on a compiler that doesn't support a void return type.
The getopt() function is a POSIX standard.
Which is wholely irrelevant when talking about portable C++. The world is not all POSIX, after all. ;)