C语言总结

*对于“同中求异”一般采用建立一个新的数组，将“异”放入新的数组中，而不是将“同”删掉，因为前者比后者在处理上更简单，删除制定字符也属于这一类；

 

*插入排序：先对头两个字符进行排序，然后把第三个字符插入到前两个字符中，插入后前三个字符依然有序；再把第四个字符插入到前三个字符中，。。。；

 折半查找：每次查找前先确定数组中待查的范围low和high（low<high），然后用m与中间位置（mid）上的元素的值进行比较。如果m的值大于中间元素的值，则下一次的查找范围落在中间位置之后的元素中；反之，下一次的查找范围落在中间位置之前的元素中。直到low>high时，查找结束；

筛选法求素数:首先从2开始，将所有2的倍数的数从数表中删去（把数表中相应位置的值为0）；接着从数表中找下一个非0数，并从数表中删去该数的所有倍数；依此类推，直到所找的下一个数等于n为止；

 

*y=(x*100+0.5)

 return (float)y/100.0;

保留两位小数，保留三位小数把100改为1000，以此类推；

 

#include <stdio.h>

void fun(int *a,int *b){

         int*c;

         c=a;

         a=b;

         b=c;

}

main(){

         intx=3,y=5,*p=&x,*q=&y;

         fun(p,q);

         printf("%d,%d,",*p,*q);

         fun(&x,&y);

         printf("%d,%d\n",*p,*q);

}输出3,5,3,5

#include <stdio.h>//法二：#include<stdio.h>

void fun(int *a,int *b){//void fun(int*x,int *y){

         intc;//int t;

         c=*a;//t=*x;

         *a=*b;//*x=*y;

         *b=c;//*y=t;

}//}

main(){//void main(){

         intx=3,y=5,*p=&x,*q=&y;//int a=3,b=5;

         fun(p,q);//fun(&a,&b);

         printf("%d,%d,",*p,*q);  // printf("%d,%d\n",a,b);

}//}

                                

*void fun(int &a,int b)&a是取地址的意思，当对a的引用在函数体内发生各种操作时，会影响变量a原来的值，而b就不会；

 

*对于取倒数的题，要从1开始，从0开始会出错；

 

*if里的控制语句有&&，||，一定要注意（）的运用否则出错，因为计算机是从头开始执行，只要||前面的语句执行成功了，则后面的语句将直接跳过；

 

*char一个字节short两个字节long四个字节int四个字节float四个字节double八个字节，凡在数据类型前面加了unsigned的，空间减半（32位）；

 

*fopen函数用来打开一个文，期一般形式为：文件指针名=fopen（文件名，使用文件方式）；

 fputc功能是把一个字符写入指定的文件中，其调用形式为：fputc（字符量，文件指针），其中待写入的字符可以是字符常量或变量，被写入的文件可以用写、读写、追加等方式打开；

 fseek文件定位函数用来移动文件内部的位置指针，其调用形式为：fseek（文件指针，位移量，起始点）。“位移量”要求long型数据，当用常量表示位移量的时，要求加后缀“L”，“起始点”有三种：文件开始用SEEK__SET表示（数字表示“0”），文件末尾用SEEK__END表示（数字表示“2”），文件中间用SEEK__CUR表示（数字表示“2”）；

 

*int a=2;a++;        int a=2,p;p=a++

printf("%d",a)       printf("%d",p)

输出3；              输出2；

对于第二种情况还有一种可能：多次调用相同函数，在第二次调用函数的时候，a+1；

 

*当多个循环并列时，执行过程是从上到下把第一个循环执行完毕，再执行下一个循环语句，切记是从上到下每条循环语句都执行一次，然后整体循环n次；

 

*输入任意一个数，需要一个输入框比如prompt；

 

*id名称不能一致，如form的id名称不能和div的名称重复；

 

*“斐波那契列问题”var N=prompt（......）;后面应为for（vari=1;i<=N;i++）如果for(var i=0;i<N+1;i++)，则前面应为varN=parseInt(prompt(.......));

 

*“星号输出问题”最外面一层的for与之配对的为document.write(“<br>”)；

 

*“解方程问题”对于同一个变量，在不同的if语句中，都要重新定义；

 

*“冒泡法问题”最关键的是t；

 

*强制转换，如vara=parseInt(Math.random()*5+6)

 

*switch语句中一定有default和括号；

 

*空字符也占内存，其内存空间并非为“0”，两个连续的单引号不合法，但两个连续的双引号合法，表示空串，占一个字节的空间；

 

*p=NULL<=>p=0；

 

*a[i]实际上指的是第i+1个数；

 

*关系数据库中的实现的专门关系运算包括选择、连接和投影；

 

*long要和double搭配；

 

*scanf函数中'\n'只转行一个单词，而gets转行所有；

 

*交换的三种方法：

1、  t=a   2、  a=a^b       3、  a=a+b

         a=b            b=a^b                b=a-b

         b=t            a=a^b                a=a-b

 

*比较两个数或少数个数的数字的大小，用条件运算符比用if语句简洁；

 

*小写字母=大写字母+32,字符=数字+48；

 

*相比于从“2”开始除到比自身小“1”判断素数的方法，根号法更快捷；

 

*parseInt()与Math.floor()有相同功效；

 

*No=叶子节点数/都为0的数，N1=度为1的数，N2=度为2的数。求二叉树总结点数：No+N1+N2，其中N2=No-1；

 

*软件设计包括软件的结构设计、数据设计、接口设计和过程设计，其中的软件的过程指系统结构部件转换成软件的过程性描述；

 

*合法的用户自定义标示符只能以字母和下划线开头，其中也不能包含除下划线以外的其他符号，如：&￥等皆不行。还有，不能和系统自定义的标志符重名，但是大写的可以，因为c语言是区分大小写的；

 

*NULL的代码值为“0”，p=NULL等价于p='\0'或p=0；

 

*取出每一行的最大值：

void fun(int a[][N],int b[]){

         inti,j;

         for(i=0;i<N;i++){

                   b[i]=a[i][0];

                   for(j=1;j<N;j++)

                            if(b[i]<a[i][j])

                                     b[i]=a[i][j];

         }

}

a[i][0]已经赋值给b[i]了，现在就剩下a[i][1]和a[i][2]与b[i]比较，所以j要从1开始；

 

*c语言中，使用exit（0）；必须要使用头文件#include<stdlib.h>；

 

*无论结果是真是假，只要满足条件，并且进入了循环，就要将循环进行到底，直到条件不满足为止；

 

*c语言中，0表示假，'0'表示零其ASCII码为48，'\0'表示结束，其ASCII码为0；

 

*a[][]可以理解为先列后行；

 

*从头到尾执行一次循环！=循环结束，因为在这一次循环中可能产生新的循环；

 

*左移扩大，右移缩小；

 

*二叉树的深度为（lnN/ln2）+1；

 

*switch语句的case后面没有break则进入下一句case，除非有return；

 

*倒序输出：

#include <stdio.h>

main(){

         intd,n=1234;

         while(n!=0){

                   d=n%10;n=n/10;

                   printf("%d",d);

         }

}

 

*内存空间的动态分配和释放：malloc,colloc,free,realloc用法：

int *p=(int *)malloc(sizeof(int)*128);

int *p=(int *)colloc(3,sizaof(structstudent));

free(pre);

p=(char *)realloc(p,256);

 

*fwrite(x,sizeof(int),3,fp)意思是把x当做一条记录，记录长度是sizeof(int)，记录数是3，得到文件指针fp；

 

以上函数均包含在头文件stdlib.h中

*&和&&的区别：前者是位运算符，后者是逻辑运算符（判断真假）；

 

*输入多个数时输入格式必须与scanf一致；

 

*注意区别：

设变量均已正确定义并赋值，以下与其他三组输出结果不同的是（D）

A、x++;printf("%d\n",x);

B、n=++x;printf("%d\n",n);

C、++x;printf("%d\n",x);

D、n=x++;printf("%d\n");

 

*int a=3;printf("%d",-a++)输出结果-3，此时a=4（也即当a++在此位置时，输出结果为a，而非a+1）；若将-a++改为- ++a输出结果为-4，此时a=4；

 

*数组输入不用&符号，引用外部数组不用带下标；要是定位输入，则可以采用&x[6]或者x+6的形式，*(x+6)和p[6]的格式都不对；

 

*"%"符号两端的数据必须为整型；

 

*printf遇到空格的符号会停止输出，而puts则可以输出空格；

 

*循环队列公式：(rear-front+maxsize)%maxsize；

 

*求栈中元素个数：bottom-top+1；

 

*输入时要与scanf的格式相同，如scanf("%d,%d",&a,&b);那么输入的时候就要写成a=1,b=2两者都要有逗号；

 

*对于“||”，当第一个数为真时，则a||b为真，不用判断第二个数。

设a、b、c都是整型变量，如果a的值为1，b的值为2，则执行c=a++||b++；语句后，变量b的值是2（而不是3）；

又如：int k1=10,k2=20;执行表达式（k1=k1>k2）&&(k2=k2>k1)后，k1和k2的值分别为：0和20；

 

*putchar(b+'0');表示输出字符；

 

*半角标点符号占一个字节，全角标点符号占两个字节；

 

*w+比r+更强大；

 

*面向对象设计方法的主要特征有：封装性、继承性、多态性；

 

*若双目运算符两边运算数的类型不一致，系统将自动进行类型转换，使运算符两边的类型达到一致后，再进行运算。转换过程为字符型->整形->浮点型；

 

*while（a--），当括号里的a变为0的时候，此语句仍执行，但是执行完之后跳出本循环；

 

*对于字符的++，是后移一位的意思；

 

*“*”和“++”都属于第二优先级，且结合性均为自右向左；自右向左的的优先级有+，-，++，--，*，&，sizeof，？：，=，+=，-=，*=，/=，%=，&=，^=，|=，<<=，>>=；

 

*int num[2][4]{1,2,3,4,5,6}和intnum[2][4]{{1,2},{3,4},{5,6}},第一个正确（可以添零），第二个错误（不能添零）；

 

*指针具有承接的功能：

#include <stdio.h>

void fun(int *p){

         printf("%d\n",p[5]);

         }

main(){

         inta[10]={1,2,3,4,5,6,7,8,9,10};

         fun(&a[3]);

         }

输出结果是9，而不是6；

 

*strcmp（字符串1，字符串2），若字符串1==字符串2，则为0；若字符串1>字符串2，则为正值；若字符串1<字符串2，则为负值；

 

*字符串升序排列：

#include <stdio.h>

#include <string.h>

main(){

         chara[5][10]={"china","beijing","you","tiananmen","welcome"};

         inti,j;

         chart[10];

         for(i=0;i<4;i++){

                   for(j=i+1;j<5;j++){

                            if(strcmp(a[i],a[j])>0){

                                     strcpy(t,a[i]);

                                     strcpy(a[i],a[j]);

                                     strcpy(a[j],t);

                            }

                   }

         }

                            puts(a[3]);

}

其中的a[i],a[j]均为a[5][10]的第一个括号；

 

*static改变了对应变量、函数的作用域，使其不能被其他文件从外部引用。除此之外还有“保值”的功能

#include <stdio.h>

int f(int m){

   static int n=0;

         n+=m;

         returnn;

}

main(){

         intn=0;

         printf("%d",f(++n));

         printf("%d",f(n++));

}

结果为1,2；

 

*形参：形式上的参数，用完就扔，是系统运行中的一个临时变量，因此不能定义成static型变量只有全局变量、局部变量才可以这样定义；

 

*对于递归函数，如果其中一句无法执行，则跳过本句，执行下一句；

 

*switch语句每个case语句都是一个独立的分支，所以对于具有相同的形参，不具有静态效应；

 

*在循环语句中，如果有多个控制变量，程序会选择支持程序运行下去的那句执行；

 

*如果不满足最外层限制条件则不必再看内层限制条件，直接执行下一条最外层限制条件，如果没有则直接输出或提出，如多重if语句；

 

*结构体中的字符串赋值不能够通过指针来实现：

如struct{

         charmark[12];

         intnum1;

         doublenum2;

         }

t2.mark=t1.mark是错误的赋值方式；

 

*if语句在没有{}封装的情况下只执行紧接其后的一句；

 

*函数放在main之前必须先进行函数声明，对于先mian后fun的一种特殊形式是在main之前进行fun的声明；

 

*0表示数字零（数字0和strlen()在一起的时候也可以起到结束符的效果），'0'表示字符零，'\0'标志结束符；

 

*指针：

int *p; scanf("%d",&p);(p是地址值)

int *p; scanf("%d",p);(不能给直接给地址p赋值)

int k,*p=&k;  scanf("%d",&p);

int k,*p;*p=&k  scanf("%d",&p);（*p是整型变量，&k是地址值，*p=&k是错误的）；

 

*用int定义数组不能包含两个以上变量，如int N=10;int a[N];的定义是错的，如果要定义可以采用宏定义；

 

*字符串可以比较大小（实际上比较的是字符串的ASCII码），但是一般情况下用strcmp比较字符串，而不用==，但是不可以做加减法等数学运算；

 

*while()括号里的判断句应仔细斟酌

do{*t++=*s++;

 }while(*s)

这条语句并不能把s所指的字符串正确复制到t所指的存储空间，因为当复制完s所指的最后一个非'\0'字符后，指针s指向了'\0',循环结束，没有将字符串结束符0复制到t中；

 

*type struct S{

int g;

char h;

}T;

T是struct S类型的变量；

 

*退栈一次的意思是从栈中取出一个元素；

 

*仅由顺序、选择（分支）和重复（循环）结构构成的程序是“结构化”程序；

 

*数据库设计的四个阶段是：需求分析，概念设计，逻辑设计和物理设计；

 

*在逻辑判断是“0”表示假，“非0”表示真，而非仅“1”表示真；

 

*如果非得使用指针输出必须要有*p=&a或者p=a；

 

*栈，树，二叉树，队列，只有栈支持子程序调用；

 

*c语言的标示符必须以下划线或英文字母开头（只有这两种情况），其余部分可以由下划线，字母，数字组成；

 

*%8.6表示输出长度为8（包括小数点）的小数点保留到小数点后6位的数；

 

*if（）括号里只能是关系表达式；

 

*#include <stdio.h>

void fun(int *a,int *b){

         int*c;

         c=a;a=b;b=c;

         }

main(){

         intx=3,y=5,*p=&x,*q=&y;

         fun(p,q);

         printf("%d,%d",*p,*q);

         fun(&x,&y);

         printf("%d,%d\n",*p,*q);

}

指针和取地址都没有改变实参；

 

*要通过指针改变对应的值应该加上星号，如果不加则是改变指针所指的内容达不到目的；

 

*#include <stdio.h>

main(){

         char*a[]={"abcd","ef","gh","ijk"};

         inti;

         for(i=0;i<4;i++)

                   printf("%c",*a[i]);

}

printf("%c",*a[i]);这句话的意思是输出字符串数组中4个字符串的首字符；

 

*用指针定义字符串的正确方法：char*s;s="BOOK!";

 

*define语句后面不能跟分号；

 

*printf("%d",++p->x);->比++的优先级高，故先执行->，输出后，在执行++；

 

*注意|和||，&与&&的区别，任何数和1进行“|”运算，都是在原数的基础上加“1”；

 

*基本路径测试属于白盒测试；

 

*数字0和字符0的ASCII码都是48；

 

*void fun(int *a){

         a[0]=a[1];

}

当输入fun(&a[i]),i=2时,fun中为a[2]=a[3]；

 

*当输出为null时，表示未能打开文件或者文件为空；

 

*程序设计的任务包括五部分：1、确定数据结构；2、确定算法；3、编码；4、在计算机上调试程序；5、整理并写出文档资料；

 

*if(a>b)c=a;a=b;b=c;执行c=a;if(a>b){c=a;a=b;b=c;}执行c=a;a=b;b=c;

 

*k=a>b? (b>c? 1:0):0;等价于if((a>b)&&(b>c))k=1;elsek=0;

 

*strlen是计算字符串长度的函数，不包括结束符，结束符也占一个字节，标点符号也是字符；

 

*字符数组除了可以装字符，还可以装其他类型的数据；

 

*程序流程图中的菱形框表示逻辑条件；

 

*设有定义：

struct person{

int ID;char name[12];

}p;

补充scanf("%d",_);使其能读入ID，结果是：&p.ID

 

*scanf("%s",a);printf("%s",a)从键盘输入How areyou?时，只能输出How；

 

*数据类型里面没有逻辑类型，只有布尔类型；

 

*软件是程序、数据和文档的集合；

 

*当以a[][n]的形式初始化的时候，依顺序一一对应赋值；

 

*for（i=0;i<2;i++）;

 for(j+0:j<3;j++);  两个for语句一共执行五次循环。

而：for（i=0;i<2;i++）

    for (j+0:j<3;j++); 两个for语句一共执行六次循环。

关键是第一个for语句后面的分号；

 

*strlen和sizeof的区别是前者是求实际字符串的数量（不包括结束符），后者在初始化数组时，无论数组是否装满，所求结果都是数组大小；

 

*对于case（外）里面的case（内）的break只影响case（内），执行完后，继续执行下一条case（外）；

 

*不能将一个整数直接赋给指针变量作为地址；

 

*对指针变量p进行定义且赋初值的语句float  *p＝&x;

 

*字符串的赋值用strcpy函数；

 

*结构体数组在内存中连续存放；

 

*p->score=(*p).score

 i=*i_pointer=*(&i)

 *与&互为逆运算；

 

*#include<stdio.h>

main()

{

int a=-2,b=0;

while(a++&&++b);

printf("%d,%d",a,b);

}

第一次循环结果为-2&&1,不等于０;

第二次循环结果为-1&&2,不等于０;

第三次循环结果为0&&3,等于０,跳出循环,执行a++;

由于&&运算是只要第一个表达式为０就不再判断第二个表达式,即不执行++b

输出结果：1,2；

#include<stdio.h>

main()

{

int a=-2,b=0;

while(++b&&a++);

printf("%d,%d",a,b)

}

第一次循环结果为1&&-2,不等于０;

第二次循环结果为2&&-1,不等于０;

第三次循环结果为3&&0,等于０,跳出循环;

由于&&运算是只要第一个表达式不为０,首先执行b++,所以b取值3,然后跳出循环,执行a++

输出结果：1,3；

 

* 顺序存储结构的存储一定是连续的，链式存储结构的存储空间不一定是连续的；

 

*在面向对象方法中，不属于"对象"基本特点的是一致性；

 

*单向链表和循环链表判断空表的语句不同；

 

*给结构体中的参数取别名要用typedef，用define会出现错误；

 

*//sqStack *S=newsqStack[];<==>sqStack*s=(sqStack*)malloc(stack_init_size*sizeof(sqStack));

 

*当while语句包含的if语句的判断句是while的非真子集时，while循环停止；

whil((toupper(*fp)==(*rp))&&(fp<rp)){

         ...

         if(fp<rp)//跳出循环

         ...

}

 

*for语句中可以掺杂与i无关的if语句控制循环次数,不过此类条件的个数应较少，一般为一个，否则会使语句杂糅；

for(i=m+1;n<k;i++)

 

*#include <stdio.h>

main(){

         inta;

         floatb;

         charc;

         printf("请输入a的值:");

         scanf("%d",&a);

         printf("请输入b的值:");

         scanf("%f",&b);

         printf("请输入c的值:");

         scanf("空格%c",&c);

         printf("a的值为:%d,b的值为:%f,c的值为:%c\n",a,b,c);

}回车符号也是字符！

 

*二分法最坏比较O（log2n）堆栈法最坏nlog2n冒泡，简单插入，简单选择n(n-1)/2，最坏情况比较次数最少的是堆排法；

 

*八进制以‘零’开始，而非字母‘o’；

 

*x*=x+1等价于x=x*(x+1)；

 

*case后面的常量必须和switch后面表达式类型一致，且case和常量之间不能有空格；

 

*字符串，数组，输入指针的输入不需要&；

 

*错例：char ss[6][7];ss[1]="right"；

 

*全局变量的作用域为由具体定义位置和extern说明决定范围；

 

*int *a,*b,*c;

 a=b=c=(int *)malloc(sizeof(int));

 *a=1;*b=2;*c=3;

 a=b;

 printf("%d,%d,%d\n",*a,*b,*c);

 得3；

 

*支持子函数调用的数据结构是树；

 

*软件测试不包含改错；

 

*c源程序中不能表示二进制；

 

*标示符开头必须是字母/下划线；

 

*c语言中没有< >运算符；

 

*switch语句中不一定要用break，但必须要用default，return可以替代break；

 

*算法的控制结构：顺序结构，选择结构，循环结构；

 

*数据的存储结构有顺序，链接，索引等；

 

*有若干数据元素组成的线性表称为记录，而由多个记录构成的线性表又成为文件；

 

*计算机软件包括程序，数据及相关文档的完整集合；

 

*软件工程3要素：方法，工具，过程；、

 

*软件周期：软件定义，软件开发，运行维护；

 

*软件设计包括：结构设计，数据设计，接口设计，过程设计；

 

*编译预处理和注释不是c语言的一部分，不占运行时间；

 

*每个c语言程序中main函数有且仅有一个；

 

*IF可以作为关键字，if不可以；

 

*0.1写成.1是合法的；

 

*e前e后必有数，e后必定是整数；

 

*%两边一定是整数，否则错误；

 

*int x=y=10;错误

 intx,y;

 x+y=10;x+2=10;正确；

 

*z=(2,3,4),z=4;z=2,3,4,z=2;

 

*'0'-0=48;

 

*【在未舍弃数据的时候】<<左移一位表乘以2，>>表除以2；

 

*int x=17;

 printf("%#o",x)输出017；

 

*%%表示输出一个%

printf("%2d",123);,,,,,,,,,,123

printf("%5d",123);,,,,,,,,,,空格空格123

printf("%10f",1.23);,,,,,,,,1.230000

printf("%%d",123);,,,,,,,,,,%d

printf("%%%d",123);,,,,,,,,,%123

 

*scanf遇空格或回车就结束输入，gets可以处理空格；

 

 

*若if(else/else if)后面无语局却紧跟着另一个if(else/elseif)，则后面的if(else/else if)属于前面的if(else/else if)，除非后面的if(else/else if)的最后有分号；

 

*switch只可以break连用不可以和continue连用；

 

*do-while最后的while()后的分号不能丢；

 

*形参可以没有名，但不能没有类型

 int*fun(*a,*b);正确

 int*fun(*a,*b);正确

 int*fun(*a,*b);正确

 

*根号下|n的x次方+e的x次方|c表达式：sqrt(fabs(pow(n,x)+exp(x)));

 

*int x=2;

 int*p=&x,**q=p;

 *p=7,*q=p,**q=7;

 

*数组名不可以自加，不能赋值，他的地址是常量名

 inta[10];

 a++;错误

 a=a+2;错误

 

*指针中*的含义：

 (1)定义时，*表示改变量为指针变量；

 (2)使用时，*表示取值符；

 

*int a[];a[]={1,2,3}错误；

 

*a[2],a[1+1],a[1/2+3]正确；

 

*a[2]变成*(a+2),a[2][3]变成*(*(a+2)+3);

 

*char a[]={'a','b','c'}字符串长度不定，sizeof(a)为3，数组长度为3；

 chara[5]={'a','b','c'}字符串长度为3，sizeof(a)为5，数组长度为5；

 

*一个文件不一定有main函数，头文件不一定都以.h结束；

 

*static int x默认值为0，而int x默认值为不定值；

 

*static的作用是消除对参数的重新复制；

 

*double类型的数据在输入时，都要以%lf格式输入；

 

*只要调用了函数，哪怕前后一模一样，结果也不一样；

 

*宏替换无类型限制；

 

*有一个以上根节点的数据结构一定不是线性结构，即线性结构有且仅有一个根节点；

 

*c语言程序仅可以编译执行，不能解释执行；

 

*char a[2],*p;p=a;正确

 chara[2][3],*p;p=a;错误；

 

*字符串的赋值不能通过指针来简单赋值，结构体可以进行整体的赋值，哪怕结构体中含有字符串也可以；

 

*有序线性表能进行二分查找的的前提是线性表必须是顺序存储的；

 

*二叉链表属于非线性结构；

 

*在关系数据库中，用来表示实体间联系的是二维表；

 

*选择横向，投影竖向；

 

*边界分析属于黑盒测试；

 

*c语言主要借助定义函数的功能来实现程序的模块化；

 

*c语言不支持用关系运算符比较字符串大小；

 

*strcpy会将字符串末尾的'\0'也拷贝到目标字符串中；

 

*#include <stdio.h>

 inta=1,b=2;

 voidfun1(int a,int b){

        printf("%d%d",a,b);

 }

 voidfun2(){

        a=3;b=4;//此处为赋值而非定义，本质为全局变量的重新赋值；

 }

 main(){

        fun1(5,6);fun2();

         printf("%d%d\n",a,b);

 }得5,6,3,4

 

*不能直接把一个字符串赋值到二维数组中的某一行；

 

*求循环队列中的元素：(rear-front+maxsize)%maxsize；

 

*fopen(文件名，打开方式)若打开的方法为w+表示清空后重新赋值；

 

*数组指针用for循环可以省略for语句中的第一个条件；

 

*用函数返回结果即用return语句返回，用形参返回即用指针*返回；

 

*程序流程图中带箭头的线段表示的是控制流；

 

*将E-R图转换成关系数据模型的过程属于逻辑设计阶段；

 

*有以下程序：

#include <stdio.h>

main()

{　 int  a＝0，b＝0，c＝0，d＝0；

　　if(a＝1)  b＝1；c＝2；

　　else    d＝3；

　　printf("%d，%d，%d，%d\n"，a，b，c，d)；

}

程序输出(　　)。

A) 1,1,2,0

B) 0,0,0,3

C)  编译有错

D) 0,1,2,0

    参考答案：C

【解析】本题中if(a＝1)b＝1；与else d＝3；之间多了语句c＝2；所以会出现else语句的位置错误的编译失败提示。

 

*当被调用函数实在找不到错误的时候，可以考虑一下返回的值的类型；

 

*当用指针返回值或数组时，被调用函数返回的值可以认为void；

 

*用函指针指向的函数，并进行调用

 double fun1(){

 ......

 }

 main(){

 ......

 double r1;

 f=f1;

 r1=f(a);

 ......

 }

 

*在结构体中，经常用到指针，所以while循环的条件一般都是p!=0,而不是*p!=0;

 

*将两个返回值变成一个返回值的方法

 intfg=1;

 if(str[i]==str[n-i-1]);

         else{

                   fg=0;

                   break;

         }

         returnfg;

 

*如果if语句语句后出现了return和break，则表示该if语句结束

 if(str[i]==str[n-i-1])

  return 1;

 else

  return 0;

 以上程序会报错：else没有匹配的if因为，在return之后，if就结束了，而后面 的else则没有与之对应的if；

 

* 不可以给指针变量赋一个整数作为地址值；

 

*数据流图中带有箭头的线段表示的是数据流；

 

*以下语句中存在语法错误的是(　　)。

A) char  ss[6][20]；  ss[1]＝ "right？"；

B) char  ss()[20]＝{"right？"}；

C) char  *ss[6]；  ss[1]＝ "right？"；

D) char  *ss()＝{"right？"}；

    参考答案：A

 

*有以下程序：

#include <stdio.h>

void swap(char  *x， char  *y)

{ char t；

t＝*x；  *x＝*y；  *y＝t；

}

main()

{ char *s1＝"abc"， *s2＝"123"；

 swap(s1，s2)；  printf("%s，%s\n"，s1，s2)；

}

程序执行后的输出结果是(　　)。

A) 321，cba

B) abc,123

C) 123，abc

D) 1bc，a23

    参考答案：D

【解析】字符串是一个特殊的数组，所以按照数组的规则，s1应该指向的是数组的首地址，即"abc"的第一个字符的地址。s2指向的是"123"的第一个字符的地址。调用swap函数之后交换的是两个字符串的第一个字符'a'和'1'的内容，所以打印输出为D)。

 

【解析】数组定义后，不可以对数组整体赋值， s是二维数组，因ss[1]是一维字符数组，即字符串，字符串赋值可以使用strcpy(ss[1]，"right")；这样的形式，而选项A)中对二维数组中的第"1"维(相当于一个一维数组)赋值，是不可以的。选项B)和D)是定义时对数组初始化，这是可以的。选项C)中，将字符串在内存中的首地址赋给指针数组的一个元素，这是可以的。关键是A中的分号；

 

 

* int x[2][3]＝{{1,2}，{3,4}，{5,6}}；是错的；

 

*设有定义：char  p[]＝{'1'， '2'， '3'}，*q＝p； ，以下不能计算出一个char型数据所占字节数的表达式是(　　)。

A) sizeof(p)

B) sizeof(char)

 

C) sizeof(*q)

D) sizeof(p[0])

    参考答案：A

【解析】根据题目中的定义可以知道sizeof(p)，计算的是数组p中所有元素所占用的字节数，而不是char型数据所占字节数。

 

*下面结构体的定义语句中，错误的是(　　)。

A) struct  ord  {int  x；int  y；int  z；} struct  ord  a；

B) struct  ord  {int  x；int  y；int  z；}； struct  ord  a；

C) struct  ord  {int  x；int  y；int  z；} a；

D) struct  {int  x；int  y；int  z；}  a；

    参考答案：A

【解析】A)选项struct  ord  {int  x；int  y；int  z；} struct  ord  a；错误，不能在定义结构体的同时，又用结构体类型名定义变量。应该写成B)选项或者D)选项的格式。

 

*预处理不一定都以#开头；

 

*fread(buffer，size，count，fp)；，其中buffer代表的是 一个内存块的首地址，代表读入数据存放的地址；

 

*逗号表示并列

.设有定义：int  x＝2；，以下表达式中，值不为6的是(　A　)。

A) 2*x,x+=2

B)  x＋＋，2*x

C) x*＝(1＋x)

D) x*＝x＋1

A的结果为4,4；

 

*以下不能将s所指字符串正确复制到t所指存储空间的是(　　)

A) do{*t＋＋＝*s＋＋；}while(*s )；

B) for(i＝0；t[i]＝s[i]；i＋＋)；

C) while(*t＝*s){t＋＋；s＋＋} 

D) for(i＝0，j＝0；t[i＋＋]＝s[j＋＋]； )；

    参考答案：A

【解析】do{*t＋＋＝*s＋＋；}while(*s)；不能因为当*s＝'\0'时，while(*s)跳出循环，这样字符串结束标志'\0'没有复制给*t，造成*t不完整。注意，*t＋＋＝*s＋＋是先执行t＝*s，然后才进行t＝t＋1，s＝s＋1。B)，C)，D)都能将'\0'复制过去。    

 

*有以下程序段：

 #include   <stdio.h>

 int   j；      float  y；      char   name[50]；

 scanf("%2d%f%s"， &j， &y， name)；

当执行上述程序段，从键盘上输入55566  7777abc 后，y的值为(　　)。

A) 566.0

B) 55566.0

C) 7777.0

D) 566777.0

    参考答案：A

【解析】它是格式输入函数，即按用户指定的格式从键盘上把数据输入到指定的变量之中。其中的格式命令可以说明最大域宽。在百分号(%)与格式码之间的整数用于限制从对应域读入的最大字符数。所以j的值为55，y的值为566.0，字符数组name为7777abc。

 

*char *s,s="Olympic";正确char*s,s={"Olympic"};错误

 chara[]="Olympic";正确char a[]={"Olympic"};正确

 chara[7]="Olympic";错误char a[7]={"Olympic"}错误；

 

*有以下函数：

int fun(char  *s)

{ char *t＝s；

 while(*t＋＋)；

 return(t－s)；

}

该函数的功能是(　　)

A)  计算s所指字符串的长度

B)  比较两个字符串的大小

C)   计算s所指字符串占用内存字节的个数

D)   将s所指字符串复制到字符串t中

    参考答案：C

【解析】首先 char *s 接受一个字符型数组的首地址并将这个首地址赋给另一个字符型指针 char*t ， while(*t＋＋)不断循环直到 *t 为'\0'，再将 t－1 ，这时字符指针 t 指向字符串的最后一个字符，又因为 s 指向字符数组的首地址即字符串的首地址所以 return(t－s) 便是返回字符数组中字符串的长度。

 

*设有如下函数定义：

#include <stdio.h>

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)  2

B)  3

C)  4

D)  5

    参考答案：B

【解析】首先 n＝fun(3),3被当作参数传递进去，这就进行了一次调用，3被当做参数传进去后，程序会执行这句 else return fun(k－1)＋1；这就调用了第二次，而参数是3－1也就是2。2被当做参数传进去后，程序会执行这句 else return fun(k－1)＋1；这就调用了第三次，而参数是2－1也就是1。1被当做参数传进去后，程序会执行这句 else if(k＝＝1) return 1；不再递归调用，所以最终结果为3次。

 

*设有定义：

struct complex

{　int real，unreal；} data1＝{1,8}，data2；

则以下赋值语句中错误的是(　　)。

A) data2＝(2,6)；

B) data2＝data1；

C) data2.real＝data1.real；

D) data2.real＝data1.unreal；

 

    参考答案：A

【解析】A)选项中可以在声明变量的同事为data2赋值，但是 data2＝(2,6)；应写作data2＝{2,6}。所以选择A)。

 

*栈支持子程序调用。

 

*有以下程序(注：字符a的ASCII码值为97) ：

#include  <stdio.h>

main()

{　 char  *s ＝{ "abc" }；

　　do

　　{　printf ("%d"， *s%10)；＋＋s；  }

　　while ( *s )；

}

程序运行后的输出结果是(　　)。

A) 789

B) abc

C)  7890

D) 979899

    参考答案：A

【解析】         因为小写字符a，b，c的ASCII的值分别为97,98,99，而在do while循环语句中，每次对字符的ASCII的值取余数并输出，所以分别输出7,8,9。

 

*设有定义：

struct complex

{　int real，unreal；} data1＝{1,8}，data2；

则以下赋值语句中错误的是(　　)。

A) data2＝(2,6)；

B) data2＝data1；

C) data2.real＝data1.real；

D)  data2.real＝data1.unreal；

 

    参考答案：A

【解析】A)选项中可以在声明变量的同事为data2赋值，但是 data2＝(2,6)；应写作data2＝{2,6}。所以选择A)。

 

*有以下程序：

#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)。

A)  9

B)  8

C)  7

D) 10

【解析】题目中静态局部变量a，在静态存储区内分配存储单元，在程序整个运行期间都不释放。所以第一次调用函数执行n＋＝a＋＋；时a先与n相加在再进行自增。n的值为4，a的值为2，且a变量执行完后空间没有释放。再执行 s＝s＋f(a)时，s的值为4，调用f(a)函数时n的返回值为 n＝3＋2＝5，且此时a的值为3了。所以s的值为9。

 

*下列选项中不属于结构化程序设计原则的是(A)。

A)  可封装

B)  自顶向下

C)  模块化

D)  逐步求精

    参考答案：A

【解析】结构化程序设计的思想包括：自顶向下、逐步求精、模块化、限制使用goto语句，所以选择A)。

 

*在E－R图中，用来表示实体联系的图形是(　　)。

A)  椭圆形

B)  矩形

C)  菱形

D)  三角形

    参考答案：C

【解析】在E－R图中实体集用矩形，属性用椭圆，联系用菱形。

 

*以下定义语句中正确的是(　　)。

A) int a＝b＝0；

B) char A＝65＋1，b＝′b′；

C) float a＝1，*b＝&a，*c＝&b；

 

*有以下程序：

point(char *p){p＋＝3；}

main(){char a[4]＝{'1'，'2'，'3'，'4'}，*p＝a；

point(p)；

printf("%c\n"，*p)；

}

程序运行后的输出结果是(　　)。

A)  1

B)  2

C)  3

D)  4

    参考答案：A

【解析】在函数point函数调用时，系统自动为函数的形参p分配内存空间，并赋值为实参p的值。当执行语句p＋＝3；时，系统操作的是形参p的内存空间，更改形参p的内容，而实参指针变量p的值未受影响，即指针变量作为函数参数时，不能更改实参指针变量的指向。故在printf("%c\n"，*p)；语句中，p仍然指向字符数组的首元素。

 

*设有以下函数：

void fun(int n，char *s){ …… }

则下面对函数指针的定义和赋值均正确的是(　　)。

A) void (*pf)()； pf＝fun；

B) void *pf()；  pf＝fun；

C) void *pf()；  *pf＝fun；

D) void(*pf)(int，char)； pf＝&fun；

    参考答案：A

【解析】函数指针的定义形式是：数据类型标识符(*指针变量名)()。void(*pf)()定义了一个没有返回值的函数指针pf，在给函数指针变量赋值时，只需给出函数名而不必给出参数。所以给pf赋值时，只把函数名fun赋给pf即可。所以正确答案为选项A)。

 

 

 

*有定义语句：char s[10]；，若要从终端给s输入5个字符，错误的输入语句是(　　)。

A) gets(&s[0])；

B) scanf("%s"，s[1])；

C) gets(s)；

D) scanf("%s"，s＋1)；

    参考答案：B

【解析】在格式输入中，要求给出的是变量的地址，而B)答案中给出的s[1]是一个值的表达式。

 

D) double a＝0.0；b＝1.1

    参考答案：B

【解析】本题考查变量的定义方法。如果要一次进行多个变量的定义，则在它们之间要用逗号隔开。因此选项A)和D)错误；在选项C)中，变量c是一个浮点型指针，它只能指向一个浮点型数据，不能指向指针变量b；所以正确答案为B)。

 

*有以下程序：

#include <stdio.h>

#include <string.h>

main(){ char a[10]＝"abcd"；

printf("%d，%d\n"，strlen(a)，sizeof(a))；

}

程序运行后的输出结果是(　　)。

A) 7,4

B) 4,10

C) 8,8

D) 10,10

    参考答案：B

【解析】strlen()用来返回字符串的长度，而sizeof()返回的是一个对象或者类型所占的内存字节数，即数组所占的内存。

 

*以下程序的运行结果是(　　)。

#include <stdio.h>

int a＝1；

int f(int c){ static int a＝2；

c＝c＋1；

return(a＋＋)＋c；}

main(){ int i，k＝0；

for(i＝0；i<2；i＋＋){int a＝3；k＋＝f(a)；}

k＋＝a；

printf("%d\n"，k)；

}

A) 17 

B) 16

C) 15

D) 14

    参考答案：D

【解析】fun函数语句return(a＋＋)＋c；中访问的a，是其内部定义的静态局部变量，main函数中语句k＋＝f(a)访问的a是其局部变量，所以两次调用实际上都是调用f(3)。第一次调用时，fun函数中c＝4，表达式(a＋＋)＋c的值为6，a递增为3，k＝6。第二次调用时，fun函数中c＝4，表达式(a＋＋)＋c的值为7，a递增为4，k＝6＋7＝13。语句k＋＝a中的a是全局变量，所以k＝13＋1＝14。

 

*有以下程序：

#include <stdio.h>

#include <string.h>

typedef struct{ char name[9]； char sex； floatscore[2]； }STU；

void f(STU a)

{　STU b＝{"Zhao"，'m'，85.0,90.0}； int i；

strcpy(a.name，b.name)；

a.sex＝b.sex；

for(i＝0；i<2；i＋＋)a.score[i]＝b.score[i]；

}

main()

{　STU c＝{"Qian"，' f '，95.0,92.0}；

f(c)；

printf("%s，%c，%2.0f，%2.0f\n"，c.name，c.sex，c.score[0]，c.score[1])；

}

程序的运行结果是(　　)。

A) Qian，f,95,92

B) Qian，m,85,90

C) Zhao，f,95,92

D) Zhao，m,85,90

    参考答案：A

【解析】本题考查的是函数调用时的参数传递以及结构体变量的引用的问题。程序在调用函数f时，传给函数f的参数只是结构变量c在栈中的一个拷贝，函数f的所有操作只是针对这个数据拷贝进行的修改，这些都不会影响变量c的值。

 

*设有以下说明语句：

struct ex

      { int x ； float y； char z ；} example；

则下面的叙述中不正确的是(　　)。

A) struct结构体类型的关键字

B) example是结构体类型名

C)  x，y，z都是结构体成员名

D) struct ex是结构体类型名

    参考答案：B

【解析】本题中，struct ex是结构体类型名，example是结构体变量名。

 

*下列叙述中正确的是(　　)。

A)  线性表的链式存储结构与顺序存储结构所需要的存储空间是相同的

B)  线性表的链式存储结构所需要的存储空间一般要多于顺序存储结构

C)  线性表的链式存储结构所需要的存储空间一般要少于顺序存储结构

D)  线性表的链式存储结构与顺序存储结构在存储空间的需求上没有可比性

    参考答案：B

【解析】线性链式存储结构中每个结点都由数据域与指针域两部分组成，增加了存储空间，所以一般要多于顺序存储结构。

 

*软件测试的目的是(　　)。

A)  评估软件可靠性

B)  发现并改正程序中的错误

C)  改正程序中的错误

D)  发现程序中的错误

    参考答案：D

【解析】软件测试是为了发现错误而执行程序的过程，测试要以查找错误为中心，而不是为了演示软件的正确功能。不是为了评估软件或改正错误。

 

*以下选项中值为1的表达式是(　　)。

A)  

B)  

C)  

D)  

    参考答案：B

【解析】字符常量0的值是48，1的值是49，\0的值是0。所以1－0＝－47,1－\0＝1，1－0＝49，\0－0＝－48。

 

*设变量均已正确定义，若要通过scanf("%d%c%d%c"，&a1，&c1，&a2，&c2)；语句为变量a1和a2赋数值10和20，为变量c1和c2赋字符X和Y。以下所示的输入形式中正确的是(注：□代表空格字符)(　　)。

A) 10□X□20□Y<回车>

B) 10□X20□Y<回车>

C) 10□X<回车>

20□Y<回车>

D) 10X<回车>

20Y<回车>

    参考答案：D

【解析】本题中，scanf函数的格式控制没有空格，所以，对于选项A)、B)、C)，输入的第一个空格会作为字符赋值给变量c1，而不会被解释成分隔符。

 

*有以下程序：

#include <stdio.h>

void fun(int a，int b){ intt；

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＋1])；

for(i＝0；i<10；i＋＋)printf("%d，"，c[i])；

printf("\n")；

}

程序的运行结果是(　　)。

A) 1,2,3,4,5,6,7,8,9,0，

B) 2,1,4,3,6,5,8,7,0,9，

C) 0,9,8,7,6,5,4,3,2,1，

D) 0,1,2,3,4,5,6,7,8,9，

    参考答案：A

【解析】在C语言中函数参数的传递是"传值"的，即形参和实参是两个没有关系的变量，函数fun虽然看似交换了参数值，但是只交换了形参的值，其结果不会传递给实参，因此数组C没有变化。主函数中给数组C元素赋值1,2，…，9,0。第一个for循环语句中调用fun函数，该函数功能是交换变量的数值，注意循环变量i的增量。第二个for循环语句将数组C中元素的值进行输出。

 

*有以下程序：

#include<stdio.h>

struct ord

{　int x，y；}dt[2]＝{11,12,13,14}；

main(){

struct ord*p＝dt；

printf("%d，"，＋＋(p－>x))；printf("%d\n"，＋＋(p－>y))；

}

程序运行后的输出结果是(　　)。

A) 11,12

B) 12,13

C) 13,14

D) 14,1l

    参考答案：B

【解析】本题中定义了一个结构体数组dt[2]，其中dt[0].x＝11，dt[0].y＝12，dt[1].x＝13，dt[1].y＝14。在main函数中指针p指向了结构体数组的第一个元素，因此p－>x值为11，p－>y值为12，自加运算的结果分别为12和13

 

*有以下程序：

int fun1(double a){return (int)(a*＝a)；}

int fun2(double x，double y)

{double a＝0，b＝0；

a＝fun1(x)；b＝fun1(y)；return(int)(a＋b)；

}

main()

{double w；w＝fun2(1.1,2.0)；…}

程序执行后变量w中的值是(　　)。

A) 5.21

B)  5

C) 5.0

D) 0.0

    参考答案：C

【解析】题中变量w的定义为double型，函数fun2()的定义为int型，按照各类数值型数据间的混合运算，整型数据被转换为实型数据。

 

*下列叙述中正确的是(　　)。

A)  有一个以上根结点的数据结构不一定是非线性结构

B)  只有一个根结点的数据结构不一定是线性结构

C)  循环链表是非线性结构

D)  双向链表是非线性结构

    参考答案：B

【解析】线性结构应满足：有且只有一个根结点与每个结点最多有一个前件，也最多有一个后件，所以B)正确。所以有一个以上根结点的数据结构一定是非线性结构，所以A)错误。循环链表和双向链表都是线性结构的数据结构。

 

*下列关于数据库设计的叙述中，正确的是(　　)。

A)  在需求分析阶段建立数据字典

B)  在概念设计阶段建立数据字典

C)  在逻辑设计阶段建立数据字典

D)  在物理设计阶段建立数据字典

    参考答案：A

【解析】数据字典是在需求分析阶段建立，在数据库设计过程中不断修改、充实和完善的。

 

*有三个关系R、S和T如下：

则由关系R和S得到关系T的操作是(　　)。

 

A)  自然连接

B)  并

C)  交

D)  差

    参考答案：A

【解析】自然连接是一种特殊的等值连接，它要求两个关系中进行比较的分量必须是相同的属性组，并且在结果中把重复的属性列去掉，所以根据T中元组可以判断R和S做的是自然连接操作。

 

*有以下程序：

void f(int *q){ int i＝0；

for( ；i<5；i＋＋)(*q)＋＋；

}

main(){ int a[5]＝{1,2,3,4,5}，i；

f(a)；

for(i＝0；i<5；i＋＋)printf("%d，"，a[i])；

}

程序运行后的输出结果是(　　)。

A) 2,2,3,4,5，

B) 6,2,3,4,5，

C) 1,2,3,4,5，

D)  2,3,4,5,6，

    参考答案：B

【解析】本题考查的是指针作为函数的参数和函数的调用。题目中定义了一个指针变量作为函数f()的形参。主函数main()中调用f()函数，当i＝0时，执行语句(*q)＋＋，此处*q代表的就是数组元素a[0]的值，即将1进行加1操作；当i＝1时，q仍指向数组元素a[0]的地址，因为在函数f()中并未对指针变量q作任何变动，也即*q仍代表了数组元素a[0]的值，所以此次(*q)＋＋即2＋1，所以a[0]的值变为3；……直到i＝4时，执行(*q)＋＋(即5＋1)后a[0]的值变为6。所以最后的输出结果为：6,2,3,4,5，。

 

*有以下程序：

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) 45

B) 50

C) 60

D) 55

    参考答案：C

【解析】内部静态变量是始终存在的，当函数被调用退出后，内部静态变量会保存数据，再次调用该函数时，以前调用时的数值仍然保留着。Fun(a,5)的值是15，再次调用后sum＝15，所以Fun(b,4)＝45，s＝45＋15＝60。

 

*下列关于线性链表的叙述中，正确的是(　　)。

A)  各数据结点的存储空间可以不连续，但它们的存储顺序与逻辑顺序必须一致

B)  各数据结点的存储顺序与逻辑顺序可以不一致，但它们的存储空间必须连续

C)  进行插入与删除时，不需要移动表中的元素

D)  以上说法均不正确

    参考答案：C

【解析】一般来说，在线性表的链式存储结构中，各数据结点的存储序号是不连续的，并且各结点在存储空间中的位置关系与逻辑关系也不一致。线性链表中数据的插入和删除都不需要移动表中的元素，只需改变结点的指针域即可。

 

*在下列模式中，能够给出数据库物理存储结构与物理存取方法的是(　　)。

A)  外模式

B)  内模式

C)  概念模式

D)  逻辑模式

    参考答案：B

【解析】数据库系统的三级模式是概念模式、外模式和内模式。概念模式是数据库系统中全局数据逻辑结构的描述，是全体用户公共数据视图。外模式也称子模式或用户模式，它是用户的数据视图，给出了每个用户的局部数据描述。内模式又称物理模式，它给出了数据库物理存储结构与物理存取方法，所以选择B)。

 

*以下程序的输出结果是(　　)。

main()

{　

int a＝20；

printf("%d，%o，%x\n"，a，a，a)；

}

A) 20， 024,0x14

B) 20， 24,14

C) 20， 0x14,024

D) 20， 20,20

    参考答案：B

【解析】本题的考查点是不同格式的数据输出。printf函数对不同类型的数据用不同的格式字符，"%d"是以带符号的十进制形式输出整数(正数不输出符号)；"%o"以八进制无符号形式输出整数(不包括前导符0)；"%x"以十六进制无符号形式输出整数(不包括前导符0x)。

 

*下面程序的运行结果是(　　)

main()

{

int y＝5， x＝14； y＝((x＝3*y,x+6),x-1);

printf("x=%d,y=%d",x,y);

}

A)  x＝27，y＝27

B)  x＝12，y＝13

C)  x＝15，y＝14

D)  x＝y＝27

    参考答案：C

【解析】本题考查的是逗号表达式。逗号表达式的求解步骤是先求解表达式1，然后依次求解表达式2，直到表达式N的值。整个逗号表达式的值就是最后一个表达式N的值。表达式(x＝3*y,x+6)中，x=15。表达式y=x-1=14。

 

*请阅读以下程序：

#include<stdio.h>

main()

{ int x＝1，y＝0，a＝0，b＝0；

switch(x)

{　case 1：

　 switch(y)

{　case 0：a＋＋；break； }

　　 case 2：

　　 a＋＋，b＋＋；break； }

　printf(" a＝%d，b＝%d\n"，a，b)；

}

上面程序的输出结果是(　　)。

A)  a＝2，b＝1

B)  a＝1，b＝1

C)  a＝1，b＝0

D)  a＝2，b＝2

    参考答案：A

【解析】考查switch语句的使用。switch语句的执行过程为：进入switch结构后，对条件表达式进行运算，然后从上至下去找与条件表达式值相匹配的case，以此作为入口，执行switch结构中后面的各语句，直到遇到break语句，则跳出switch语句，如果各case都不匹配时，则执行default后面的语句。

 

*若有以下说明和语句，请选出哪个是对c数组元素的正确引用(　　)。

int c[4][5]，(*cp)[5]；

cp＝c；

A) cp＋1

B) *(cp ＋3)

C) *(cp ＋1)＋3

D) *(* cp＋2)

    参考答案：D

【解析】本题的考查点是数组元素的引用。cp＝c这个语句是将数组c的首行元素地址赋给了指针数组cp。选项A)，cp＋1是指将数组c的首行地址加1，即为第二行地址；选项B)，*(cp＋3)是地址，等于数组c的首地址加3的那个内存单元的内容，不是对数组元素的引用；选项C)，*(cp＋1)＋3是地址，等于数组c的首地址加1的那个内存单元中存放的值加3，不是对数组元素的引用。

 

*当用"#define F37.5f"定义后，下列叙述正确的是(　　)。

A)  F是float型数

B)  F是char型数

C)  F无类型

D)  F是字符串

    参考答案：D

【解析】字符替换定义格式为：#define 标识符(形参表)形参表达式。题中F是代表形参表达式的标识符(字符串)。

 

*有以下程序段：

typedef struct NODE

{int num； struct NODE *next；

}OLD；

以下叙述中正确的是(　　)。

A)  以上的说明形式非法

B) NODE 是一个结构体类型

C) OLD 是一个结构体类型

D) OLD 是一个结构体变量

    参考答案：C

【解析】本题考查的是结构体的定义。typedef关键字用于声明一个新的类型名代替已有的类型名。本题中如果没有用typedef进行定义，则struct NODE为结构体类型，现在用typedef定义后，相当于用OLD代表了struct NODE这一结构体类型，故OLD为结构体类型。

 

*有以下程序：

struct STU

{ char name[10]； int num； floatTotalScore； }；

void f(struct STU *p){ struct STU s[2]＝{{"SunDan",20044,550}，{"Penghua",20045,537}}，*q＝s；

＋＋p；＋＋q； *p＝*q；

}

main(){ struct STU s[3]＝{{"YangSan",20041,703}，{"LiSiGuo",20042,580}}；

f(s)；

printf("%s %d %3.0f\n"，s[1].name， s[1].num，s[1].TotalScore)；

}

程序运行后的输出结果是(　　)。

A) SunDan 20044 550

B) Penghua 20045 537

C) LiSiGuo 20042 580

D) SunDan 20041 703

    参考答案：B

【解析】本题考查的是结构体。本程序将结构体数组s的首地址传递给了结构体指针变量p，并在函数f中改变了指针变量p所指向的第二个结构体中的成员变量，这一改变，也就是改变了主函数中s[1]的成员变量，故程序输出的值为Penghua  20045  537。

 

*若有以下说明和语句，则下列引用方式中不正确的（D）

struct worker{

         intno;

         char*name;

}work,*p=&work;

(A)work.no      (B)(*p).no      (C)p->no      (D)work->no

不能用结构体名指向。