tahonermann
commented
3 years ago Some relevant discussion can be found in the SG16 mailing list archives at https://lists.isocpp.org/sg16/2021/01/2005.php. Unfortunately, the list archives have predictably mojibaked the message, but the experimental results presented are still understandable.
In recent discussion, Peter Brett and I discussed the following design to address command line options:
- A library solution that provides global immutable access to command line options. This would allow access to command line options from constructors of global objects prior to the call to main(). This is a feature that, while not frequently needed, is quite useful for some use cases and is already provided by most implementations in some form.
- That library solution would provide the sequence of command line arguments as a range.
- The range elements, each corresponding to an argument, would provide access to the raw (
charorwchar_tbased) argument as well as to transcodedchar,wchar_t,char8_t,char16_t, andchar32_trepresentations; similar to thestd::filesystem::pathstring format observers. - Providing conversion to
std::filesystem::pathwould enable implementations to provide appropriately preserved paths portably; on Windows, the implementation could construct from thewchar_t-based command line while implementations for other OSs construct from thechar-based command line. - No need for additional signatures for main().
Code using this might look like the following (which would itself benefit from being wrapped in a nicer command line argument handling facility).
#include <filesystem>
#include <program_arguments>
#include <ranges>
#include <string>
int main() {
auto &&args = std::program_arguments(1); // Skip argument 0, keep 1...
for (auto arg = std::ranges::begin(args);
arg != std::ranges::end(args);
++arg)
{
// arguments implicitly convert to std::string_view or a similar char-based range.
// When only basic source characters are expected, comparison with execution character set is fine.
if (*arg == "--file") {
if (++arg != std::ranges::end(args)) {
// Retrieve the filename operand converted to a path.
std::filesystem::path filename = arg->path();
}
}
else if (*arg == "--name") {
if (++arg != std::ranges::end(args)) {
// Retrieve the provided username converted from the command line encoding to UTF-8.
std::u8string username = arg->u8string();
}
}
else {
...
}
}
}
jensmaurer
cor3ntin
Currently, C++ requires the following forms of
main()function to be supported:Implementations can also define other additional entry points. For example, some implementations permit
main()to accept environment variables:Some permit arguments to be accepted as wide characters; examples:
Many applications make assumptions about the encoding of the contents of
argv(andenvironif available). These assumptions are very rarely portable between different deployments of a single C++ implementation, let alone across multiple implementations. On some implementations individual components ofargvandenvironvariables may have different encodings; some may not even be text. On some implementations, using the contents ofargvmay be guaranteed to lose data, and implementation-specific library functions must be use to safely access arguments.We should standardize portable ways to access data from outside the program via command-line arguments and environment variables, for example by:
main()