下载文档原格式
c++函数数组C++是一种广泛使用的编程语言，在这种语言中，函数数组被广泛应用。
本文将介绍C++函数数组的基础知识以及如何使用它们。
一、什么是函数数组在C++中，函数数组是一组相同类型的函数，它们被存储在一个数组中。
这意味着可以使用数组下标来调用不同的函数，并且每个函数都可以处理相同或不同类型的数据。
```c++#include <iostream>using namespace std;int add(int a, int b) {return a + b;}// 调用函数数组中的函数cout << funcArray[0](2, 3) << endl; // 输出 5cout << funcArray[1](2, 3) << endl; // 输出 -1return 0;}```在上面的代码中，我们定义了一个名为funcArray的函数数组，它有两个元素，即add函数和sub函数。
调用函数数组中的函数时，我们使用函数名和参数列表，并且在函数名前加上数组下标。
funcArray [0]（2, 3）调用数组中的第一个函数，即add函数，传递参数2和3，返回5。
二、函数指针// 声明函数指针typedef int (*FuncPointer)(int, int);// 定义函数数组FuncPointer funcArray[2] = {add, sub};在上面的示例中，我们声明了一个名为FuncPointer的函数指针类型，并定义了两个函数add和sub。
然后，我们使用函数指针类型来声明函数数组。
三、使用类成员函数在C++中，可以使用类成员函数来定义函数数组。
下面的代码演示如何使用类成员函数来定义函数数组。
四、使用Lambda表达式在上面的代码中，我们使用Lambda表达式定义函数数组，该数组仅包含一个Lambda 表达式。
该Lambda表达式的返回类型为int，它接受两个整数参数并返回它们的和。
C语言数组函数的使用方法1. 介绍C语言是一种广泛应用于系统开发、嵌入式设备、游戏开发等领域的编程语言。
在C语言中，数组是一种特殊的数据结构，它可以容纳多个相同类型的元素，并通过索引来访问和操作这些元素。
函数是C语言中的重要概念，它可以使程序模块化并提高代码的可读性和复用性。
本文将介绍C语言中数组函数的使用方法。
2. 定义和初始化数组定义数组是指给数组分配内存空间，并为数组元素指定类型。
C语言中，可以使用以下语法来定义一个数组：<数据类型> <数组名>[<数组大小>];例如，定义一个包含5个整数的数组：int numbers[5];数组的大小指定了数组可以容纳的元素个数。
数组的索引从0开始，因此上述数组的索引范围是0到4。
进行数组初始化可以分为两种情况：2.1 静态初始化静态初始化是指在定义数组时直接给数组元素赋初值。
例如，下面的代码定义并初始化了一个包含5个整数的数组：int numbers[5] = {1, 2, 3, 4, 5};上述代码将数组的前5个元素分别赋值为1、2、3、4和5。
2.2 动态初始化动态初始化是指在定义数组后，通过循环或用户输入等方式给数组元素赋值。
例如，下面的代码定义了一个包含5个整数的数组，并通过循环给数组元素赋值：int numbers[5];int i;for (i = 0; i < 5; i++) {numbers[i] = i + 1;}上述代码通过循环将数组的前5个元素分别赋值为1、2、3、4和5。
3. 数组函数的定义和使用数组函数是指以数组为参数和/或返回值的函数。
在C语言中，可以通过以下方式定义数组函数：<返回类型> <函数名>(<数据类型> <数组名>[<数组大小>]) {// 函数体}下面是一个示例，定义了一个数组函数用于计算数组中所有元素的和：int sum(int numbers[], int size) {int result = 0;int i;for (i = 0; i < size; i++) {result += numbers[i];}return result;}上述代码定义了一个名为sum的函数，接受一个整数数组和数组大小作为参数，并返回数组元素的和。
数组作为函数参数解读在编程语言中，数组作为函数参数是一种常见的用法，它可以使代码更加简洁和可重用。
本文将详细解读数组作为函数参数的含义、用法和相关注意事项，以及优缺点等。
一、数组作为函数参数的含义和用途1.将数组作为参数可以方便地传递多个值给函数，而不需要单独传递多个参数。
这在处理固定大小的集合数据时非常有用，例如计算数组元素的总和、平均值、最大值、最小值等。
2.数组作为参数还可以用于对数组中的元素进行排序、过滤等操作。
这使得函数可以对不同大小的数组进行相同的操作，从而提高代码的重用性。
3.当函数需要返回多个值时，可以将数组作为参数，并将结果填充到数组中。
这比返回单个值更加灵活和高效。
例如，可以使用数组来存储一个函数中的错误信息或多个计算结果。
二、数组作为函数参数的基本用法2. 数组传递：调用函数时，将数组作为实参传递给函数，例如：func(arr)。
在函数内部，通过形参来访问数组，可以直接使用数组名或指针来操作数组元素。
3.数组访问：在函数内部，可以使用下标运算符（[]）来访问数组中的元素。
通过下标，可以读取和修改数组的元素值。
需要注意的是，数组下标从0开始，因此第一个元素的下标为0。
三、数组作为函数参数的注意事项在使用数组作为函数参数时，需要注意一些细节，以保证代码的正确性和健壮性。
1. 数组的传递方式：数组参数实际上是以指针的形式传递给函数的。
因此，在函数内部对数组的修改会影响到原始数组。
如果不希望修改原始数组，可以使用const关键字来声明参数，例如：void func(const int arr[])。
2.数组的大小：在函数中无法获知数组的大小，因此需要额外传递数组的大小信息。
可以在函数的参数列表中增加一个表示数组大小的参数，或者使用特殊的值表示数组的结束，例如使用-1表示数组的结束。
3.数组的越界访问：在函数中，需要谨慎处理数组的边界问题，以避免访问越界导致的错误。
可以使用循环和条件判断来处理数组的边界情况。
c语言数组与函数句心得体会数组定义：数组是有序的并且具有相同类型的数据的集合。
一维数组1、一般形式：类型说明符数组名[常量表达式]；例如：inta[10];元素为a[0]----a[9].2、常量表达式中不允许包含变量，可以包含常量或符号常量。
3、数组元素下标可以是任何整型常量、整型变量或任何整型表达式。
4、可以对数组元素赋值，数组元素也可以参与运算，与简单变量一样使用。
5、使用数值型数组时，不可以一次引用整个数组，只能逐个引用元素。
6、需要整体赋值时只可以在定义的同时整体赋值。
如inta[10]={0,1,2,3,4,5,6,7,8,9};正确。
inta[10];a[10]={0,1,2,3,4,5,6,7,8,9};错误。
7、可以只给一部分元素赋值。
例如：inta[10]={5,8,7,6};后面没有赋值的元素值默认为0。
8、对全部数组元素赋值时可以不指定数组长度，例如：inta[10]={0,1,2,3,4,5,6,7,8,9};可以写成inta[]={0,1,2,3,4,5,6,7,8,9};但是，既不赋初值，也不指定长度是错误的。
例如：inta[];错误。
二维数组1、一般形式：类型说明符数组名[常量表达式1][常量表达式2]；例如：inta[3][4];可以看成是包含3个一维数组，每个一维数组里包含4个元素。
一共3*4=12个元素。
所有元素为a[0][0],a[0][1]，a[0][2]，a[0][3] a[1][0],a[1][1]，a[1][2]，a[1][3] a[2][0],a[2][1]，a[2][2]，a[2][3]2、与一维数组一样元素下标可以是是任何整型常量、整型变量或任何整型表达式。
3、需要整体赋值时只可以在定义的同时整体赋值。
例如：inta[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};正确。
inta[3][4]；a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};错误。
理解C语⾔（⼀）数组、函数与指针1 指针⼀般地，计算机内存的每个位置都由⼀个地址标识，在C语⾔中我们⽤指针表⽰内存地址。
指针变量的值实际上就是内存地址，⽽指针变量所指向的内容则是该内存地址存储的内容，这是通过解引⽤指针获得。
声明⼀个指针变量并不会⾃动分配任何内存。
在对指针进⾏间接访问前，指针必须初始化: 要么指向它现有的内存，要么给它分配动态内存。
对未初始化的指针变量执⾏解引⽤操作是⾮法的，⽽且这种错误常常难以检测，其结果往往是⼀个不相关的值被修改，并且这种错误很难调试，因⽽我们需要明确强调: 未初始化的指针是⽆效的，直到该指针赋值后，才可使⽤它。
int *a;*a=12; //只是声明了变量a,但从未对它初始化，因⽽我们没办法预测值12将存储在什么地⽅int *d=0; //这是可以的，0可以视作为零值int b=12;int *c=&b;另外C标准定义了NULL指针，它作为⼀个特殊的指针常量，表⽰不指向任何位置，因⽽对⼀个NULL指针进⾏解引⽤操作同样也是⾮法的。
因⽽在对指针进⾏解引⽤操作的所有情形前，如常规赋值、指针作为函数的参数，⾸先必须检查指针的合法性- ⾮NULL指针。
解引⽤NULL指针操作的后果因编译器⽽异，两个常见的后果分别是返回置0的值及终⽌程序。
总结下来，不论你的机器对解引⽤NULL指针这种⾏为作何反应，对所有的指针变量进⾏显式的初始化是种好做法。
如果知道指针被初始化为什么地址，就该把它初始化为该地址，否则初始化为NULL在所有指针解引⽤操作前都要对其进⾏合法性检查，判断是否为NULL指针，这是⼀种良好安全的编程风格1.1 指针运算基础在指针值上可以进⾏有限的算术运算和关系运算。
合法的运算具体包括以下⼏种: 指针与整数的加减(包括指针的⾃增和⾃减)、同类型指针间的⽐较、同类型的指针相减。
例如⼀个指针加上或减去⼀个整型值，⽐较两指针是否相等或不相等，但是这两种运算只有作⽤于同⼀个数组中才可以预测。
Excel高级函数使用OFFSET和SUMPRODUCT函数进行动态区域选择和数组计算在Excel中，高级函数的运用可以极大地提高数据处理和分析的效率。
OFFSET函数和SUMPRODUCT函数是两个常用的高级函数，它们能够帮助我们进行动态区域选择和数组计算。
下面我们将详细介绍这两个函数的用法和应用场景。
一、使用OFFSET函数进行动态区域选择OFFSET函数可以根据指定的偏移量，从一个基准单元格开始，返回一个新的单元格区域。
其基本语法如下：OFFSET(基准单元格, 行偏移量, 列偏移量, 行数, 列数)1. 动态选择行假设我们有一份销售数据表格，其中A列为产品名称，B列为销售数量。
我们可以使用OFFSET函数来选择前N行的产品名称，N由用户输入的值动态确定。
在C1单元格中输入N的值，然后在A1单元格中输入以下公式：=OFFSET($A$1, 0, 0, $C$1, 1)2. 动态选择列假设我们需要从一个表格中选择最近N天的日期数据，日期数据位于A列，我们可以使用OFFSET函数来实现。
在B1单元格中输入N 的值，然后在B2单元格中输入以下公式：=OFFSET($A$1, COUNT($A:$A)-$B$1, 0, $B$1, 1)二、使用SUMPRODUCT函数进行数组计算SUMPRODUCT函数可以对多个数组进行计算，并返回计算结果的总和。
其基本语法如下：SUMPRODUCT(数组1, 数组2, ...)1. 数组区域求和假设我们有一个数据表格，A列为产品名称，B列为销售数量，C 列为销售单价。
我们可以使用SUMPRODUCT函数来计算总销售额。
在D1单元格中输入以下公式：=SUMPRODUCT($B$2:$B$10, $C$2:$C$10)2. 条件求和假设我们需要计算销售数量大于100的产品的销售总额，我们可以使用SUMPRODUCT函数结合条件进行计算。
在E1单元格中输入以下公式：=SUMPRODUCT(($B$2:$B$10>100)*($C$2:$C$10))三、综合运用OFFSET和SUMPRODUCT函数有时候，我们需要在一个区域范围内进行条件筛选，然后再进行统计计算。
c语言函数组成的数组
C语言中的函数组成的数组是指可以存储函数指针的数组。
函
数指针是指向函数的指针变量，它存储了函数的地址，可以用来间接调用函数。
在C语言中，函数名可以视作指向函数代码的指针，因此可以将函数指针存储在数组中。
通过使用函数指针数组，可以实现一些高级的编程技巧，例如实现函数回调，动态选择调用不同的函数等。
这在一些特定的编程场景下非常有用。
在C语言中，定义函数指针数组的语法如下：
c.
return_type (function_array_name[size])(argument_type);
其中，return_type 是函数返回类型，function_array_name 是函数指针数组的名称，size 是数组大小，argument_type 是函数参数类型。
通过定义函数指针数组，可以将多个函数的指针存储在数组中，然后通过索引来访问并调用相应的函数。
这种技术在实现状态机、
回调函数等方面有广泛的应用。
总的来说，C语言中的函数组成的数组是指存储函数指针的数组，通过它可以实现一些高级的编程技巧，提高代码的灵活性和可
扩展性。
dp函数和 dp数组
DP函数和DP数组是动态规划算法中的两个重要概念。
DP函数指的是一个输入为当前状态和决策，输出为最优决策结果的函数。
它可以帮助我们解决很多优化问题，如背包问题、最长上升子序列等。
DP 数组指的是一个二维数组，其中每个元素表示当前状态下的最优解。
我们可以通过填充DP数组来解决许多动态规划问题。
在实际应用中，我们常常将DP函数转化为DP数组，并通过填充DP数组来得到最优解。
通过理解和应用DP函数和DP数组，我们可以更好地掌握动态规划算法，解决更多实际问题。
- 1 -。
postgresql----数组类型和函数postgresql⽀持数组类型，可以是基本类型，也可以是⽤户⾃定义的类型。
⽇常中使⽤数组类型的机会不多，但还是可以了解⼀下。
不像C或JAVA⾼级语⾔的数组下标从0开始，postgresql数组下标从1开始，既可以指定长度，也可以不指定长度。
且postgresql既⽀持⼀维数组，也⽀持多维数组，但是平时⼆维数组也就够⽤了。
⽰例1.使⽤ARRAY构建数组类型---1*4的⼀维数组test=# select array[1,2,3,4];array-----------{1,2,3,4}(1 row)--2*2的⼆维数组test=# select array[[1,2],[3,4]];array---------------{{1,2},{3,4}}(1 row)--1*2的⼆维数组，基本类型为box矩形类型，且和上⾯相⽐box类型元素之间是以分号分隔的，其他所有类型的数据都是以逗号分隔的test=# select array[box'(1,1),(0,0)',box'(0,0),(-1,-1)'];array-----------------------------{(1,1),(0,0);(0,0),(-1,-1)}(1 row)⽰例2.创建⼀张表，字段包含数组类型其中int[]表⽰数组长度⽆限制，int[4]表⽰数组长度为4.test=# create table tbl_array(a int[],b varchar(32)[][],c int);CREATE TABLEtest=# insert into tbl_array (a,b,c) values (array[1,2],array[[1,2,3],[4,5,6]],1);INSERT01test=# insert into tbl_array (a,b,c) values (array[1,2,3],array[[1,2],[4,5]],2);INSERT01test=# select*from tbl_array ;a |b | c---------+-------------------+---{1,2} | {{1,2,3},{4,5,6}} |1{1,2,3} | {{1,2},{4,5}} |2(2 rows)test=# select a[1],b[2]from tbl_array where c =1;a | b---+---1|(1 row)test=# select a[1],b[2][1]from tbl_array where c =1;a | b---+---1|4(1 row)test=# select a[1],b[2][4]from tbl_array where c =1;a | b---+---1|(1 row)test=# update tbl_array set a[1]=200where a[1]=1;UPDATE1test=# select a[1],b[2][4]from tbl_array ;a | b-----+---100|200|(2 rows)也可以使⽤[下标:上标]⽅式来查询数组连续的某些元素。
第3章函数和数组库函数的调用（1）有以下程序（strcpy为字符串复制函数，strcat为字符串连接函数) #include <stdio.h>#include <string.h>main(){ char a[10]="abc",b[10]="012",c[10]="xyz";strcpy(a+1,b+2);puts(strcat(a,c+1));}程序运行后的输出结果是A）bc2yzB）a2yzC）a12xyzD）12yz（2）若各选项中所用变量已正确定义，函数fun中通过return语句返回一个函数值，以下选项中错误的程序是A）main() { ……x=fun(2,10); ……} float fun(int a,int b){……}B）float fun(int a,int b){……} main() { ……x=fun(i,j); ……}C）float fun(int ,int); main() { ……x=fun(2,10); ……} float fun(int a,intb){……}D）main() { float fun(int i,int j); ……x=fun(i,j); ……} float fun(int a,intb){……}（3）以下叙述中正确的是A）用户自己定义的函数只能调用库函数B）不同函数的形式参数不能使用相同名称的标识符C）在C语言的函数内部，可以定义局部嵌套函数D）实用的C语言源程序总是由一个或多个函数组成（4）若有定义语句：char s[10]="1234567\0\0"; 则strlen(s)的值是A）8B）7C）9D）10（5）有以下程序# include <string.h>main( ){ char p[20]={'a','b','c','d'},q[ ]="abc", r[ ]="abcde";strcat(p, r); strcpy(p+strlen(q), q);printf("%d\n", strlen(p));}程序运行后的输出结果是A）9C）6D）7（6）若有定义语句：char *s1="OK", *s2="ok"; 以下选项中，能够输出"OK"的语句是A）if (strcmp(s1,s2)!=0) puts(s1);B）if (strcmp(s1,s2)!=0) puts(s2);C）if (strcmp(s1,s2)==1) puts(s1);D）if ( strcmp(s1,s2)==0) puts(s1);（7）有以下程序，程序中库函数islower (ch)用以判断ch中的字母是否为小写字母#include <stdio.h>#include <ctype.h>void fun(char *p){ int i=0;while (p[i]){ if(p[i]==' ' &&islower(p[i-1])) p[i-1]=p[i-1]-'a'+'A';i++;}}main(){char sl[100]="ab cd EFG !";fun (s1); printf("%s\n",s1);}程序运行后的输出结果是A）Ab Cd EFg !B）ab cd EFG !C）ab cd EFg !D）aB cD EFG !（8）若有以下定义和语句char s1[10]="abcd!",*s2="\n123\\";printf("%d %d\n",strlen(s1),strlen(s2));则输出结果是A）10 5B）10 7C）5 5D）5 8（9）有以下程序#include <stdio.h>int fun(int a,int b){ if(b==0) return a;else return(fun(--a,--b));}main()printf("%d\n", fun(4,2));}程序的运行结果是A）1B）2C）3D）4（10）下列选项中，能够满足“只要字符串s1等于字符串s2，则执行ST”要求的是A）if(s1==s2) ST;B）if(strcpy(s1,s2)==1) ST;C）if(strcmp(s2,s1)==0) ST;D）if(s1-s2==0) ST;1B 2 A 3 D 4 B 5 C 6 A 7 D8C 9 B 10 C函数的定义和返回值（11）以下叙述中正确的是A）函数名代表该函数的入口地址B）所有函数均不能接受函数名作为实参传入C）函数体中的语句不能出现对自己的调用D）如果函数带有参数，就不能调用自己（12）以下叙述中正确的是A）函数既可以直接调用自己，也可以间接调用自己B）任何情况下都不能用函数名作为实参C）函数的递归调用不需要额外开销，所以效率很高D）简单递归不需要明确的结束递归的条件（13）以下关于return语句的叙述中正确的是A）一个自定义函数中必须有一条return语句B）一个自定义函数中可以根据不同情况设置多条return语句C）定义成void类型的函数中可以有带返回值的return语句D）没有return语句的自定义函数在执行结束时不能返回到调用处（14）已定义以下函数int fun( int *p) { return *p; } fun函数返回值是A）不确定的值B）一个整数C）形参p中存放的值D）形参p的地址值（15）以下叙述中错误的是A）用户定义的函数中可以没有return语句B）用户定义的函数中若没有return语句，则应当定义函数为void类型C）用户定义的函数中可以有多个return语句，以便可以调用一次返回多个函数值D）函数的return语句中可以没有表达式（16）以下叙述中错误的是A）函数调用可以作为一个独立的语句存在B）函数形参的值也可以传回给对应的实参C）若函数有返回值，必须通过return语句返回D）C程序必须由一个或一个以上的函数组成11 A 12 A 13 B 14 B 15 C 16 B函数的调用及要求（17）有以下程序int add (int a,int b){return (a+b);}main( ){ int k,(*f)( ),a=5,b=10;f=add;…}则以下函数调用语句错误的是A）k=add(a,b);B）k=(*f)(a,b);C）k= *f(a,b);D）k=f(a,b);（18）以下叙述中正确的是A）函数调用时，不必区分函数名称的大小写B）调用函数时，函数名必须与被调用的函数名完全一致C）函数名允许用数字开头D）在函数体中只能出现一次return语句17 C 18 B函数的说明（19）若有以下函数首部int fun(double x[10], int *n) 则下面针对此函数的函数声明语句中正确的是A）int fun(double , int );B）int fun(double *x, int n);C）int fun(double *, int *);D）int fun(double x, int *n);（20）以下选项中叙述错误的是A）在C程序的同一函数中，各复合语句内可以定义变量，其作用域仅限本复合语句内B）C程序函数中定义的赋有初值的静态变量，每调用一次函数，赋一次初值C）C程序函数中定义的自动变量，系统不自动赋确定的初值D）C程序函数的形参不可以说明为static型变量19 C 20 B调用函数和被调用函数之间的数据传递（21）有以下程序int f(int x);main() {int n=1,m;m=f(f(f(n)));printf("%d\n",m); }int f(int x){return x*2; }程序运行后的输出结果是A）1B）2C）4D）8（22）有以下程序#include <stdio.h>int fun(int x,int y){ if(x==y)return(x);else return((x+y)/2);}main(){ int a=4,b=5,c=6;printf("%d\n",fun(2*a,fun(b,c)));}程序运行后的输出结果是A）3B）6C）8D）12（23）有以下程序#include <stdio.h>int f(int x,int y){return ((y-x)*x);}main(){ int a=3,b=4,c=5,d;d=f(f(a,b),f(a,c));printf("%d\n",d);}程序运行后的输出结果是A）10B）8C）9D）7（24）有以下程序#include <stdio.h>double f(double x);main(){ double a=0; int i;for(i=0;i<30;i+=10) a+=f((double)i);printf("%5.0f\n",a);}double f(double x){ return x*x+1; }程序运行后的输出结果是A）401B）500C）503D）1404（25）若函数调用时的实参为变量时，以下关于函数形参和实参的叙述中正确的是A）形参只是形式上的存在，不占用具体存储单元B）函数的形参和实参分别占用不同的存储单元C）同名的实参和形参占同一存储单元D）函数的实参和其对应的形参共占同一存储单元（26）有以下程序void fun( int a, int b, int c ){a=b; b=c; c=a;}main() {int a=10 , b=20, c=30;fun( a, b, c );printf("%d,%d,%d\n",c,b,a); }程序运行后的输出结果是A）10,20,30B）20,30,10C）30,20,10D）0,0,0（27）有以下程序#include <stdio.h>int f(int x);main(){ int a,b=0;for(a=0;a<3;a++){b=b+f(a);putchar('A'+b);}}int f(int x){return x*x+1;}A）BCDC）ABED）BCF（28）若有以下程序void f(int x){if (x >= 10){printf("%d-", x%10);f(x/10); }else printf("%d", x); }main() {int z = 123456;f(z); }则程序的输出结果是A）6-5-4-3-2-1B）6-5-4-3-2-1-C）1-2-3-4-5-6D）1-2-3-4-5-6-（29）有以下程序#include <stdio.h>int fun( int x ) {int p;if (x==0 || x==1) return(3);p= x - fun( x-2 ); return (p); }main() {printf ("%d\n", fun(9));}程序运行后的输出结果是A）5B）9C）4D）7（30）有以下程序#include <stdio.h>int fun(int n) {int a;if( n==1 ) return 1;a = n + fun( n-1);return ( a ); }main() {printf( "%d\n", fun( 5 ) );}程序的输出结果是B）10C）15D）9（31）有以下程序#include <stdio.h>int fun( int a, int b) {return a+b; }main() {int x=6, y=7, z=8, r ;r = fun ( fun(x,y), z-- );printf (" %d\n" , r ); }程序运行后的输出结果是A）15B）21C）20D）31（32）以下选项中函数形参不是指针的是A）fun( int &p ){…}B）fun( int a[10] ){…}C）fun( int *a ){…}D）fun( int p [ ] ){…}（33）设有如下函数定义int fun(int k){if(k<1) return 0;else if(k==1) return 1;else return fun(k-1)+1;}若执行调用语句：n=fun(3);，则函数fun总共被调用的次数是A）2B）4C）3D）521 D 22 B 23 C 24 C 25 B 26 C 27 B 28 A 29 D 30 C 31 B 32 A 33 C 对函数的进一步讨论（34）有以下程序#include <stdio.h>int f(int x){int y;if(x==0||x==1)return (3);y=x*x-f(x-2);return y;main(){int z;z=f(3);printf("%d\n",z);}程序的运行结果是A）9B）0C）6D）8（35）有以下程序（strcat函数用以连接两个字符串) #include <stdio.h>#include <string.h >main(){ char a[20]="ABCD\0EFG\0", b[]="IJK";strcat (a,b); printf("%s\n",a);}程序运行后的输出结果是A）ABCDE\0FG\0IJKB）ABCDIJKC）IJKD）EFGIJK（36）有以下程序int fun(int n){ if(n= =1)return 1;elsereturn(n+fun(n-1));}main( ){ int x；scanf("%d",&x); x=fun(x); printf("%d\n",x);}执行程序时，给变量x输入10，程序的输出结果是A）54B）65C）45D）55（37）有以下程序fun(int x){ int p;if(x= =0‖x= =1) return(3);p=x-fun(x-2);return p;main( ){ printf("%d\n",fun(7));}执行后的输出结果是A）3B）7C）0D）2（38）若有以下程序int f(int a[], int n){if (n > 1){int t; t=f(a, n-1);return t > a[n-1] ? t : a[n-1]; }else return a[0]; }main(){int a[] = {8,2,9,1,3,6,4,7,5};printf("%d\n", f(a, 9)); }则程序的输出结果是A）9B）1C）8D）534 C 35 B 36 D 37 D 38 A 39 B局部变量和全局变量（39）以下叙述中正确的是A）只有全局变量才有自己的作用域，函数中的局部变量没有作用域B）只要是用户定义的标识符，都有一个有效的作用域C）只有在函数内部定义的变量才是局部变量D）局部变量不能被说明为static（40）以下叙述中正确的是A）对于变量而言，“定义”和“说明”这两个词实际上是同一个意思B）在复合语句中不能定义变量C）全局变量的存储类别可以是静态类D）函数的形式参数不属于局部变量（41）有以下程序int d=1;void fun( int p ){int d=5;d += p++;printf("%d ", d ); }int a=3;fun( a );d += a++;printf("%d\n",d); }程序的输出结果是A）9 6B）9 4C）8 4D）8 5（42）有以下程序#include <stdio.h>int a=1,b=2;void fun1(int a, int b){ printf(“%d%d”,a,b); }void fun2( ){ a=3; b=4; }main(){ fun1(5,6); fun2();printf("%d%d\n",a,b);}程序运行后的输出结果是A）3 4 5 6B）1 2 5 6C）5 6 1 2D）5 6 3 4（43）在一个C源程序文件中所定义的全局变量，其作用域为A）由具体定义位置和extern说明来决定范围B）所在程序的全部范围C）所在函数的全部范围D）所在文件的全部范围（44）有以下程序void fun2(char a, char b){ printf("%c%c",a,b); }char a='A',b='B';void fun1( ){a='C'; b='D' ; }main( ){ fun1( );printf("%c%c",a,b);fun2('E','F');}程序的运行结果是A）A B E FC）A B C DD）C D A B40 C 41 C 42 D 43 A 44 B变量的作用域和生存期（45）有以下程序#include <stdio.h>fun( int a, int b ) {int static m=0, i=2;i=i+m+1;m=i+a+b;return m; }main() {int k=4, m=1, p;p=fun( k, m);printf("%d,",p);p=fun( k, m);printf("%d\n",p); }程序运行后的输出结果是A）8,17B）7,16C）8,8D）7,17（46）有以下程序#include <stdio.h>func(int n){ static int num=1;num=num+n;printf("%d",num);}void main(){ func(3);func(4);printf("\n"); }程序运行后的输出是A）4 5B）3 5C）4 8D）3 4（47）有以下程序fun (int x,int y){ static int m=0,i=2;i+ =m+1; m=i+x+y; return m；}main ( ){ int j=1, m=1, k;k=fun(j,m); printf("%d, ",k);k=fun(j,m); printf("%d\n",k);}执行后的输出结果是A）5, 5B）5, 11C）11, 11D）11, 5（48）在C语言中，只有在使用时才占用内存单元的变量，其存储类型是A）extern和registerB）auto和staticC）static和registerD）auto和register（49）有以下程序#include <stdio.h>int fun() {static int x=1;x*=2;return x; }main() {int i, s=1;for( i=1; i<=3; i++ )s*=fun( );printf("%d\n", s); }程序运行后的输出结果是A）0B）10C）30D）64（50）有以下程序#include <stdio.h>int f(int n);main() {int a=3,s;s=f(a);s=s+f(a);printf("%d\n",s); }int f(int n) {static int a=1;n+=a++;return n; }程序运行后的输出结果是A）9B）8C）7D）10（51）有以下程序#include <stdio.h>int fun() {static int x=1;x+=1;return x; }main() {int i,s=1;for(i=1;i<=5;i++) s+=fun();printf("%d\n",s); }程序运行后的输出结果是A）11B）21C）6D）120（52）有以下程序int fun(int x[ ],int n){ static int sum=0,i;for(i=0;i<n;i+ +) sum+ =x[i];return sum;}main( ){ int a[ ]={1,2,3,4,5},b[ ]={6,7,8,9},s=0;s=fun(a,5)+fun(b,4); printf("%d\n",s);}A）50B）45C）60D）55（53）有以下程序int f ( int m ){static int n=0;n+=m; return n; }main() {int n=0;printf ( "%d,", f(++n) );printf ( "%d\n", f(n++) ); }程序运行后的输出结果是A）1,1B）1,2C）2,3D）3,3（54）有以下程序#include <stdio.h>int fun(){ static int x=1;x*=2; return x;}main(){ int i,s=1;for(i=1;i<=2;i++) s=fun();printf("%d\n",s);}程序运行后的输出结果是A）4B）1C）0D）8（55）有下列程序：int a=4;int f(int n){ int t=0; static int a=5;if(n%2) {int a=6; t+ =a+ +; }else {int a=7; t+ =a+ +;}return t+a+ +;}main( ){ int s=a,i=0;for(;i<2;i+ +)s+ =f(i);printf("%d\n",s);}程序运行后的输出结果是A）28B）24C）32D）3645 A 46 C 47 B 48 D 49 D 50 A 51 B 52 C 53 B 54 A 55 A 一维数组的定义和元素的引用（56）有以下程序void fun( int a[], int n) {int i, t; for(i=0; i<n/2; i++){t=a[i]; a[i]=a[n-1-i]; a[n-1-i]=t;}}main(){ int k[10]={1,2,3,4,5,6,7,8,9,10}, i;fun(k,5);for(i=2; i<8; i++) printf("%d", k[i]);printf("\n");}程序的运行结果是A）876543B）321678C）1098765D）345678（57）下列定义数组的语句中，正确的是A）int N=10; int x[N];B）#define N 10 int x[N];C）int x[0..10];D）int x[];（58）有以下程序#include <stdio.h>void main(){int a[]={2,3,5,4},i;for(i=0;i<4;i++)switch(i%2){case 0:switch(a[i]%2){case 0:a[i]++;break;case 1:a[i]--;}break;case 1:a[i]=0;}for(i=0;i<4;i++)printf("%d",a[i]);printf("\n");}程序运行后的输出结果是A）2 0 5 0B）3 3 4 4C）3 0 4 0D）0 3 0 4（59）有以下程序#include <stdio.h>void fun(int a, int b){ int t;t=a; a=b; b=t;}main(){ int c[10]={1,2,3,4,5,6,7,8,9,0), i;for (i=0; i<10; i+=2)fun(c[i], c[i+l]);for (i=0; i<10; i++)printf("%d,", c[i]);printf("\n");}程序的运行结果是A）2,1,4,3,6,5,8,7,0,9,B）0,9,8,7,6,5,4,3,2,1,C）1,2,3,4,5,6,7,8,9,0,D）0,1,2,3,4,5,6,7,8,9,（60）有下列程序：main( ){ int i,s=0,t[ ]={l,2,3,4,5,6,7,8,9};for(i=0;i<9;i+ =2) s+ =*(t+i);printf("%d\n",s);}程序执行后的输出结果是A）20B）45C）36D）25（61）下列选项中，能正确定义数组的语句是A）int num[];B）int N=2008; int num[N];C）int num[0..2008];D）#define N 2008 int num[N];（62）若要求定义具有10个int型元素的一维数组a，则以下定义语句中错误的是A）#define n 5 int a [2*n];B）int a[5+5];C）#define N 10 int a[N];D）int n=10,a[n];（63）下列程序中函数f的功能是：当flag为1时，进行由小到大排序；当flag为0时，进行由大到小排序。
