该楼层疑似违规已被系统折叠 隐藏此楼查看此楼
C89 31个，C99 127个。
ANSI C89
2.2.4.1 Translation limits
The implementation shall be able to translate and execute at least one program that contains at least one instance of every one of the following limits:
* 15 nesting levels of c0mp0und statements, iteration control structures, and selection control structures
* 8 nesting levels of conditional inclusion
* 12 pointer, array, and function declarators (in any combinations)  modifying an arithmetic, a structure, a union, or an incomplete type in a declaration
* 31 declarators nested by parentheses within a full declarator
* 32 expressions nested by parentheses within a full expression
* 31 significant initial characters in an internal identifier or a macro name
* 6 significant initial characters in an external identifier
* 511 external identifiers in one translation unit
* 127 identifiers with block scope declared in one block
* 1024 macro identifiers simultaneously defined in one translation unit
* 31 parameters in one function definition
* 31 arguments in one function call
* 31 parameters in one macro definition
* 31 arguments in one macro invocation
* 509 characters in a logical source line
* 509 characters in a character string literal or wide string literal (after concatenation)
* 32767 bytes in an object (in a hosted environment only)
* 8 nesting levels for #include'd files
* 257 case labels for a switch statement (excluding those for any
nested switch statements)
* 127 members in a single structure or union
* 127 enumeration constants in a single enumeration
* 15 levels of nested structure or union definitions in a single struct-declaration-list
ISO C99
5.2.4.1 Translation limits
1 The implementation shall be able to translate and execute at least one program that
contains at least one instance of every one of the following limits:13)
— 127 nesting levels of blocks
— 63 nesting levels of conditional inclusion
— 12 pointer, array, and function declarators (in any combinations) modifying an arithmetic, structure, union, or incomplete type in a declaration
— 63 nesting levels of parenthesized declarators within a full declarator
— 63 nesting levels of parenthesized expressions within a full expression
— 63 significant initial characters in an internal identifier or a macro name (each universal character name or extended source character is considered a single character)
— 31 significant initial characters in an external identifier (each universal character name specifying a short identifier of 0000FFFF or less is considered 6 characters, each universal character name specifying a short identifier of 00010000 or more is considered 10 characters, and each extended source character is considered the same number of characters as the corresponding universal character name, if any)
— 4095 external identifiers in one translation unit
— 511 identifiers with block scope declared in one block
— 4095 macro identifiers simultaneously defined in one preprocessing translation unit
— 127 parameters in one function definition
— 127 arguments in one function call
— 127 parameters in one macro definition
— 127 arguments in one macro invocation
— 4095 characters in a logical source line
— 4095 characters in a character string literal or wide string literal (after concatenation)
— 65535 bytes in an object (in a hosted environment only)
— 15 nesting levels for #included files
— 1023 case labels for a switch statement (excluding those for any nested switch statements)
— 1023 members in a single structure or union
— 1023 enumeration constants in a single enumeration
— 63 lev els of nested structure or union definitions in a single struct declaration-list

其实请求参数永远都是一个，因为一个request中只包含一个request body. 理解了这个，就会明白Spring MVC不支持多个@RequestBody。
至于要将一个request body中的content反序列化成几个Java实例是另外一个问题。
有三个解决方向：
创建一个新的entity，将你的两个entity都进去。这是最简单的，但是不够“优雅”。
用Map<String, Object>接受request body，自己反序列化到各个entity中。
类似方法2，不过更为generic，实现自己的HandlerMethodArgumentResolver

   原创作品，转账请注明出处。 


  调用一个函数是，它的实参会替换函数中的形参。也就是说实参会填充形参的位置。有几种机制都可以实现这一过程：
一是传值调用机制，二是用于替换形参的传引用调用机制，下面主要针对传应用调用机制进行简单的阐述。
   1. 区别：
  传值调用机制是将实参中的值传递给函数的形参，并不会将实参这个变量传入；
传引用调用机制是用实参变量本身来替换形参。函数调用中相应的实参必须是一个变量，用于替换形参的将是这个变量。

void getInput(double& fVar)
{
    using namespace std;
    cout<<"I will convert a value from A to B.\n";
    cin>>fVar;
}
在一个包含这个函数的定义的程序中，以下函数调用会将A变量设置从键盘读取值：


getInput(A);
   2. 传引用调用详解：

大多数情况下可以将传引用调用机制想象成：作为函数实参提供的变量名称直接替换掉引用调用形参。实际过程中，要比这种简单说法更加微妙。要是形参成为传引用调用参数，需要在其类型名称之后添加符号&。对应地，在函数调用中，你传递的实参应该是一个变量，而不能是一个常量或者表达式。调用函数时，实参变量（而不是该变量的值）会替换形参。调用函数期间，函数主体中对形参的任何改变，都会作用于实参变量。
程序变量是作为内存地址来实现的，编译器为每个变量都分配一个内存位置。用以下函数声明为例：

<strong><span style="font-size:14px;">void getInput(int& inputNum1, int& inputNum2);</span></strong>
   两个传引用调用形参inputNum1和inputNum2是函数调用中所用的实参占位符。
<strong><span style="font-size:14px;">getInput(firstNum, secondNum);</span></strong>
   执行这个函数调用时，为函数提供的实际并不是实参名称inputNum1和inputNum2，相反，为其提供的是与每个名称关联在一起的内存位置的列表。列如其位置列表是


<strong><span style="font-size:14px;">1000
1014</span></strong>
这是已经分配给实参变量firstNum1和secondNum2的内存位置（注意顺序）。与形参关联的实际是这些内存位置。


<strong><span style="font-size:14px;">firstNum1  ------> 1000 -------> inputNum1
secondNum2 ------> 1004 -------> inputNum2</span></strong>
执行函数主体的语句时，函数主体对形参执行的任何操作实际会作用于形参关联的内存位置。

  
 3. 形参与实参
（1）函数的形参在函数声明中列出，并在函数定义主体中使用。任何形参都是一种空白位置或者占位符，会在函数调用时候被别的东西填充。
（2）实参用于填充形参。学一个函数调用时，实参在函数名之后的圆括号中列出。执行这个函数调用时，实参会在形参的位置“插入”。
（3）“传值调用”和“传引用调用”这两个术语是指“插入”过程中具体采用的一种机制。
在传值调用机制中，只使用实参的值在这种机制中，形参是一个局部变量，它被初始化称想要实参的值。
在传引用调用机制中，实参是一个变量，而且会照搬整个变量。在这种机制中，是参变量会替换形参，故对形参所做的任何更改其实都会作用于实参变量。




         

关于main函数的参数。
前几天遇到一个题，关于main函数的参数的。

可以看到这个题里main函数有了两个参数。一般来说，main函数是不带参数的，但实际上main是可以有参数的，而且第一个必须是int型，第二个必须是一个char类型的指针数组。

main（int argc,char *argv[ ])。

但是咱们正经人都知道自己写的程序都是main调用其他函数，而main函数不能被其他函数调用，那么main函数的形参是谁传入的呢？？

实际上main函数的形参是由操作系统传入的，比如当你用电脑的cmd的命令对程序进行操作时，就会对main函数进行传参。比如上面的程序，当你在cmd中对题中的程序输入test gcc test.c -o test.exe时，系统就会将这些东西以空格为分割点，分解成字符串并将首地址储存在argv中，argv[0]中会自动存放文件的路径或者执行文件的名字，而其他字符串会顺次存放进去。对于第一个int型的函数，系统会自动读取，表示的时后面数组内容的个数。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main(int length, char* args[]) {

	printf("%d\n",length);
	for(int i=0;i<length;i++){
		printf("%s\n",args[i]);
	}
	return 0;
}

这一串程序就是一个用来显示形参内容的程序，当我在命令行执行这个代码，并输入text 123 456时会出现以下结果：


我们可以看到length=3；args[0]=text;args[1]=123;args[2]=456。

关于main函数的参数的内容就是这么多，但是有没有人在想main函数的形参有什么用呢？？

这个时候，就得说说操作系统的那些命令了，在cmd命令中我们会用到一些命令来对文件或者说磁盘进行操作，你们有没有发现那些命令的输入形式像极了我们在命令行对我们自己写的函数的操作呢。