在C语言中，_____存储类型的变量，只在使用时才分配空间。

在 C 语言中，自动存储类型的变量只在使用时才分配空间，因此选项 D `auto` 和 `register` 是正确的答案。

`auto` 存储类型是 C 语言中的默认存储类型，通常用于描述函数内部定义的局部变量。这些变量在定义时不会被初始化，而是在函数执行到定义语句时才会分配存储空间，并且在函数执行完毕后自动释放所占用的空间。

`register` 存储类型用于告诉编译器将变量存储在寄存器中，以提高访问速度。由于寄存器数量有限，因此只有部分变量可以存储在寄存器中。同时，变量的地址也无法取得，即不能对其进行取地址 *** 作。

`static` 存储类型用于描述静态变量，这些变量在程序编译时就已经分配了固定的存储空间，并且在整个程序执行期间都存在。与自动存储类型相比，静态变量具有更长的生命周期和更广泛的作用域，可以跨越多个函数使用。

`extern` 存储类型用于描述外部变量，这些变量在其他文件中定义，并且需要通过 `extern` 关键字声明后才能在当前文件中使用。

一、基础知识和数据类型、表达式

1、｛｝，［］，（），‘’，“”不配对。解决这个问题最好的方法就是每当写这些符号的时候就先写成一对，然后再在中间加内容。

2、忘记在语句的末尾加分号，或在预处理命令后多加分号。记住：每一个语句的后边都要加分号，而预处理命令并不是语句，所以不加分号，他们必须每行一条，不能把多个命令写在一行。

3、混淆/和\；注释对应的符号是/ /,而转义字符是以\开头，除号是/。

4、printf()和scanf()的参数设置有误，主要表现在以下几方面：

l 类型不匹配的问题。（例如：有float a=35,但输出的时候printf(“a=%d”,a);则屏幕上会显示出a=000000或者提示其它运行错误）。基本原则是：float对应%f, int对应%d, char对应%c。

l 个数不匹配。无论是哪个函数，都可以有n个参数，第一个永远是“”括起来的内容，表示输出格式。剩下的n-1个是输出的变量或者输入的变量的地址。需要注意的是，如果后边有n-1个参数，那么前边一定对应n-1个%f一类的格式说明符。

l scanf()中变量前忘了加＆。记住：scanf()中变量前要有＆(但后边学到的字符数组名和指针前不用加)

5、定义标识符的时候经常出现使用非法字符的情况，例如：标识符中不能用空格，也就是说不能有这样的定义：int radium of circle;一般情况下可用下划线将三个单词连接在一起。

6、在使用变量前未定义，或未初始化。例如：若下边的sum未定义，则在编译时会提示相应的错误信息，而若未初始化为0，则求和的结果一定是错误的。

　void main()

{ int I,a[10], sum=0; /只要下边要用，这个定义就必须要有，一般情况下也要有初始值/

for(I=0;I<10;I++) sum+=a[I];

printf(“%d”,sum);

}

7、计算错误。主要注意：＋＋，――和其它运算符一起运算时，除根据优先级进行计算时，还要考虑先后位置的特殊含义；数据类型不一致时发生的自动转换也会导致计算的误差；还要注意求模结果的符号与被除数相同；某些特殊情况下　使用懒惰求值法。

8、不能除以0，要做合法性检查；

9、类型溢出。记住每种数据类型的取值范围，确保数据在所定义类型范围之内；

10、数学表达式的格式有误。常见的有：（1）数学与C语言运算表达式的混淆（例如：＝表示赋值，而= =才表示我们数学中的相等关系）。（2）、忽略了运算的优先级。解决这个问题的最好方法就是写数学表达式时不要从左到右，而是按优先级的顺序写，写完优先级高的一个表达式后加上（）再写下一级的表达式，例如：计算梯形的面积时，要s=((a+b)h)/2，不要1/2a+bh (3)忽略了计算和赋值时的自动转换。例如：float half=1/2;这样，因为＝右边是整数相除的结果为整数0，不会得到05存入half，进而会影响下边的计算结果。要想不在这儿绊跟头，当计算不同类型的数据时，一定注意会不会出现引起错误的自动转换，建议最好加上强制转换。（4）赋值号左边不是变量，例如：若有#define PI 314，程序中又出现PI=314159。又例如：f(n)=f(n-1)n（这是典型的数学语言，在C语言中右边的乘积不能正确存储，而左边又是一个函数调用）。

11、使用库函数前忘了加#include<h>

二、流程控制

1、 丢掉语句结束标记“；”，尤其是for语句中表达式后或do-while语句后的分号，或在预处理命令后边、while()后、for()后加“；”；

2、 If语句或循环语句中逻辑表达式或关系表达式书写错误。一定要注意C语言的条件与数学表达式的区别（例如我们数学中经常写到的0≤x≤9,在C语言中应该写成x>=0&&x<=9）。

3、 if-else嵌套时不配对。最好在写每个条件时要用两个｛｝分别将两个分支先括起来，再添加其中的语句，以保证其配对不易错。

4、 switch()语句中的格式不正确。（）中的表达式结果一定是一些明确的值，不能是区间；表达式的所有可能结果要列在case后边，case与常量之间有一空格，不要丢掉必要的break;

5、 随意修改循环控制变量i的值，导致循环次数的改变，尤其是当循环有嵌套时。在循环体中，不要将循环控制变量进行另外的改变。

6、 分不清什么情况下用双重循环，什么情况下用两个控制变量写成一重循环。当I不变，j又循环一遍的时候用双重循环。当I,j同时变化的时候用一重循环，此时，循环控制变量有两个，但条件只写一个就可以，因为另一个总是进行相应的变化的。

7、 忽略循环体与循环控制变量的关系。其实，很多情况下，循环控制变量都在循环体中起到非常重要的作用。应该利用上这种关系。

三、数组与指针

1、 字符串的输入有错误：主要表现在使用scanf()或gets()时加了＆,或输入字符串时用循环，（这样的话，字符个数无论多长，都不会为自动加\0，将来引用的时候也就不能以字符串的形式引用。）

2、 对字符串的处理中，循环条件仍然写成I<N。由于字符串是不定长的，所以循环条件一般为str[I]!=’\0’ 或I<strlen(str)

3、 而输入所对应的变量是指针时（常见的有：输入的变量是字符数组名或指向字符串的指针）不能加＆。

4、 指针定义后未赋值就引用。如果在定义时不知道赋什么值，可以用p=NULL赋初值，以避免引起的灾难性错误。

5、 分不清p和＊p。前者是指针，即地址，后者表示指针所间接引用的数据，但如果是二级指针或多级指针，取以后得到的仍然可能是地址。

四、函数

1、 函数定义的时候，函数头部加分号，而函数声明的地方忘了加分号

2、 函数实参格式不对，主要表现在：给出实参时，多给出数组类型，或者，形参是数组int a[];的时候，给出的a[]或a[I]

3、 递归时忘了设置边界条件，这样易造成死循环调用。

4、使用函数之前未声明（包括C库函数的声明）。建议大家，将所定义的一切函数都在程序开始的预处理命令后加上函数原型的声明，这样做不仅可以避免错误，而且整个程序的结构看起来更清楚。

五、结构体共用体

1、 结构体类型定义有误，主要表现在：结构体类型里还有嵌套的时候，忘记了成员名称。（例如：下边的例子中，有些同学经常忽略了birthday）

2、 结构体类型名和结构体变量名混淆。例如：

struct STU

{…

Struct data

{int year,month,day;<br/><br/>}birthday

};

struct STU a; struct STU是类型名称，而且不分配空间，且不能直接引用。只有定义了结构体类型struct STU的变量a以后，才为a分配相应的内存空间，引用时也要是a

3、 结构体变量的成员引用不正确，尤其是当结构体类型中有嵌套定义的时候。一定要一级一级的引用。例如：上边的例子：如果引用其中的年的话，一定是abirthdayyear　不能直接ayear

4、 对结构体变量进行输入输出的时候，整体输入或整体输出。除作为函数参数外，不能对结构体变量整体 *** 作，只能一个成员一个成员地输入、输出。

5、 不理解共用体的“共占内存”。对共用体中的成员变量，一定要靠一个标记区别它们，并分别按不同类型引用它们。切记：共用体变量不能做函数形参。

六、文件

1、 使用之前没有打开文件，使用之后没有关闭文件。

2、 相关函数的调用格式有误。请一定注意实参的类型、顺序、个数上与函数原型（或函数声明）的一致。

在c语言中，程序运行期间，其值可以改变的量叫做变量。

当在窗体中设计用户界面时，c语言会自动为产生的对象（包括窗体本身）创建一组变量，即属性变量，并为每个变量设置其缺省值。这类变量可供用户直接使用，比如引用它或给它赋新值。用户也可以创建自己的变量，以便存放程序执行过程中的临时数据或结果数据等等。

扩展资料：

变量的作用域由声明它的位置决定。如果在过程中声明变量，则只有该过程中的代码可以访问或更改变量值，此时变量具有局部作用域并被称为过程级变量。如果在过程之外声明变量，则该变量可以被Script中所有过程所识别，称为Script级变量，具有Script级作用域。

变量可以保存程序运行时用户输入的数据、特定运算的结果以及要在窗体上显示的一段数据等。变量声明后没有赋值的话，编译器会自动提示并赋予默认值。

程序首先定义了一个名为 struct S 的结构体类型，包含一个整形变量n，一个整形数组，整形变量可用来标记数组的长度。

然后定义了一个名为 f 的函数，该函数定义了一个指针p作为形参，指针类型为struct S,函数完成的功能是排序。

主函数部分先定义了一个struct S类型的变量，名为 s，并初始化。然后调用函数 f，将变量 s的地址传给指针p，则 p 指向结构体变量 s，在函数 f 中，第一曾循环，p->n-1 应理解为（p->n)-1,因为p指向变量s，因此p->n即是取结构体变量s中的变量 n，从主程序中可见n被初始化为10，所以p->n-1值为9，第二层循环是依次取结构体变量s中数组a的两个相邻成员，比较两者大小并交换，最终完成从小到大排序的功能。主函数中的for循环是将s中的数组a输出（已被函数f排序过了)

c语言结构体是在C语言中一种重要的数据类型。该数据类型由一组称为成员（或称为域，或称为元素）的不同数据组成，其中每个成员可以具有不同的类型。结构体通常用来表示类型不同但是又相关的若干数据。结构体类型不是由系统定义好的，而是需要程序设计者自己定义的。C语言提供了关键字struct来标识所定义的结构体类型。

c语言结构体变量

c语言结构体变量是不同数据类型的若干数据的集合体。在程序中使用结构体变量时，一般情况下不能把它作为一一个整体参加数据处理，参见运算和 *** 作的是结构体变量的各个成员的项数据。除此之外还可以引用结构体中的变量成员地址以及成员元素，结构体变量可以进行赋值运算。在数组中，数组是不能彼此赋值的，结构体变量可以相互赋值。

下面说法不正确的是（）。

调用函数时，实参可以是表达式

调用函数时，实参和形参可以共用内存单元

调用函数时，将实参的值复制给形参，使实参变量和形参变量在数值上相等

调用函数时，实参与形参的类型必须一致

~B

~~~6

下面函数调用语句含有实参的个数为（）。

func((exp1,exp2),(exp3,exp4,exp5));

1

2

3

5

~B

~~~6

在C语言中，函数调用时（）。

实参和形参各占独立的存储单元

实参和形参共用存储单元

由系统自动确定实参和形参是否共用存储单元

由用户指定实参和形参是否共用存储单元

~A

~~~6

C语言规定，程序中各函数之间（）。

既允许直接递归调用也允许间接递归调用

既不允许直接递归调用也不允许间接递归调用

允许直接递归调用不允许间接递归调用

不允许直接递归调用允许间接递归调用

~A

~~~8

下列能正确定义一维数组的选项是（）。

int a[5]={0,1,2,3,4,5};

char a[]={0,1,2,3,4,5};

char a={'A','B','C'};

int a[5]="0123";

~B

~~~8

下列叙述中错误的是（）。

对于double类型数组，不可以直接用数组名对数组进行整体输入或输出

数组名代表的是数组所占存储区的首地址，其值不可改变

在程序执行中，数组元素的下标超出所定义的下标范围时，系统将给出“下标越界”的出错信息

可以通过赋初值的方式确定数组元素的个数

~C

~~~8

有下列程序：

#include <stringh>

main()

{ char p[]={'a','b','c'},q[10]={'a','b','c'};

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

}

下列叙述中正确的是（）。

在给p和q数组赋初值时，系统会自动添加字符串结束符，故输出的长度都为3

由于p数组中没有字符串结束符，长度不能确定，但q数组中字符串长度为3

由于q数组中没有字符串结束符，长度不能确定，但p数组中字符串长度为3

由于p和q数组中都没有字符串结束符，故长度都不能确定

~A

~~~8

若要求从键盘读入含有空格字符的字符串，应使用函数（）。

getc()

gets()

getchar()

scanf()

~B

~~~8

当用户要求输入的字符串中含有空格时，应使用的输入函数是（）。

scanf()

getchar()

gets()

getc()

~C

~~~8

当有定义语句：char s[10];,若要从终端给s输入5个字符，错误的输入语句是（）。

gets(&s[0]);

scanf("%s",s+1);

gets(s);

scanf("%s",s[1]);

~D

~~~8

当以下叙述中错误的是（）。

gets函数用于从终端读入字符串

getchar函数用于从磁盘文件读入字符

fputs函数用于把字符串输出到文件

fwrite函数用于以二进制形式输出数据到文件

~B

下列关于字符串的叙述中正确的是（）。

C语言中有字符串类型的常量和变量

两个字符串中的字符个数相同时才能进行字符串大小的比较

可以用关系运算符对字符串的大小进行比较

空串一定比空格打头的字符串小

~D

~~~8

下面能正确进行字符串赋值的是（）。

char s[5]={"ABCDE"};

char s[5]={'A','B','C','D','E'};

chars; s="ABCDE";

chars;printf("%s",s);

~C

~~~8

字符串"\\\"ABCDEF\"\\"的长度是（）。

15

10

7

8

~B

~~~8

下面各语句行中，能正确进行赋值字符串 *** 作的是（）。

char s[5]={'a','b','c','d','e'};

char s;gets(s);

char s;s="ABCDEF";

char s[5];scanf("%s",&s);

~B

~~~8

设已执行预编译命令#include<stringh>,以下程序段的输出结果是（）。

char s[]="abcdefg";

printf("%d\n",strlen(s));

7

8

9

10

~A

~~~8

若已包括头文件<stringh>且已有定义char s1[18],s2={"ABCDE"}和int i，现要将字符串"ABCDE"赋给s1,下述语句错误的是（）。

strcpy(s1,s2);

strcpy(s1,"ABCDE");

s1="ABCDE";

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

s1[i]=s2[i];

~C

###

~~~7

以下程序的输出结果是[<4>]。

#include<stdioh>

main()

{

int a[5]={2,4,6,8,10},p;

p=a;p++;

printf("%d",p);

}

~~~7

以下程序的输出结果是[<3 5>]。

#include<stdioh>

void swap(int a,int b)

{

int t ;

t=a;a=b;b=t;

}

main()

{

int i=3,j=5,p=&i,q=&j;

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

}

~~~7

下面程序段的运行结果是[<68>]。

char str[]="ABCD",p=str;

printf("%d\n",(p+3));

###

~~~7

设已有定义：float x;，则下列对指针变量p进行定义且赋初值的语句中正确的是( )。

float p=1024;

int p=(float)x;

float p=&x;

float p=&x;

~D

~~~7

设有定义语句int (f)(int);，则以下叙述正确的是( )。

f是基类型为int的指针变量

f是指向函数的指针变量，该函数具有一个int类型的形态

f是指向int类型一维数组的指针变量

f是函数名，该函数的返回值是其类型为int类型的地址

~B

~~~7

设有定义：int n1=0,n2,p=&n2,q=&n1;，以下赋值语句中与n2=n1;语句等价的是( )。

p=q

p=q

p=&n1;

p=q

~A

~~~7

在16位编译系统上，若有定义int a[]={10,20,30},p=&a;，当执行p++;后，下列说法错误的是( )。

p向高地址移了一个字节

p向高地址移了一个存储单元

p向高地址移了两个字节

p与n+1等价

~A

~~~7

若有定义语句：int k[2][3],pk[3];，则下列语句中正确的是( )。

pk=k;

pk[0]=&k[1][2];

pk=k[0];

pk[1]=k;

~B

~~~7

若有定义：char(p)[6];则标识符p( )。

是一个指向字符型变量的指针

是一个指针数组名

是一个指针变量，它指向一个含有6个字符型元素的一维数组

定义不合法

~C

~~~7

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

#include<stdioh>

void main()

{ char str[]="abc",p=str;

printf("%d\n",(p+3));

}

67

0

字符'C'的地址

字符'C'

~B

~~~7

若有以下定义，则对a数组元素的正确引用是( )。

int a[5],p=a;

&a[5]

a+1

(p+5)

(a+2)

~D

###

~~~3

C语言中用[<非0>]表示逻辑"真"，用[<0>]表示逻辑值"假"。

~~~3

C语言中逻辑运算符[<!>]的优先级高于算术运算符。

~~~3

当a=1，b=2，c=3时，以下if语句执行后，a、b、c中的值分别为[<3>]、[<2>]、[<2>]。

if(a>c)

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

~~~3

以下程序段的输出结果是[<死循环>]

int k,n,m;

n=10;m=1;k=1;

while(k<=n) m=2;

printf("%d\n",m);

~~~3

以下程序的输出结果是[<-1>]

main()

{

int x=2;

while(x--);

printf("%d\n",x);

}

~~~3

以下程序段：

s=10;

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

s=s+10/(k(k+1))

printf("%f\n",s);

请填空，使下面的程序段的功能完全与之等同。

s=00

[<d=10>]

k=0;

do

{

s=s+d;

[<k++>]

d=10/(k(k+1));

}

while[<k<=n>]

printf("%f\n",s);

~~~3

以下程序功能是：从键盘上输入若干个学生的成绩，统计并输出最高成绩和最低成绩，当输入负数时结束输入。请填空。

main()

{

float x,amax,amin;

scanf("%f",&x);

amax=x;

amin=x;

while[<x>=0>]

{

if(x>amax) amax=x;

if[<x<amin>] amin=x;

scanf("%f",&x);

}

printf("\namax=%f\namin=%f\n",amax,amin);

}

~~~5

若有定义int a[3][5];则排列在数组中的第九个元素是[<a[1][3]>]

~~~5

strlen("How are you\n")的值是[<12>]

~~~5

C语言中字符串结束的标志是[<'\0'>]

~~~5

写出一个名为s的单精度实型一维数组，长度是6，所有元素初值均为0，其数组定义语句是[<float s[6]={0};>]

~~~5

strcmp("how","How")的值是[<32或者>0>]

~~~6

C语言程序执行的开始处是[<main函数>]

~~~6

C程序中的一个函数由两部分组成，即[<声明部分>]和[<执行部分>]

~~~6

为了保证被调用函数不返回任何值，其函数定义的类型应为[<void>]

~~~6

下面pi函数的功能是，根据以下公式返回满足精度ε要求的∏的值。请填空。∏/2=1+1/3+(1/3)(2/5)+(1/3)(2/5)（3/7)+(1/3)(2/5)（3/7)(4/9)+

double pi(double eps)

{double s=00,t=10;

int n;

for([<n=1>];t>eps;n++)

{

s+=t;

t=nt/(2n+1);

}

return (20[<s>]);

}

~~~6

以下函数用以求x的y次方。请填空。

double fun(double x,int y)

{

int i;double z;

for(i=1;i[<<=y>];i++)

z=[<Zx>];

return z;

}

~~~6

以下程序的功能是计算s=0!+1!+2!+3!++n!。请填空。

long f(int n)

{ int i; long s;

s=[<1L>];

for(i=1;i<=n;i++) s=[<Si>];

return s;

}

main()

{

long s;int k,n;

scanf("%d",&n);

s=[<0>];

for(k=0;k<=n;k++) s=s+[<f(k)>];

printf("%ld\n",s);

}

###

~~~3

下列运算符中优先级最高的运算符是()。

!

%

-=

&&

~A

~~~3

下列运算符中优先级最低的运算符是()。

||

!=

<=

+

~A

~~~3

为表示关系x≥y≥z,应使用的C语言表达式是()。

(x>=y)&&(y>=z)

(x>=y)AND(y>=z)

(x>=y>=z)

(x>=y)&(y>=z)

~A

~~~3

设a、b和c都是int型变量，且a=3，b=4，c=5；则以下的表达式中，值为0的表达式是()。

a&&b

a<=b

a||b+c&&b-c

!(a<b)&&!c||1

~D

~~~5

若有int s[4]={1,2,3,4};则s[s[0]+2s[2]-s[3]]的值是()。

1

2

3

4

~D

~~~5

对数组的描述正确的是()。

数组一旦定义去大小是固定的，但数组元素的类型可以不同

数组一旦定义去大小是固定的，但数组元素的类型必须相同

数组一旦定义去大小是可变的，但数组元素的类型可以不同

数组一旦定义去大小是可变的，但数组元素的类型必须相同

~B

~~~5

对字符串"Boy"进行完整赋值的 *** 作是()

char s[3]={'B','o','y'}

char s[]="Boy"

char s[3]={"Boy"}

char s[3];s="Boy"

~B

~~~5

在c语言中引用数组元素时，其数组下标的数组类型允许是()

整型常量

整型表达式

整型常量或整型表达式

任何类型的表达式

~C

~~~5

对以下说明语句的正确理解是()

int a[10]={6,7,8,9,10}

将5个初值依次赋给a[1]至a[5]

将5个初值依次赋给a[0]至a[4]

将5个初值依次赋给a[6]至a[10]

因为数组长度与初值的个数不相同，所以此语句不正确

~B

~~~5

以下程序段给数组所有元素输入数据，应在下划线处填入的是()

main()

{

int a[10],i=0;

while(i<10) scanf("%d",_______);

:

:

}

a+(i++)

&a(i+1)

a+i

&a[++i]

~D

~~~5

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

main()

{

int a[]={2,4,6,8},y=1,x,p;

p=&a[1];

for(x=0;x<3;x++) y+=(p+x);

printf("%d\n",y);

}

17

18

19

20

~C

~~~6

下述函数定义形式正确的是()

int f(int x;int y)

int f(int x, y)

int f(int x,int y)

int f(x,y:y)

~C

~~~6

关于函数参数，说法正确的是()

实参与其对应的形参各自占用独立的内存单元

实参与其对应的形参共同占用一个内存单元

只有当实参和形参同名时才占用同一个内存单元

形参是虚拟的，不占用内存单元

~A

~~~6

用数组名作为函数的实参时，传递给形参的是()

数组的首地址

数组的第一个元素

数组中的全部元素

数组的元素个数

~A

~~~6

复合语句中定义的变量的作用范围是()

整个源文件

整个函数

整个程序

所定义的复合语句

~D

~~~6

一个函数的返回值由()确定

return语句中的表达式

调用函数的类型

系统默认的类型

被调用函数的类型

~D

~~~6

以下说法正确的是()

C语言程序总是从第一个定义的函数开始执行

在C语言程序设计中，要调用的函数必须在main函数中定义

C语言程序总是从main函数开始执行

C语言程序中的main函数必须放在程序的开始部分

~C

~~~6

以下函数的类型是()

fff(float x)

{

printf("",xx);

}

与参数x的类型相同

void类型

int类型

无法确定

~C

~~~6

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

fun(int a,int b)

{int c;

c=a+b;

retutn c;

}

main()

{int x=6,y=7,z=8,r;

r=func((x--,y++,x+y),z--);

printf("%d\n",r);

}

11

20

21

31

~C

~~~10

当说明一个结构体变量时，系统分配给它的内存是()

各成员所需内存总量的总和

结构中第一个成员所需内存量

成员中占内存量最大者所需的容量

结构中最后一个成员所需内存量

~A

~~~10

设有以下说明语句：

struct stu

{int a;

float b;

}stutype;

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

strut是结构体类型的关键字

strut stu是用户定义的结构体类型

stutype是用户定义的结构体类型名

a和b都是结构体成员名

~C

~~~10

C语言结构体类型变量在执行期间()

所有成员一直驻留在内存中

只有一个成员驻留在内存中

部分成员驻留在内存中

没有成员驻留在内存中

~A

~~~11

若想对文本文件只进行读 *** 作，打开此文件的方式为()

"r"

"W"

"a"

"r+"

~A

~~~11

如果要打开C盘file文件夹下的abcdat文件，fopen函数中第一个参数应为()

c:file\abcdat

c:\file\abcdat

"c:\file\abcdat"

"c:\\file\\abcdat"

~D

~~~11

用fopen函数打开文件， *** 作完毕后用()函数关闭它

fopen

open

fclose

close

~C

~~~11

以下可作为函数fopen中第一个参数的正确格式是()

c:user\testtxt

c:\user\testtxt

"c:\user\testtxt"

"c:\\user\\testtxt"

~D

~~~11

若执行fopen函数时发生错误，则函数的返回值是()

地址值

0

1

EOF

~B

~~~11

若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应是()

"ab++"

"wb+"

"rb+"

"ab"

~B

若以"a+"方式打开一个已存在的文件，则以下叙述正确的是()

文件打开时，原有文件内容不被删除，位置指针移到文件末尾，可作添加和读 *** 作

文件打开时，原有文件内容不被删除，位置指针移到文件开头，可作重写和读 *** 作

文件打开时，原有文件内容不被删除，只可作写 *** 作

以上各种说法皆不正确

~A

###

~~~9

下列程序的功能时：给r输入数据后计算半径为r的圆面积s。程序在编译时出错。

main()

{ int r; float s;

scanf("%d",&r);

s=pirr;

printf("s=%f\n",s);

}

出错的原因是（）。

注释语句书写位置错误

存放圆半径的变量r不应该定义为整型

输出语句中格式描述符号非法

计算圆面积的赋值语句中使用了非法变量

~D

~~~9

以下叙述错误的是（）。

在程序中凡是以“#”开始的语句行都是预处理命令行

预处理命令行的最后不能以分号表示结束

#define MAX是合法的宏定义命令行

C程序对预处理命令行的处理是在程序执行的过程中进行的

~C

~~~9

下列叙述中正确的是（）。

预处理命令行必须位于源文件的开头

在源文件的一行上可以有多条预处理命令

宏名必须用大写字母表示

宏替换不占用程序的运行空间

~D

~~~9

若程序中有宏定义行：#define N 100，则下列叙述中正确的是（）。

宏定义中定义了标识符N的值为整数100

在编译程序对C源程序进行预处理时用100替换标识符N

对C源程序进行编译时用100替换标识符N

在运行时用100替换标识符N

~B

~~~9

程序

#include <stdioh>

#define M 5

#define N M+M

main()

{ int k;

k=NN5;

printf("%d\n",k);

}

的输出结果是（）。

100

50

55

45

~C

~~~9

下列叙述中正确的是（）。

预处理命令行必须位于C源程序的起始位置

在C语言中，预处理命令行都以#开头

每个C程序必须在开头包含预处理命令行：#include<stdioh>

C语言的预处理不能实现宏定义和条件编译的功能

~B

~~~9

C语言的编译系统对宏命令的处理是（）。

在系统对源程序进行编译前

和其他语句的编译同时进行

在程序连接时进行

在程序运行时进行

~A

~~~9

以下叙述中不正确的是（）。

预处理命令行都必须以“#”号开始，结尾不加分号

在程序中凡是以“#”开始的语句行都是预处理命令行

C程序在执行过程中对预处理命令进行处理

预处理命令可以放在程序的任何位置

~C

~~~9

下面叙述中正确的是（）。

C语言中预处理是指完成宏替换和文件包含指定的文件的调用

预处理命令只能位于C源程序文件的首部

预处理命令可以放在程序中的任何位置

预处理命令结尾需要加分号

~C

~~~9

以下有关宏替换的叙述不正确的是（）。

使用宏定义可以嵌套

宏定义仅仅是符号替换

双引号中出现的宏名不替换

宏名必须用大写字母表示

~D

19C 只是建议这样做，不是一定，只要把函数放在调用之前也可以、

20B b是数组名，地址常量，不能给地址常量赋值。

21A >

C语言知识要点——转给那些还没把书看完的同志们

来源： 李志远的日志

1C源程序的框架

尽管各个C源程序的功能千变万化，但框架是不变的，主要有：编译预处理、主函数()、函数n()等，主函数的位置不一定在最前面，可以在程序的中部或后面，主函数的名字固定为main。

2C语言源程序的书写规则：

(1)C源程序是由一个主函数和若干个其它函数组成的。

(2)函数名后必须有小括号，函数体放在大括号内。

(3)C程序必须用小写字母书写。

(4)每句的末尾加分号。

(5)可以一行多句。

(6)可以一句多行。

(7)可以在程序的任何位置加注释。

3语句种类

语句是程序的基本成分，程序的执行就是通过一条条语句的执行而得以实现的，根据表现形式及功能的不同，C语言的基本语句可以分为五大类。

(1)流程控制语句

流程控制语句的功能是控制程序的走向，程序的流程有三种基本结构：顺序结构、分支结构和循环结构，任何复杂的程序都可以由这三种基本结构复合而成。其中后两种结构要用特定的流程控制语句实现。

(2)表达式语句

表达式语句的形式是：表达式；，即表达式后跟一分号"；"，分号是语句结束符，是一个语句必不可少的成分。表达式和表达式语句的区别在于表达式代表的是一个数值，而表达式语句则代表一种动作。最常见的表达式语句是赋值语句。

(3)函数调用语句

函数调用语句实际上也是一种表达式语句，形式为：在一次函数调用的小括号后面加上一个分号。

(4)空语句

空语句的形式就是一个分号，它不代表任何动作，常常作为一个意义转折点使用。

(5)复合语句

复合语句从形式上看是多个语句的组合，但在语法意义上它只相当于一个语句，在任何单一语句存在的地方都可以是复合语句。注意复合语句中最后一个语句末尾的分号不能少。复合语句右大括号后面没有分号。

4运算符

用来表示数据各种 *** 作的符号称为运算符。运算符实际上代表了一种类型数据的运算规则。不同的运算符具有不同的运算规则，其 *** 作的数据类型必须符合该运算符的要求，运算结果的数据类型也是固定的。

根据参加 *** 作的数据个数多少，可以将C语言的运算符分为单目运算符，双目运算符和三目运算符(三目运算符只有条件运算符一个)。

根据运算对象和运算结果的数据类型可分为算术运算符、关系运算符、逻辑运算符等。

5表达式

表达式是由常量、变量、函数，通过运算符连接起来而形成的一个算式。一个常量，一个变量或一个函数都可以看成是一个表达式。

表达式的种类有：

算术表达式、关系表达式、逻辑表达式、赋值表达式、字位表达式、强制类型转换表达式、逗号表达式(顺序表达式)、条件表达式、指针表达式。

6数据的输入/输出

C语言本身没有输人/输出语句，数据的输入/输出是通过调用库函数来实现的。

第二章 数据类型知识点

划分数据类型的意义是编译系统对每个不同类型的数据在内存中分配的字节数不同，不同类型的数据可以按规定参加不同类型的运算。

1C语言的数据类型

数据类型有：整型、字符型、实型单精度型、双精度型、构造类型数组类型、结构体类型、共用体类型、枚举类型、指针类型、空类型，其中整型、实型、字符型是C语言中的基本类型。

2各种类型数据的定义方法

定义形式：数据类型 变量名1，变量名2，变量名n；

3常量与变量

(1)常量——在程序执行期间其值不变的量。它不能被赋值。

(2)变量——在程序运行期间其值可以改变的量。

4各种类型数据的混合运算

各类数据运算前会自动转换成同一类型。规律如右图示：从右向左的箭头表示必定的转换，如float型数据运算前化成double型，以提高运算精度，结果也为double型，short或char型数据运算前化成int型，结果也为int型；从下向上的箭头表示转换方向是向级别高的靠拢。

5强制类型变换

当我们需要对数据进行类型变换，而机器又不能自动完成时，就要用强制类型变换，形式为：(数据类型符)(被转换对象)。

第三章 选择知识点

C语言中实现选择结构的控制语句有两种：条件分支语句if和开关分支语句switch。

1if语句的三种形式：

(1) if(表达式)语句；

(2) if(表达式)语句1;

else语句2;

(3) if(表达式1)语句1;

else if(表达式2)语句2;

else if(表达式3)语句3;

else if(表达式n)语句n;

2开关分支语句switch

(1)形式

switch(表达式)

{ case e1:语句1；break;

case e2:语句2；break;

case e3:语句3；break;

case en:语句n；break;

default :语句n+1;

}

(2)功能

当表达式的值等于e1时，执行语句1；

当表达式的值等于e2时，执行语句2；

当表达式的值等于en时，执行语句n；

当表达式的值与常量e1、e2en谁都不等时，就执行default后的语句

第四章 循环知识点

循环就是在程序执行过程中，反复多次的执行同一段程序。C语言中有三种循环语句。

1while循环语句

形式为：while(表达式)

{

循环体

}；

执行过程是：先计算表达式的值，当表达式的值非0时就执行循环体，之后再判断表达式的值，且重复以上过程；当表达式的值为0时就结束循环。

2do-- while循环语句

形式为：do

{

循环体

} while(表达式)；

执行过程是：先执行循环体一次，再判断表达式的值，当表达式的值非0时就再执行循环体，之后再判断表达式的值，且重复以上过程；当表达式的值为0时就结束循环。

3for循环语句

形式为：for(表达式1;表达式2;表达式3)

{ 循环体 }

4三种循环语句的比较

三种循环语句可以完成同一件事，可任选其一。

使用while和do-- while循环时，要提前给循环变量赋初值。而for循环是在表达式1中赋初值的。

while循环和for循环都是先判断条件后执行循环体，有可能一次也不执行循环体，do-- while循环是先执行循环体，后判断条件，即循环体至少也得执行一次。for循环不限于计数循环，其循环条件可以是逻辑表达式和字符表达式等。

5循环嵌套

三种循环控制语句可以互相嵌套，即在一个循环体内部又可以出现另一循环，这种嵌套在理论上来说可以是无限的。注意必须是一个循环完整的套住另一个循环。

6break语句

break语句只能出现在三种循环语句和switch多分支语句中，其作用是用来中断这四种语句的执行。当程序执行到break语句时，会跳出break语句所在的循环或switch分支，而直接执行紧跟在它们后面的语句。

7continue语句

continue语句只能出现在三种循环语句中，当程序执行到continue语句时，其作用是提前结束本次循环，自动跳过循环体中后半部剩余的语句的执行，而直接回到循环条件判断。根据判断的结果决定是否继续执行下次循环。

8 goto 语句

goto语句是一种非结构化语句，其作用是使程序的执行无条件的转移到某一处。使用格式为: goto 标号；利用goto语句与if条件语句配合，也可以实现条件循环。C语句允许在任何语句前添加标号，作为跳转目标，标号的构成是标识符后面加一个":"。

第五章 数组知识点

数组就是同类型的一批数据的集合，用一个变量名存放，区分各元素的办法是用下标。

1一维数组

类型说明符数组名\[数组长度\]；

(1)数组命名要符合标识符的命名规则。

(2)数组名后的括号必须是方括号，不能是圆括号。

(3)数组长度必须是正整数,可以是个表达式，但不能有变量，C语言不支持动态数组。

(4)数组长度表示数组中元素的个数

(5)数组元素的下标从0开始数，所以最大下标是数组的长度减1。

2．多维数组(以二维为例)

类型说明符数组名\[第一维长度\]\[第二维长度\]；

(1)数组命名要符合标识符的命名规则。

(2)数组名后的括号必须是两个方括号，定义时不能写成inta\[3，4\]；。

(3)数组长度必须是整型常量表达式。

(4)第一维长度表示数组行数，第二维长度表示数组列数。

(5)每个数组元素都有两个下标，第一维表示该元素所在的行，第二维表示该元素所在的列，每一维的下标都从0开始数。

二维数组的初始化：C语言规定只有静态数组和外部数组才允许在定义时赋初值，赋初值形式如下：

static类型说明符数组名\[第一维长度\]\[第二维长度\]={初值表}；

二维数组的引用：二维数组不能整体引用，要引用数组的单个元素，形式为：数组名\[下标\]\[下标\]和普通变量的使用无任何区别。

3．字符数组

C语言中没有字符串变量，字符串是靠字符数组实现的，所谓字符数组就是元素的数据类型为字符型的数组。

(1)字符数组的定义形式：char数组名\[数组长度\]；

因为C语言中的整型数据和字符型数据是相通的，所以也可以这样定义：int数组名\[数组长度\]；

(2)字符数组的初始化：给字符数组的初始化有两种方式，一种是用字符常量，另一种是用字符串。形式如下：

staticchar数组名\[数组长度\]={字符常量表}；

staticchar数组名\[数组长度\]={字符串常量}；

4数组与函数

数组经常作为函数的参数，数组做函数的参数有两种形式，一是数组元素做函数的参数，一是数组名做函数的参数，当用数组名做函数的实参时传送的是首地址。

5常用的字符串处理函数

C语言提供了一些处理字符串的标准函数，用以完成一些常见的 *** 作。对以下几个函数要掌握其功能和调用形式。

(1)gets(字符数组名)此函数功能是从键盘输入一串字符，回车后送到字符数组中，注意定义数组时数组长度要足够大。

(2)puts(字符数组名)此函数功能是将字符数组的内容输出到屏幕上。

(3)strcat(字符数组名1，字符数组名2)此函数功能是将字符数组1中的'\\0'去掉后将字符数组2的内容连接到字符数组1的末尾。

(4)strcpy(字符数组名1，字符数组名2)函数功能是将字符数组2的内容(包括'\\0')拷贝到字符数组1中，字符数组2处也可以是字符串常量。strcpy函数可以实现拷子串。

(5)strcmp(字符数组名1，字符数组名2)函数功能是两个字符串(ASCII码)比大小。

(6)strlen(字符数组名)此函数功能是求字符串的长度，注意不包括'\\0'。

(7)strlwr(字符数组名)此函数功能是将字符串中的所有大写字母都变成小写。

(8)strupr(字符数组名)此函数功能是将字符串中的所有小写字母都变成大写。

第六章 函数知识点

每个C源程序都是由函数组成的，一个主函数和若干个其它函数，C语言程序设计的基础工作就是函数的具体编写，C语言中的函数就相当于其它高级语言中的子程序。

1函数的概念

函数就是一个数据加工厂,从函数外部接收数据，在函数内部加工处理，然后得到一个结果返回给外部的调用者。所以函数就是对语言功能的扩充，对函数的调用就是对功能的调用。

2标准函数

各种高级语言都定义了一些标准函数，C语言中的标准函数称为库函数，是将一些基本的、常用的功能编成了函数，供大家使用方便。使用库函数时必须把它的头文件用＃i nclude命令包含进来，每个库函数的功能及对应的头文件都会在手册中给出。

3自定义函数

C 语言也允许用户自己编写函数以实现C库函数中没有提供的功能，称作自定义函数。

4．定义函数

C语言规定每个函数都要独立定义,函数定义不能嵌套。

函数定义的形式：数据类型函数名(形参表)

形参说明语句序列

{ 说明语句序列

可执行语句序列 }

5．函数调用

函数调用的形式是： 函数名(实参表)。当实参表中有多个参数时，要用逗号隔开，若被调函数无参数，调用时小括号也不能省。函数调用过程是:将实参的值传给形参，在函数体内进行加工处理，然后由return语句将函数值返回调用处。

5．全局变量和局部变量

局部变量：在函数内部定义的变量称为局部变量，只在本函数中有效。

全局变量：在函数外部定义的变量称为全局变量，它的作用范围是从定义开始到本文件结束。

6．动态存储与静态存储

内存中的用户数据区分为动态存储区和静态存储区，动态存储区是指程序运行期间给变量临时分配存储单元，变量用完后立即释放单元的区域，动态存储区放的是函数的形参、自动变量、函数调用期间的现场保护数据和返回地址。

静态存储区是指程序运行期间给变量分配固定的存储单元，放的是全局变量和局部静态变量。

一个变量除了它的数据类型以外还有存储类型，定义一个变量时应该说明这两种类型。

第七章 预处理知识点

对高级语言编译连接就是把源程序转换成机器语言，C语言在进行编译之前还要预先处理三件事：宏定义命令、文件包含命令和条件编译命令，统称为预处理命令，其特点是：

1所有的预处理命令都放在程序的头部，以#开头，且#号后面不留空格。

2预处理命令不是C的语句，行尾不加分号。

3预处理命令是在编译预处理阶段完成的，所以它们没有任何计算、 *** 作等执行功能。

4预处理命令有所变动后，必须对程序重新进行编译和连接。

1．宏定义

宏定义命令的作用是给一些常用的对象重新命名，在程序中可以用宏名来引用这些对象，预处理时宏名会被代表的内容替换，此过程称为宏展开或宏替换。宏定义有两种形式：

2．文件包含

使用文件包含命令可以将另—个C源程序的全部内容包含进来，其形式为：

＃i nclude ＜文件名＞或＃i nclude "文件名"

通常可以把经常用到的，带公用性的一些函数或符号等集合在起形成一个源文件，然后用此命令将这个源文件包含进来，这样可以避免在每个新程序中都要重新键入这些内容。

3．条件编译

顾名思义满足条件时进行编译，为了解决程序移植问题，C语言提供了条件编译命令，它能使源程序在不同的编译环境下生成不同的目标代码文件。条件编译命令有3种形式。

第八章 指针知识点

1什么是指针和指针变量？

指针就是内存地址，因为通过"地址"可以找到变量，所以内存"地址"形象的称为指针。

指针变量就是存地址的变量。在C语言中用一个变量存另一个变量的地址，那么就称这个变量为指针变量，指针变量的值就是地址。通常指针变量被简称为指针。

指针变量是有类型的，即指针值增1表示指向下一个数据，如整型数据在内存中占两个字节，它的指针变量增1是增两个字节。如实型数据在内存中占4个字节，它的指针变量增1是增4个字节。

2怎样定义指针变量？

定义形式为：数据类型指针变量名1，指针变量名2；

3指针的有关运算

指针为内存地址是整数，可以进行一些算术运算、关系运算、赋值运算、特殊运算等，但要注意运算代表的实际意义。

4．指向数组的指针变量

(1)指向数组元素的指针变量定义形式为：inta\[10\];

intp=a;

(2)指向一维数组的指针变量

定义形式为：inta\[3\]\[4\];

int(p)\[4\];

p=a;

(3)指向字符串的指针变量

定义形式为： charp="字符序列"；

C语言中的字符串是以隐含形式的字符数组存放的，定义了指针变量p并不是将整个字符串都存放在p中了，而p中存放的是字符串的首地址。

5．指向函数的指针变量

一个函数在编译时被分配一个入口地址，这个地址就是函数的指针，可以用一个指针变量指向它。指向函数的指针变量定义形式为：

数据类型(指针变量名)；

6指针变量做函数的参数

(1)指针作函数的参数可以传送地址，如数组的首地址，函数的入口地址等。

(2)指针作函数的参数也可以用地址方式传送数据。

7．返回值是指针的函数

即函数的返回值是内存的地址，利用这种方法可以将一个以上的数据返回给函数的调用者。定义形式如下：

数据类型函数名（形参表）

8指针数组

定义形式为：数据类型数组名\[数组长度\]；

数组中的每个元素都是指针类型的数据，这种数组被称为指针数组。

9指向指针的指针

定义形式为：数据类型指针变量名；

指向指针数据的指针变量称为指向指针的指针。

10main函数的形参

main函数可以带两个形参，如：

main(argc,argv)

intargc；

char argv\[\]；

{

}

11指向结构体的指针变量

结构体变量的指针就是该变量所占据的内存段的首地址。指向结构体的指针变量定义形式为：struct结构体类型名指针变量名；

12指向共用体的指针变量

共用体变量的指针就是该变量所占据的内存段的首地址。指向共用体的指针变量定义形式为：union共用体类型名指针变量名；

替换了的字符时(这里为正中间的字符"4")，原来的字符己不复存在。

第九章 结构体与共用体知识点

结构体类型是C语言的一种构造数据类型，它是多个相关的不同类型数据的集合，相当于其它高级语言中的记录。

1结构体类型定义

结构体类型的形式为：

struct结构体类型名

{ 数据类型成员名1；

数据类型成员名n；

}

2结构体变量的定义

结构体变量有三种定义形式：

(1)先定义结构体类型，后定义结构体变量。

(2)定义结构体类型的同时定义结构体变量。

(3)不定义结构体类型名，直接定义结构体变量。

3结构体变量的引用

(1)结构体变量的初始化：许多C版本规定对外部或静态存储类型的结构体变量可以进行初始化，而对局部的结构体变量则不可以，新标准C无此限制，允许在定义时对自动变量初始化。

(2)结构体成员的引用：由于C语言一般不允许对结构体变量的整体引用，所以对结构体的引用只能是对分量的引用，结构体变量中的任一分量可以表示为：结构体变量名·成员名

4结构体与数组

C语言中数组的成员可以是结构体变量，结构体变量的成员也可以是数组。

结构体数组有三种定义形式：

(1)先定义结构体类型，后定义结构体数组。

(2)定义结构体类型的同时定义结构体数组。

(3)不定义结构体类型名，直接定义结构体变量。

5结构体与指针

一方面结构体变量中的成员可以是指针变量，另一方面也可以定义指向结构体的指针变量，指向结构体的指针变量的值是某一结构体变量在内存中的首地址。

结构体指针的定义形式:struct结构体类型名结构体指针变量名。

由结构体指针引用结构体成员的方法

6用指针处理链表

结构体的成员可以是指针类型，并且这个指针类型就是本结构体类型的，这样可以构造出一种动态数据结构—成为链表。所谓动态数据就是指在编译时不能确定数据量的多少，而是在程序执行时才确定的数据，动态数据可以比较方便的进行数据插人或删除等 *** 作。

7结构体与函数

结构体变量的成员可以作函数的参数、指向结构体变量的指针也可以作函数的参数。虽然结构体变量名也可以作为函数的参数，将整个结构体变量进行传递，但一般不这样做，因为如果结构体的成员很多，或者有些成员是数组，则程序运行期间，将全部成员一个一个的传递，既浪费时间，又浪费空间，开销太大。

8结构体与共用体

结构体变量中的成员可以是共用体，共用体变量中的成员可以是结构体。

共用体

为了节省存储空间，C语言允许将几种不同类型的数据存放在同一段内存单元，它们共用一个起始地址，称做共用体。

1共用体类型定义

union共用体类型名

{ 数据类型成员名1;

数据类型成员名n；

}

2共用体变量定义

(1)先定义类型，后定义变量。

(2)定义类型的同时定义变量。

(3)不定义类型名，直接定义变量。

3共用体变量的引用

(1)共用体变量不能整体引用，只能引用其成员，形式为：共用体变量名·成员名

(2)共用体变量的成员不能初始化，因为它只能放一个数据。

(3)共用体变量存放的数据是最后放入的数据。

(4)共用体变量的长度是最大的成员的长度。

(5)可以引用共用体变量的地址、各个成员的地址，它们都是同一个地址。

(6)共用体变量不能当函数的参数或函数的返回值，但可以用指向共用体变量的指针作函数的参数。

(7)共用体变量的成员可以是数组，数组的成员也可以是共用体变量。

第十章 位运算知识点

位运算就是按二进制位进行 *** 作的运算，运算的对象只能是整型或字符型，不能是实型。不同长度的变量进行位运算，系统会自动右对齐，而左端的不齐部分，对于无符号数左端补满0，对于有符号数则：正数左端补满0，负数左端补满1。

第十一章 文件知识点

*** 作系统是以文件为单位对数据进行管理的，任何一种计算机高级语言都要有和磁盘文件打交道的能力，否则该语言的功能充其量是算一算、显示显示而已。在C语言中没有单独的文件 *** 作语句，所有对文件的 *** 作都是通过库函数来完成的，所以本章的重点是学会使用有关文件 *** 作的库函数。

1文件的基本概念

2文件类型指针

3文件的 *** 作

以上就是关于在C语言中，_____存储类型的变量，只在使用时才分配空间。全部的内容，包括:在C语言中，_____存储类型的变量，只在使用时才分配空间。、在C语言中运行程序时最常出现的有那些错误、在c语言中，程序运行期间，其值可以改变的量叫做()等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！