C ++如何将命令行参数转换为数组？

Question

I would like to how does C++ actually turn the command line arguments into a char array? What "secret" code does this? Where can I view the code that does this (even if it is in assembly, I know some assembly)? I am using Linux, if that helps.

Thank You

Answer 1

In most (all?) Unix-based operating systems, they are already an array. It's how operating system executes a process there — when a process starts, there is already an array of arguments ready for it.

The code that turns command line into an array lives in a shell (like bash) or any other program that starts another program. bash has it's sources available, other programs — it's different.

In Windows, they are one string (which you can get unmodified using GetCommandLine() API call), which is parsed by C runtime library to turn it into an array, because the language specification requires them to come as an array.

For programs compiled with Visual C++, the code that does this is included into Visual Studio distributions. You may have to turn on a checkbox that says something like “Include C runtime library source” in installer in order to have it installed.

Answer 2

This is usually handled by the operating system when it creates the process for the program. This code could very well be written in C (for example, if the OS is written in C), or it could be in assembly. To find the code for this, you will probably have to look at the operating system code.

Hope this helps!

Answer 3

It's an OS job to manage command line arguments and to put it to the stack during process creation.

For POSIX systems the execution path is:

1. in your program you call the execle/execve/... system call, passing the path to the new process executable and command line arguments.
2. this data go to the kernel
3. the kernel updates its internal structures to take the new process identity into account and allocates the address space for the new process (also kernel purges the old address space if it's not needed anymore). the kernel initializes the process memory with zeros, copying the info from old memory to the new address space at the top of the stack.
4. the kernel puts the new process to the scheduling queue and returns from the exec() system call, transferring execution path to the userspace and eventually to the entry point of the process (this is usually routine from crt0.o object file, which is linked by default to every executable - this routine calls main() ).

For Linux, you can see this code here: http://www.cs.fsu.edu/~baker/devices/lxr/http/source/linux/fs/exec.c#L383 :

383 /*
384  * 'copy_strings()' copies argument/environment strings from the old
385  * processes's memory to the new process's stack.  The call to get_user_pages()
386  * ensures the destination page is created and not swapped out.
387  */

In the do_execve() kernel counterpart of userspace execve() syscall, at line 1345, copy_strings() 's are called, and copy_strings() routine actually does the job you're asking about.

Answer 4

It's part of the c runtime library. If you would like to know what that is, look here: What is the C runtime library?

I just created a basic C++ console app using Microsoft Visual Studio and set a breakpoint on the first line of the program. When debugged, the program stops on that line and you call look up the call stack to see the function that calls 'main'. The calling function is part of the c runtime, and this does seem to contain some code that manipulates the command line... I haven't given it a close look, but that's probably where you should start.

Answer 5

Sometimes it is not the actual main() that is executed first. For example, on Visual Studio it is the function mainCRTStartup() that serves as entry point that calls Windows API to retreive and parse the command line (you can see this if you use debugger).