The more I think about this thread, the more it seems to me that the
standard is quite broken on this point.
Maybe, from a "very small memory machine" point of view anyway:
I was thinking along these lines: OK, so my program starts, and let's
say I get one command line argument, so argv[0] and argv[1] are both
pointers to strings. Perhaps argv[1] is enormously long! Now I change
it to point to something else. Alarm bells ring - I've just lost all
record of whatever argv[1] was pointing too - boom, potential memory
leak alert.
But on further reflection, even if I don't change argv[1], it's still
as good as a memory leak! Once my program has finishing doing whatever
it wants to do with its command line arguments, there's still never
any way of releasing the memory they occupy.
Maybe not for you, but the implementation could.
Remember that your main() is called, somehow, by the implementation.
Typically this is accomplished with a bit of sneakily-written (and
usually machine-dependent in some way) code that vaguely resembles:
void __start(void) {
register struct __OS_start_info *args __sneaky("%r29");
int status;
... do some stuff with the OS-provided startup info ...
... in the process, set up argc and argv ...
__init_C_library_part_A();
__init_C_library_part_B();
...
__init_C_library_part_P();
status = main(argc, argv);
exit(status); /* __shutdown_C_library_* calls are done from exit() */
/* NOTREACHED */
}
