Hello,

My current understanding is that the only portable way to access
command-line arguments in C++ is with `int main(int argc, char** argv)`.
Given that modern C++ avoids pointer arithmetic and indexing into raw
pointers, it would be nice if there was an alternative way to access
command-line arguments.

For example, there could be an additional main definition of `int
main(std::command_line_arguments args)` where
`std::command_line_arguments` is type which implements the
`std::ranges::random_access_range` concept. Dereferencing the iterator
would result in instances of `std::string` (or perhaps `std::string_view`
or `std::zstring_view` from P3655R2). This would allow a range-for loop
over your command line arguments and the potential for out-of-bounds
checking.

An alternative method would be to introduce new function named something
like `std::get_command_line_arguments()` which would return an instance of
`std::command_line_arguments` and encourage people to use `int main()` as
their main signature.

If we wished to include standardized support for `char** envp`, that is a
third argument passed to `main` which holds a pointer to the environment
variables, which is a common C++ compiler extension, it could go into a
field of `std::command_line_arguments` though at that point renaming
`std::command_line_arguments` to something else like
`std::program_start_context` would be appropriate, and would allow other
additions in later versions of C++.

The type signature of `char** argv` suggests that modifying the strings
inside `argv` is permitted, and this suggests a `std::string`
representation. However, my impression is that this is not recommended
practice.

There is hypothetical potential for a slight performance improvement if an
operating system stores command line arguments in a non-null terminated
string format and thus can pass a `std::string_view` to main without
needing to do a copy. I am not familiar with this part of operating
systems, but I have doubts that this performance gain would be realized in
practice.

If the operating system already supplies null-terminated command line
arguments like they must currently, then using `std::string_view` instead
of `std::string` or `std::zstring_view` could imply a small performance
decrease when interacting with legacy APIs that need null-terminated strings.

I tried to look for previous work on this matter and I failed to find it.
If I merely didn't search hard enough, then I apologize.

Emily