blocks|key|874689|text|它们是编译器的魔法，并且依赖于实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|874690|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

They are compiler magic, and implementation-dependent.

blocks|key|1089332|text|虽然您能够访问实际参数，但我认为它们的实际位置并不重要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1089333|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

While you are able to access to the actual parameters, I think their actual location does not matter at all.

blocks|key|1089379|text|参数列表是进程环境的一部分，与环境变量相似(但不同)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1089380|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The argument list is part of the process environment, similar to (but distinct from) environment variables.

blocks|key|874837|text|这些参数与任何其他函数的参数没有什么不同。如果架构的调用序列需要参数通过堆栈，那么它们就在堆栈上。如果像on一样，x86-64的一些参数进入寄存器，这些参数也进入寄存器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|874838|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

These parameters are no different than any other function's parameters.
If the architecture's calling sequence requires parameters to go through stack they are on stack. If, like on, x86-64 some parameters go in registers these also go in registers.

blocks|key|874877|text|通常情况下，它们在哪里是未知的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|874878|#include+<stdlib.h>
#include+<string.h>

int+main(int+argc,+char+*argv[])+{
++char+**foo;
++char+*bar[]+=+{"foo",+"bar"};

++(void)argv;+/*+avoid+unused+argv+warning+*/

++foo+=+malloc(sizeof+*foo);
++foo[0]+=+malloc(42);
++strcpy(foo[0],+"forty+two");

++/*+where+is+foo+located?+stack?+heap?+somewhere+else?+*/
++if+(argc+!=+42)+main(42,+foo);+else+return+0;

++/*+where+is+bar+located?+stack?+heap?+somewhere+else?+*/
++if+(argc+!=+43)+main(43,+bar);+else+return+0;
++/*+except+for+the+fact+that+bar+elements
++**+point+to+unmodifiable+strings
++**+this+call+to+main+is+perfectably+reasonable+*/

++return+0;
++/*+please+ignore+memory+leaks,+thank+you+*/
}|code-block|syntax|javascript|874879|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Usually it is unknown where they are.

<pre><code>#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;

int main(int argc, char *argv[]) {
 char **foo;
 char *bar[] = {"foo", "bar"};

 (void)argv; /* avoid unused argv warning */

 foo = malloc(sizeof *foo);
 foo[0] = malloc(42);
 strcpy(foo[0], "forty two");

 /* where is foo located? stack? heap? somewhere else? */
 if (argc != 42) main(42, foo); else return 0;

 /* where is bar located? stack? heap? somewhere else? */
 if (argc != 43) main(43, bar); else return 0;
 /* except for the fact that bar elements
 ** point to unmodifiable strings
 ** this call to main is perfectably reasonable */

 return 0;
 /* please ignore memory leaks, thank you */
}
</code></pre>

blocks|key|874961|text|这个问题的答案取决于编译器。这意味着它不是在C标准中处理的，所以任何人都可以随心所欲地实现它。这是正常的，因为操作系统也没有一个通用的、标准的方法来启动和结束进程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|874962|让我们想象一个简单的，为什么不是这样的场景。|874963|该进程通过某种机制接收写在命令行中的参数。因此，argc只是一个int，它被编译器放在程序进程(运行时的一部分)入口点的bootstrap函数推送到堆栈。实际值是从操作系统获取的，可以写在堆的内存块中。然后，构建argv向量，并且其第一个位置的地址也被压入堆栈。|874964|然后调用必须由程序员提供的函数main()，并保存其返回值以供以后(几乎是即时)使用。将释放堆中的结构，并将为main获得的退出代码导出到操作系统。该过程结束。|874965|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The answer to this question is compiler-dependent. This means it is not treated in the C standard, so anyone can implement that as he or she would like to. This is normal since also operating systems don't have a common accepted, standard way to start processes and finish them.

Let's imagine a simple, why-not scenario.

The process receives by some mechanism the arguments written in the command line. argc is then just an int which is pushed to the stack by the bootstrap function the compiler put as the entry point for the process of the program (part of the runtime). The actual values are get from the operating system, and can be, say, written in a memory block of the Heap. Then the argv vector is built and the address to its first position also pushed into the stack.

Then the function main(), which must be provided by the programmer, is called, and its return value is saved for later (nearly inmediate) use. The structures in the Heap are freed, and the exit code obtained for main is exported to the operating system. The process finishes.

blocks|key|875001|text|正如pmg提到的，当以递归方式调用main时，它取决于参数所指向的调用者。除了“调用者”是C实现/OS之外，对于main的原始调用，答案基本上是相同的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|875002|在UNIX-y系统上，argv所指向的字符串、argv指针本身以及进程的初始环境变量几乎总是存储在堆栈的最顶端。|875003|entityMap^0|2|3|H|4|1K|4|0|B|4|N|4|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$]]

As <code>pmg</code> mentions, when <code>main</code> is called recursively, it's up to the caller where the arguments point to. Basically the answer is the same on the original invocation of <code>main</code>, except that the "caller" is the C implementation/OS.

On UNIX-y systems, the strings that <code>argv</code> points to, the <code>argv</code> pointers themselves, and the process's initial environment variables are almost always stored at the very top of the stack.

blocks|key|875073|text|它实际上是编译器依赖和操作系统依赖的组合。main()是一个与任何其他C函数一样的函数，因此两个参数argc和argv的位置将遵循平台上编译器的标准。例如，对于大多数面向x86的C编译器，它们将位于返回地址和保存的基指针之上的堆栈上(请记住，堆栈向下增长)。在x86_64上，参数在寄存器中传递，因此argc将在%25edi中，而argv将在%25rsi中。然后，由编译器生成的main函数中的代码将它们复制到堆栈中，这就是后面引用的位置。这是为了使寄存器可以用于main的函数调用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|875074|argv所指向的char*块和实际的字符序列可以在任何地方。它们将在某个操作系统定义的位置开始，并可能被链接器生成的前导代码复制到堆栈或其他地方。您必须查看exec()的代码和链接器生成的汇编程序前导才能找到答案。|875075|entityMap^0|L|6|1E|4|1J|4|46|4|4C|4|4J|4|4P|4|6C|4|0|8|5|26|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|I|$]]

It's actually a combination of compiler dependence and operating system dependence. <code>main()</code> is a function just like any other C function, so the location of the two parameters <code>argc</code> and <code>argv</code> will follow standard for the compiler on the platform. e.g. for most C compilers targeting x86 they will be on the stack just above the return address and the saved base pointer (the stack grows downwards, remember). On x86_64 parameters are passed in registers, so <code>argc</code> will be in <code>%edi</code> and <code>argv</code> will be in <code>%rsi</code>. Code in the main function generated by the compiler then copies them to the stack, and that is where later references point. This is so the registers can be used for function calls from <code>main</code>.

The block of <code>char*</code>s that argv points to and the actual sequences of characters could be anywhere. They will start in some operating system defined location and may be copied by the pre-amble code that the linker generates to the stack or somewhere else. You'll have to look at the code for <code>exec()</code> and the assembler pre-amble generated by the linker to find out.

blocks|key|1089770|text|正如这里的许多其他答案所指出的那样，编译器实现用来向main传递参数的精确机制是标准未指定的(正如编译器用来向函数传递任何参数的机制一样)。严格地说，编译器甚至不需要在这些参数中传递任何有用的东西，因为这些值是由实现定义的。但这些都不是特别有帮助的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1089771|典型的C(或C%2B%2B)程序是针对所谓的“托管”执行环境进行编译的(使用function+main()作为程序的起点是托管环境的要求之一)。要知道的关键一点是，编译器会安排事情，以便当操作系统启动可执行文件时，编译器的运行时最初会获得控制-而不是main()函数。运行库的初始化代码执行任何必要的初始化，包括为main()的参数分配内存，然后将控制权移交给main()。|offset|length|style|CODE|1089772|用于main()参数的内存可以来自堆，可以在堆栈上分配(可能使用标准C代码不可用的技术)，也可以使用静态分配的内存，尽管这是一种不太可能的选择，因为它不太灵活。该标准确实要求argv所指向的字符串所使用的内存是可修改的，并且对这些字符串所做的修改在整个程序生命周期中始终有效。|1089773|只需注意，在执行到达main()之前，已经运行了相当多的代码，这些代码正在为您的程序运行设置环境。|1089774|entityMap^0|0|17|6|3D|6|49|6|4W|6|0|2|6|2F|4|0|A|6|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]|$D|R|E|S|F|G]|$D|T|E|U|F|G]|$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|12|8|@$D|13|E|14|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|M|$]]

As many other answers here point out, the precise mechanism a compiler implementation uses to pass arguments to main is unspecified by the standard (as is the mechanism a compiler uses to pass any arguments to a function). Strictly speaking, the compiler need not even pass anything useful in those parameters, since the values are implementation-defined. But neither of these are particularly helpful answers.

The typical C (or C++) program is compiled for what's known as a 'hosted' execution environment (using function <code>main()</code> as the starting point of your program is one of the requirements for a hosted environment). The key thing to know is that the compiler arranges things so that when the executable is launched by the operating system, the compiler's runtime gets control initially - not the <code>main()</code> function. The runtime's initialization code performs whatever initialization is necessary, including allocating memory for the arguments to <code>main()</code>, then it transfers control to <code>main()</code>.

The memory for the arguments to <code>main()</code> could come from the heap, could be allocated on the stack (possibly using techniques that aren't available to standard C code), or could use statically allocated memory, though that's a less likely option just because it's less flexible. The standard does require that the memory used for the strings pointed to by <code>argv</code> are modifiable and that modifications made to those string persist throughout the program's lifetime.

Just be aware that before execution reaches <code>main()</code>, quite a bit of code has already been run that's setting up the environment for your program to run in.

In C/C++, the main function receives parameters which are of type <code>char*</code>.

<pre><code>int main(int argc, char* argv[]){
 return 0;
}
</code></pre>

<code>argv</code> is an array of <code>char*</code>, and points to strings. Where are these string located? Are they on the heap, stack, or somewhere else?

Where are C/C++ main function's parameters?

编译器

在C/C++中，main函数接收char*类型的参数。int main(int argc, char* argv[]){  return 0;}argv是一个char*数组，指向字符串。这些字符串位于何处？它们是在堆上、堆栈上还是在其他地方？

问C/C++ main函数的参数在哪里？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C/C++ main函数的参数在哪里？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C/C++ main函数的参数在哪里？
EN