C语言要点复习

第三章 C语言基础
考核要点：
1. 用户定义标识符
注意事项：A、用户定义标识符只能包含英文字母、下划线、数字，且必须以英文字母或下划线打头；
B、不能使用关键字标识符，区别大小写。
2. 常量的表示和使用
整型常量：A、整型常量的表示和进制转换；B、int、long、unsigned的长度和能表达的有效数值。
字符型常量：A、字符常量和字符串常量的书写格式及区别；B、转义字符的书写格式和含义。
float、double型：A、数值的有效长度和精度；B、float、double型转换为int型的规则。
3. 变量的定义和赋值
A、 内存变量先定义后使用；B、赋值要注意类型的匹配和有效长度，特别注意int、long、char；
C、char型的ASCII码值，及其与int型的互换。
4. 算术运算、赋值运算和逗号运算
1) 算术运算： 双目运算符：+、-、*、/、%； 单目运算符：++、--
A、 运算符的含义和运算规则，如整数除（5/2）和实数除（5./2），%的含义及其结果符号的确定；
B、 混合运算中运算符的优先级别和不同数据类型之间的转换；
C、 ++、--：前缀运算（如i++，i--）是先引用变量的值，然后变量再自增或自减；
后缀运算（如++i，--i）是变量先自增（自减），然后再引用变量的值。
2）赋值运算：A、不同数据类型的转换规则，如int i=3.74；B、复合赋值运算，如x%=3;等价于x=x%3;
3）逗号表达式和逗号运算：表达式1，表达式2，…，表达式n
运算：从左到右，最后一个表达式（表达式n）的值即整个逗号表达式的值。

典型例题

1、以下4组用户定义标识符中，合法的一组是 (C)
A) _main B) 2_int_ C) int_2_ D) default
2、与十进制数200等值的十六进制数为 (C)
A) A8 B)A4 C)C8 D)C4
3、以下选项中可作为C语言合法整数的是 (C)
A）10110B B）0386 C）0Xffa D）x2a2
4、以下符合C语言语法的实型常量是 (C)
A) 1.2E0.5 B) 3.14.159E C) .5E-3 D) E15
5.有以下程序 (C)
main()
{ int m=0256,n=256;
printf("%o %o\n", m, n); }
程序运行后的输出结果
A) 0256 0400 B)0256 256 C)256 400 D)400 400
6、若有以下程序
main()
{ char a;
a = 'H' - 'A' + '0';
printf("%c\n", a); }
执行后输出结果是 【 7 】 。

7、有以下定义语句
double a,b; int w; long c;
若各变量正确赋值，下列选项中不正确的表达式是(A)
A)a=a+b=b++ B)w%(int)(a+b)
C)(c+w)%(int)a D)w=a==b
8、有以下程序
main()
{ int a; char c=10;
float f=100.0; double x;
a=f/=c*=(x=6.5);
printf("%d %d %3.1f %3.1f\n",a,c,f,x); }
程序运行后的输出结果是 （B）
A）1 65 1 6.5 B）1 65 1.5 6.5
C）1 65 1.0 6.5

D）2 65 1.5 6.5
9、若有语句int i=﹣19, j=i%4; printf("%d\n", j); 则输出结果是 【-3】。
10、有以下程序
main()
{ int m=3,n=4,x;
x=-m++;
x=x+8/++n;
printf("%d\n", x); }
程序运行后的输出结果是 （D）
A)3 B)5 C)-1 D)-2
11、有以下程序
main()
{ char a='a', b;
print("%c,", ++a);
printf("%c\n", b=a++); }
程序运行后的输出结果是 （A）
A)b,b B)b,c C)a,b D)a,c

12、有以下程序 （B）
main()
{ int i=10,j=1; printf("%d,%d\n", i--,++j); }
执行后输出结果是 A）9,2 B）10,2 C）9,1 D）10,1
13、设有如下程序段： （D）
int x=2002, y=2003;
printf("%d\n",(x,y));
则以下叙述中正确的是
A）输出语句中格式说明符的个数少于输出项的个数，不能正确输出
B）运行时产生出错信息
C）输出值为2002
D）输出值为2003

第四章 顺序程序设计
考核点：
1. C语句。A、简单语句：表达式; “;”不可缺少。B、复合语句：多个简单语句用{}括起来。
2. printf函数：printf(格式控制，输出表列)
1) 格式控制：%格式控制符。注意格式控制符的含义，以及输出宽度、精度、对齐方式。
2) 输出列表与格式控制一一对应，多余的项将不予输出；输出列表成员可以是常量或变量。
3. scanf函数：scanf（格式控制，地址表列）
1) 格式控制：%格式控制符。注意格式控制符的含义以及输入格式控制之间的分隔符；
2) 输入列表必须是变量地址，输入成员之间用逗号隔开；
3) 从键盘输入时的输入格式必须与格式控制说明的格式一致才能正确输入赋值。
4) 可以指定输入数据的宽度，系统自动截取。如：scanf(“%2d%3d”,&a,&b); 若输入123456 则a的值为12，b的值为345; 而对于“%c”格式，无论指定宽度多少，都只取一个字符。如：char c; scanf(“%c”, &c); 输入ABC，而c的值是A。
5) 结束标识：a、空格，回车，跳格键；b、遇宽度说明；c、遇非法输入：scanf(“%d”, &a); 若输入 123a56；则a值为123。

典型例题

1、若有程序
main()
{ int i,j;
scanf("i=%d,j=%d", &i,&j);
printf("i=%d,j=%d\n", i,j); }
要求给i赋10，给j赋20，则应该从键盘输入 【 】 。
2、有以下程序
main()
{ int i=10,j=1;
printf("%d,%d\n",i-- ,++j); }
执行后输出结果是 (A)
A）9,2 B）10,2 C）9,1 D）10,1
3、有以下程序段 (A)
int m=0,n=0; char c='a';
scanf("%d%c%d", &m,&c,&n);
printf("%d,%c,%d\n", m,c,n);
若从键盘上输入：10A10<回车>，则输出结果是：
A）10,A,10 B）10,a,10 C）10,a,0 D）10,A,0
4、有定义语句：int x, y;，若要通过scanf("%d,%d",&x,&y);语句使变量x得到数值11,变量y得到数值12

，下面输入中，错误的是 (A)
A）11 12<回车> B）11, 12<回车>
C）11,12<回车> D）11,<回车>12<回车>
5、有以下语句段
int n1=10,n2=20;
printf(“ 【 】 ”,n1,n2);
要求按以下格式输出n1和n2的值，每个输出行从第一列开始，请填空。
n1=10
n2=2
6、有以下程序
main( )
{
int x=102，y=012;
printf(“%2d,%2d\n”,x,y); }
执行后输出结果是 (C)
A) 10,01 B) 02,12 C) 102,10 D) 02,10

第五章 选择结构
考核点：
1. 关系运算和关系表达式
1) 优先级别：<、<=、>、>=；==、!= （优先级：前后两组组内同级，前组优先级高于后组）；
2) 表达式的书写：注意aa && x<=b的区别；关系表达式的值非真（非0）即假（0）；
2. 逻辑运算和逻辑表达式。
1) 优先级别：单目运算（!，++，--）>算术运算符>关系运算符>逻辑与和逻辑或>赋值运算符
2) 逻辑运算：&&表达式从左至右依次计算，如某一项值为0，则表达式的值为0，该项之后的不再计算；
||表达式从左至右依次计算，如某一项值为1，则表达式的值为1，该项之后的不再计算。
3. 条件运算和条件表达式
1) 格式：条件 ？表达式1：表达式2；
2) 运算：先计算条件表达式，如满足条件，取表达式1；否则取表达式2。
4. if语句
1) if...else...的执行过程。
2) if和else的作用范围：最近的一条语句，可以是简单或复合语句。
3) if与else的配对：else总是与它前面的、最近的、未配对的if配对。
5、switch语句
1) switch语句的结构
形式：switch(表达式) switch(表达式)
{ {
case 常量表达式1： 语句1 case 常量表达式1：语句1; break;
case 常量表达式2： 语句2 case 常量表达式2：语句2; break;
... ...
case 常量表达式n： 语句n case 常量表达式n：语句n; break;
default: 语句n+1 default: 语句n+1
} }
2) 当表达式的值与case后面的常量表达式相等时，就执行此case后面的语句，若所有的case中的常量表达式的值都没有与表达式的值相匹配，就执行default后的语句；
3) 从入口case后的语句开始（此后不再作判断）执行到最后，如只要执行完一个case语句后即中断，必须在每个case语句后加上break语句；多个case可以共用一组执行语句：
case ‘A’:
case ‘B’: printf(“>60\n”); break;
典型例题


1、若x和y代表整型数，以下表达式中不能正确表示数学关系|x-y|<10的是 (C)
A) abs(x-y)<10 B) x-y>-10&& x-y<10
C)!(x-y)<-10||!(y-x)>10 D) (x-y)*(x-y)<100
2、若有以下程序

main()
{ int p, a=5;
if (p=a != 0 )
printf("%d\n", p);
else
printf("%d\n", p+2);
}
执行后输出结果是 【 1 】 。
3、有以下程序
main()
{ int a=5,b=4,c=3,d=2;
if (a>b>c)
printf("%d\n", d);
else if ( (c-1 >= d) == 1)
printf("%d\n", d+1);
else
printf("%d\n", d+2);
}
执行后输出结果是 (B)
A）2 B）3 C）4 D）编译时有错，无结果
4、有以下程序




main()
{ int i=1, j=1, k=2;
if ( (j++ || k++) && i++)
printf("%d,%d,%d\n", i,j,k);
}
执行后输出结果是 (C)
A）1,1,2 B）2,2,1 C）2,2,2 D）2,2,3
5、有以下程序
　main()
　{ int i;
for(i=0;i<3;i++)
switch(i)
{ case 0:printf("%d",i);
case 2:printf("%d",i);
default: printf("%d", i); } }
程序运行后的输出结果是 (C)
A)022111 B)021021 C)000122 D)012
6.以下程序运行后的输出结果是 ___2,1___ 。
　main()
　{ int x=1,y=0,a=0,b=0;
switch(x)
{ case 1:switch(y)
{ case 0:a++; break;
case 1:b++; break;
}
case 2:a++;b++; break;
}
printf("%d,%d\n", a,b); }

第六章 循环控制
考核点：所有的循环控制问题关注三个方面：初始状态各变量的值、循环的逐步执行过程、结束状态各变量的值。
1. while和do~while语句
1) do~while语句的结构
do
{
循环体语句
} while（条件表达式）;
2) 执行流程。
2、for语句
1) for循环的结构：
for(循环变量初始化表达式;循环条件表达式;循环变量增值表达式)
{ 循环体语句}
for语句的三个表达式根据需要可有可无，但三个”;”号不可缺省。
2) 执行流程见右图。
3、break语句和continue语句
1) break语句：跳出循环体，提前结束循环。
2) continue语句：跳过continue语句之后的语句，提前进入下一次循环。

典型例题


1、有以下程序
main()
{ int s=0,a=1,n;
scanf("%d",&n);
do
{ s+=1; a=a-2; }while(a!=n);
printf("%d\n",s);
} }
若要使程序输出值为2，应该从键盘给n输入的值是B
A）-1 B）-3 C）-5 D）0
2、有以下程序
main()
{ int i=0,s=0;
do {
if (i%2) { i++; continue; }
i++;
s += i;
} while(i<7);
printf("%d\n", s);
}
执行后输出结果是 (A)
A）16 B）12 C）28 D）21
3、有以下程序
main( )
{ int i,s=0;
for(i=1;i<10;i+=2) s+=i+1;
printf(“%d\n”,s);
}
程序执行后的输出结果是 (D)
A) 自然数1～9的累加和 B) 自然数1～10的累加和C) 自然数1～9中的奇数之和 D) 1～10中偶数之和
4、执行以下程序后，输出'#'号的个数是 【 6 】 。
#include
main()
{ int i,j;
for(i=1; i<5; i++)
for(j=2; j<=i; j++) putchar('#');
}
5、有以下程序
main( )
　{ int i,n=0;
for(i=2;i<5;i++)
{ do
{ if(i%3) continue;
n++;
} whil

e(!i);
n++;
}
printf(“n=%d\n”, n);
}
程序执行后的输出结果是 (D)
A) n=5 B) n=2 C) n=3 D) n=4
6、有以下程序
main()
{ int i=0,x=0;
for ( ; ;)
{
if(i==3||i==5) continue;
if (i==6) break;
i++;
s+=i;
}
printf("%d\n",s);
}
程序运行后的输出结果是 (D)
A)10 B)13 C)21 D)程序进入死循环
7、有以下程序
main()
{ int k=4,n=0;
for( ; n{ n++;
if(n%3!=0) continue;
k--; }
printf("%d,%d\n", k,n);
}
程序运行后的输出结果是 (C)
A）1,1 B）2,2 C）3,3 D）4,4

第七章 数组
1. 一维数组
1) 定义：必须指定数组的大小，不允许动态定义；但是数组定义时初始化如果不指定元素个数，则其由初始赋值的个数决定。
2) 初始化：a、对全部数组元素赋值；b、部分元素赋值；c、注意数组元素的缺省值。
3) 数组的元素：数组名[下标]，注意下标从0开始，要防止数组访问越界。
2. 二维数组
1) 定义：必须指定二维数组的行和列的大小，不允许动态定义；但在定义时初始化可省略行的大小说明，行的大小由赋值的个数决定。
2) 数组的元素：数组名[行下标][列下标]，注意下标从0开始。
3. 字符串和数组
1) 字符数组的定义、赋值、数组元素的引用与数值型数组一致；但字符数组未被初始化的元素系统赋值’\0’。
2) C语言为字符串常量自动附加’\0’作为结束标识，因此字符串的实际长度（strlen()）是所包含的字符个数，但占用的内存空间（sizeof()）应是strlen()+1，用于保存’\0’。
4. 字符处理函数
1) “%s”输出格式：a、输出的字符中不包括结束符’\0’， 输出时遇到’\0’就结束，若没有’\0’，则按数组实际长度输出；b、在printf中，输出项使用字符数组地址，而不是数组元素。
2) puts函数：a、输出字符串中可包含转义字符；b、输出结束后自动换行；c、只能输出单个字符串。
3) strcat(字符数组1,字符数组2)：连接两个字符串，2接在1的后面（从1的第一个’\0’处开始），结果存放在1中；1的空间应足够大；函数返回值是字符数组1的起始地址。
4) strcpy(字符数组1,字符数组2)：将字符数组2拷贝到字符数组1中（从1的起始位置开始）；1的空间必须足够大；拷贝时连同’\0’一起拷贝到串1中；2可以是字符串常量；不能用赋值语句进行字符串赋值（str1=str2错误）。
5) strcmp(字符串1，字符串2)：从左到右逐个比较字符的ASCII码值的大小，直到出现不同字符或遇到’\0’为止。字符串1=字符串2，函数值0；否则返回第一个不同字符的ASCII码值的差。
6) strlen(字符数组或字符串常量)：计算第

一个’\0’之前（不包括’\0’）的字符串长度。
7) sizeof(变量名)：计算变量所占用的内存空间，变量可以是一般内存变量、数组、指针、结构体等。
典型例题

1、以下能正确定义数组并正确赋初值的语句是 (D)
A）int N=5,b[N][N]; B）int a[1][2]={{1},{3}};
C）int c[2][]= {{1,2},{3,4}}; D）int d[3][2]={{1,2},{34}};
2、若有以下程序
main()
{ Int a[4][4]= {{1,2,-3,-4},{0,-12,-13,14},
{-21,23,0,-24},{-31,32,-33,0}};
int i, j, s=0;
for (i=0; i<4; i++)
{ for (j=0; j<4; j++)
{ if (a[i][j] < 0) continue;
if (a[i][j] == 0) break;
s += a[i][j];
}
}
printf("%d\n", s);
}
执行后输出结果是 【 58 】 。
3、有以下程序
main()
{ char s[]="\n123\\";
printf("%d,%d\n ", strlen(s), sizeof(s)); }
执行后输出结果是 (C)
A）赋初值的字符串有错 B）6,7 C）5,6 D）6,6
4、以下函数的功能是：通过键盘输入数据，为数组中的所有元素赋值。
#define N 10
void arrin(int x[N])
{ int i=0;
while(iscanf("%d", );
}
在下划线处应填入的是 (C)
A）x+i B）&x[i+1] C）x+(i++) D）&x[++i]
5、有以下程序
main()
{ int m[][3]={1,4,7,2,5,8,3,6,9};
int i,j,k=2;
for(i=0; i<3; i++)
{ printf("%d ",m[k][i]); }
}
执行后输出结果是 (C)
A）4 5 6 B）2 5 8 C）3 6 9 D）7 8 9
6、有以下程序
main ()
{ int p[7]={11,13,14,15,16,17,18}, i=0,k=0;
while(i<7 && p[i]%2){k=k+p[i];i++;}
printf ("%d\n", k);
}
执行后输出结果是 (D)
A）58 B）56 C）45 D）24

7、以下程序运行后的输出结果是 _92 。
main()
{ int a[4][4] = {{1,2,3,4},{5,6,7,8}, {11,12,13,14},{15,16,17,18}};
int i=0,j=0,s=0;
while(i++<4)
{
if(i==2||i==4) continue;
j=0;
do{s+=a[i][j]; j++; } while(j<4);}
printf("%d\n", s);
}
}

第八章 函数
考核要点：
1. 函数声明：返回值类型 函数名（形参类型1, 形参类型2,...）;/*被调用函数定义在主调函数之后需声明*/
2. 函数调用：函数名（实参1, 实参2,...） /*实参是有实际值的常量、变量、指针等*/
1) 实参与形参按顺序对应，一一传递数据; 实参与形参个数应相等，类型匹配；
2) 函数由return语句返回一个数值，数值类型与函数定义的返回值类型一致（void无返回值）；
3) 传值：直接将实参的数值传递给形参。系统首先为形参分配临时内存单元，然后将实参值赋给形参，形参值在函数中的改变并不会使实参发生改变，最后在函数调用结束时形参的临时内存单元被销毁。
4) 传地址。不直接将实参的数值传递给形参，而是将实参的地址传递给形参，形参直接读取其中的值。这种情况形参和实参共享一片内存单元，函数中对形参的操作就是对实参的操作，结果会使实参的值改变。传地址的几种情况是：a、形参定义

为引用；b、数组作形参；c、指针作形参。
3. 函数的嵌套和递归调用（函数嵌套仔细分析教材P168图8-5；递归仔细分析P172例8.7及图8-11）
1) 函数嵌套的执行过程：由内向外，逐层执行，注意每层执行的情况。
2) 递归：自己调用自己的函数嵌套，其执行也是由内向外，逐层执行，注意每层执行开始条件和结束的情况。
4. 变量的作用域和生存周期
1) 局部变量：在函数内部定义的，只在本函数范围内有效的变量。a、主函数中定义的变量也是局部变量，只在主函数中有效；b、不同函数中可以定义相同的变量名，它们互不干扰；c、形式参数也是局部变量；d、可在复合语句中定义只在本复合语句内有效的局部变量。
2) 全局变量：在函数之外定义的变量，其有效范围是从变量定义处到本源程序文件结束。A、全局变量在其有效作用范围内，值的改变都会被保留；b、同一个程序文件中，外部变量与局部变量同名，则在局部变量的作用范围内，外部变量不起作用。
3) 静态存储变量：在程序运行期间系统分配固定的内存空间，主要有全局变量、static变量、extern变量。
4) 动态存储变量：在程序运行期间根据需要动态的分配内存空间；函数形参、自动变量函数调用的现场保护。

典型例题


1、通过函数求f(x)的累加和，其中f（x）=x2＋1
F( int x)
{ return _____ x*x+1____;}
SumFun(int n)
{
int x,s=0;
for(x=0;x<=n;x++) s+=F（__x__）;
return s;
}
main()
{ printf("The sum=%d\n",SumFun(10));}
2、请在以下程序第一行的下划线处填写适当内容，使程序能正确运行。
【 double max 】 ( double, double);
main ()
{ double x, y;
scanf("%lf%lf",&x,&y);
printf("%lf\n",max(x, y));
}
double max(double a, double b)
{ return(a>b ? a:b); }
3、有以下程序
void f(int x, int y)
{ int t;
if (x}
main()
{ int a=4,b=3,c=5;
f(a, b); f(a, c); f(b, c);
printf("%d,%d,%d\n", a,b,c);
}
执行后输出结果是 (D)
A）3,4,5 B）5,3,4 C）5,4,3 D）4,3,5
4、有以下程序 (B)
void swap1(int c[])
{ int t;
t=c[0];c[0]=c[1];c[1]=t;
}
void swap2(int c0,int c1)
{ int t;
　t=c0;c0=c1;c1=t;
}
main( )
{ int a[2]={3,5},b[2]={3,5};
　swap1(A) ; swap2(b[0],b[1]);
　printf(“%d %d %d %d\n”,a[0],a[1],b[0],b[1]);
}
其输出结果是 A) 5 3 5 3 B) 5 3 3 5
C) 3 5 3 5 D) 3 5 5 3
5、若有以下程序 d=9
int f(int x, int y)
{ return (y-x)*x; }
main()
{ int a=3,b=4,c=5,d;
d = f(f(3,4),f(3,5));
printf("%d\n",d); }
6、以下程序运行后的输出结果是 【 136 】
Void fun(int x)
{ if(x/2>0) fun(x/2);
printf("%d ",x);
}
main()
{ fun(6); }
7、有以下程序
char fun(char x , char y)
{ if(x>y)
　return y;

}
main( )
{ int a=’9’,b=’8’,c=’7’;
printf(“%c\n”,fun(fun(a,b) ,fun(b,c)));
}
程序的执行结果是 (D)
A) 函数调用出错 B） 8 C）9 D）7
8、以下程序运行后的输出结果是 【 30 25 】
int a=5;
fun(int b)
{ static int a=10;
a+=b++;
printf("%d ",a);
}
main()
{ int c=20;
fun(c);
a+=c++;
printf("%d\n",a);
}

第九章 编译预处理
考核要点：
1. 宏定义：a、不带参数的宏定义；b、带参数的宏定义；c、嵌套宏定义；d、宏定义的有效范围。宏定义的求解分为二步：1）、字符串替换（只作简单替换，不做正确性检查）；2、代入数值；3、宏定义的有效范围自定义到程序末，或遇”#undef 宏名”结束。
2. 条件编译：几种条件编译的含义和执行。
典型习题

1、下面程序的执行结果是：5
#define N 2
#define M N+1
#define K M+1*M/2
main()
{ for(int i=1;iprintf(“%d”, i);
}
2、有以下程序
#define f(x) x*x
main( )
{ int i;
i=f(4+4)/f(2+2);
　printf(“%d\n”,i);
}
执行后输出结果是 A
A) 28 B) 22 C) 16 D) 4
3、以下程序的输出结果是 【16】 。
#define MCRA(m) 2*m
#define MCRB(n,m) 2*MCRA(n)+m
main()
{ int i=2,j=3;
printf("%d\n",MCRB(j,MCRA(i)));
}
4、有以下程序
#include
#define F(X,Y) (X)*(Y)
main()
{ int a=3, b=4;
printf("%d\n", F(a++, b++));
}
程序运行后的输出结果是 （A）
A）12 B）15 C）16 D）20


第十章 指针
考核要点：
1. 指向简单内存变量的指针：a、定义和赋值；b、&：取地址运算；*：取数值运算；c、指针变量作函数形参是地址传递，实参应是变量地址。
2. 一维数组和指针（以此定义为例：int a[5]={0,1,2,3,4}, *p=a;）
1) 数组名是常量指针，永远指向数组起始地址，指针变量P可指向任意int型变量的地址；
2) 第i个数组元素的地址：a+i、&a[i]、p+i（p++表示移动指针p到下一地址）；
3) 第i个数组元素的值：a[i]、p[i]、*(a+i)、*(p+i)。
4) 一维数组作函数形参：a、形参数组大小说明可省略，由实参决定；b、地址传递，实参可以是数组名、二维数组的一行、指向一维数组的指针。
3. 二维数组和指针（以此定义为例：int a[2][4]={0,1,2,3,4,5,6,7}, *p=a;）
1) 第i行的地址：a[i], *(a+i), &a[i][0]；
2) 第i行、第j列元素的地址：a[i]+j、*(a+i)+j、&a[i][j]；
3) 第i行、第j列元素的值：a[i][j]、*(a[i]+j)、*(*(a+i)+j)；
4) 指向由m个整数组成的一维数组的指针变量：数据类型说明符 （*变量名）[m]。指针只能指向一个包含m个元素的一维数组，它的值是一维数组的起始地址，而不能直接指向某个元素。
5) 二维数组作函数形参：列大小说明可省略，由实参决定；实参可以是二维数组名或指向二维数组的指针。
4. 字符串与指针
1) 字符

串可用字符数组保存，也可以用字符指针”保存”---把字符串的起始地址赋给字符指针；
2) 字符串元素的引用：a、下标法：string[i]；b、指针法：*(string+i)；
3) 字符数组作形参：实参可以是被初始化的字符数组名、字符串常量、指向字符数组或字符串的指针。
5. 指向函数的指针
1) 定义格式： 数据类型说明符 （*指针变量名）（形参类型列表）; 如：int (*p)(int, int);
2) 初始化格式：指针变量名=函数名; 如：p=max;
3) 调用格式： （*指针变量名）（函数实参列表）; 如：c=(*p)(a, b);
6. 指针数组、二维指针
1) 指针数组：类型标识符 *数组名[数组大小];每个数组元素都是一个指针，注意与指向数组的指针的区别；
2) 二维指针：二维指针的定义格式：数据类型标识符 **指针变量名; 例如：int **q; q是二维地址，*q是一维地址，**q是数值。
7. main函数的参数
1) main函数的形参格式：void main(int argc, char *argv[])
2) 命令执行格式：命令名 参数1，参数2，…，参数n
3) 其中，argc保存命令行中参数的个数，文件名也作为一个参数；命令行参数保存在argv[]中。
4) 例题。在命令提示符下输入如下内容：file1 Beijing China
main(int argc, char *argv[])
{ printf(“%d ”, argc);
for(int i=0; iprintf(“%s ”, argv+i);
}
将得到输出：3 file1 Beijing China

典型习题

1、设有定义：int n=0,*p=&n,**q=&p;则以下选项中，正确的赋值语句是 (D)
A) p=1; B) *q=2; C) q=p; D) *p=5;
2、有以下程序
void f( int y,int *x)
{y=y+*x; *x=*x+y;}
main( )
{ int x=2,y=4;
f(y,&x);
printf(“%d %d\n”,x,y); }
执行后输出的结果是【 8 4 】 。
3、有以下程序
int a=2;
int f(int *a)
{return (*a) ++;}
main( )
{ int s=0;
{ int a=5;
s+=f(&a) ;
}
s+=f(&a) ;
printf(“%d\n”,s); }
执行后输出结果是 (C)
A) 10 B) 9 C) 7 D) 8
4、有以下程序
void fun( int *a, int i, int j)
{ int t;
if(i{ t=a[i]; a[i]=a[j]; a[j]=t;
fun(a,++i,--j); } }
main()
{ int a[]={1,2,3,4,5,6},i;
fun(a,0,5);
for(i=0; i<6; i++)
printf("%d ",a[i]); }
执行后输出结果是 (A)
A）6 5 4 3 2 1 B）4 3 2 1 5 6 C）4 5 6 1 2 3 D）1 2 3 4 5 6
5、有以下程序
main()
{ int x[8]={8,7,6,5,0,0},*s;
s=x+3;
printf("%d\n",s[2]); }
执行后输出结果是 (B)
A）随机值 B）0 C）5 D）6
6、有以下程序
main()
{ int a[][3]={{1,2,3},{4,5,0}},(*pa)[3],i;
pa=a;
for(i=0; i<3; i++)
if(i<2) pa[1][i] = pa[1][i]-1;
else pa[1][i]=1;
printf("%d",a[0][1]+a[1][1]+a[1][2]);}
执行后输出结果是 (A)
A）7 B）6 C）8 D）无确定值
7、有以下程序
int *f(int

*x, int *y)
{ if (*x < *y) return x;
else return y; }
main()
{ int a=7,b=8,*p,*q, *r;
p=&a; q=&b; r = f(p,q);
printf("%d,%d,%d\n",*p,*q,*r); }
执行后输出结果是 (B)
A）7,8,8 B）7,8,7 C）8,7,7 D）8,7,8
8、有以下程序段
int a[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b;
b=p[5]; (D)
b中的值是　A) 5 B) 6 C) 8 D) 9
9、以下程序中，函数sumColumM的功能是：求出M行N列二维数组每列元素中的最小值，并计算它们的和值。和值通过形参传回主函数输出。请填空。
#define M 2
#define N 4
void SumColumMin(int a[M][N],int *sum)
{ int i,j,k,s=0;
for(i=0;i　{ k=0;
for(j=1;j if(a[k]>a[j]) k=j;
s+= ___a[k]____ ;
　}
　*sum = s;
}
main()
{ int x[M][N]={3,2,5,1,4,1,8,3},s;
SumColumMin( a, &s );
　printf("%d\n",s); }
10、以下程序中给指针p分配三个double型动态内存单元，请填空。
　main ( )
　{ double *p;
　p=(double*)malloc(3*sizeof(double));
p[0]=1.5;p[1]=2.5;p[2]=3.5;
printf(“%f%f%f\n”,p[0],p[1],p[2]);}
11、以下程序运行后的输出结果是 __gae___ 。
main ()
{ char a[]="Language",b[]="Programe";
char *p1,*p2; int k;
　p1=a; p2=b;
　for(k=0;k<=7;k++)
　if(*(p1+k)==*(p2+k)) printf("%c",*(p1+k));}
12、有以下程序
main( )
{ char *p[10]={“abc”,”aabdfg”,”dcdbe”,”abbd”,”cd”};
　printf(“%d\n”,strlen(p[4])); }
执行后输出结果是 (A)
A) 2 B) 3 C) 4 D) 5
13、有以下程序 (C)
main()
{ char str[][20]={"Hello","Beijing"},*p=str;
printf("%d\n",strlen(p+20)); }
程序运行后的输出结果是 A）0 B）5 C）7 D）20
14、以下程序运行后输入：3,abcde<回车>，则输出结果是 【 】
#include
move(char *str, int n)
{ char temp; int i;
temp=str[n-1];
for(i=n-1;i>0;i--) str[i]=str[i-1];
str[0]=temp; }
main()
{ char s[50]; int n, i, z;
scanf("%d,%s",&n,s);
z=strlen(s);
for(i=1; i<=n; i++) move(s, z);
printf("%s\n",s); }
15、以下程序中函数scmp的功能是返回形参指针s1和s2所指字符串中较小字符串的首地址
#include
#include
char *scmp(char *s1, char *s2)
{ if(strcmp(s1,s2)<0) return(s1);
else return(s2); }
main()
{ int i; char string[20], str[3][20];
for(i=0;i<3;i++) gets(str[i]);
strcpy(string,scmp(str[0],str[1]));
strcpy(string,scmp(string,str[2]));
printf("%s\n",string); }
若运行时依次输入：abcd、abba和abc三个字符串，则输出结果为
A）abcd B）abba C）abc D）abca
16、以下程序运行后的输出结果是 _______ 。
main()
{ char a[]="123456789",*p; int i=0;
p=a;
　while(*p)
　{ if(i%2==0) *p='*";
p++;i++;}
　puts(a); }
17、以下sstrcpy( )函数实现字符串复制，即将t所指字符串复制到s所指向内存空间中，形成一个新的字符串s。请填空。
void sstrcpy(char *s,char *t)
{ while(*s++=【

】)；}
main( )
{ char str1[100],str2[]=”abcdefgh”;
　sstrcpy(str1,str2);
printf(“%s\n”,str1);}
18、下列程序的运行结果是：【 】
char *ss(char *s)
{ return s+strlen(s)/2;}
main( )
{ char *p,*str=”abcdefgh”;
　p=ss(str); printf(“%s\n”, p);}
19、有以下程序
main(int argc, char *argv[] )
{ int n,i=0;
while(argv[1][i]!='\0')
{ n=fun(); i++; }
printf("%d\n", n*argc); }
int fun()
{ static int s=0;
s+=1; return s; }
20、设函数findbig已定义为求3个数中的最大值。以下程序将利用函数指针调用findbig函数。请填空。
main()
{ int findbig(int,int,int);
int (*f)(),x,y,z,big;
f= 【 】 ;
scanf("%d%d%d",&x,&y,&z);
big=(*f)(x,y,z);
printf("big=%d\n",big); }

21、有以下程序
main()
{ char str[]="xyz",*ps=str;
while(*ps) ps++;
for(ps--; ps-str>=0;ps--) puts(ps); }
执行后输出结果是_______