C语言32个关键字3篇

C语言的32个关键字1　　(1)char：声明字符型变量或函数　　(2)double：声明双精度变量或函数　　(3)enum：声明枚举类型　　(4)float：声明浮点型变量或函数　　(5)int：下面是小编为大家整理的C语言32个关键字3篇,供大家参考。

C语言的32个关键字1

　　(1) char ：声明字符型变量或函数

　　(2) double ：声明双精度变量或函数

　　(3) enum ：声明枚举类型

　　(4) float：声明浮点型变量或函数

　　(5) int： 声明整型变量或函数

　　(6) long ：声明长整型变量或函数

　　(7) short ：声明短整型变量或函数

　　(8) signed：声明有符号类型变量或函数

　　(9) struct：声明结构体变量或函数

　　(10) union：声明共用体(联合)数据类型

　　(11) unsigned：声明无符号类型变量或函数

　　(12) void ：声明函数无返回值或无参数，声明无类型指针

C语言的32个关键字2

　　A循环语句：

　　for：一种循环语句

　　do ：循环语句的`循环体

　　while ：循环语句的循环条件

　　break：跳出当前循环

　　continue：结束当前循环，开始下一轮循环 B条件语句：

　　if: 条件语句

　　else：条件语句否定分支(与 if 连用)

　　goto：无条件跳转语句 C开关语句：

　　switch :用于开关语句

　　case：开关语句分支

　　default：开关语句中的“其他”分支 D返回语句：

　　return ：子程序返回语句(可以带参数，也看不带参数)

C语言的32个关键字3

　　auto ：声明自动变量 一般不使用

　　extern：声明变量是在其他文件正声明(也可以看做是引用变量)

　　register：声明积存器变量

　　static ：声明静态变量

C语言的32个关键字3篇扩展阅读

——C语言初始化效率问题及关键字解释3篇

C语言初始化效率问题及关键字解释1

　　1、在静态变量的初始化中，我们可以把可执行程序文件想要初始化的值放在当程序执行时变量将会使用的位置。当可执行文件载入到内存时，这个已经保存了正确初始值的位置将赋值给那个变量，完成这个任务并不需要额外的时间，也不需要额外的指令，变量将会得到正确的值、

　　2、自动变量当程序链接时还无法判断自动变量的存储位置。事实上，函数的局部变量在函数的每次调用中可能占据不同的位置。基于这个理由，自动变量没有缺省的初始值，而显示的初始化将在代码块的其实出插入一条隐式的赋值语句。

　　一句话总结;局部变量的初始化与分开写毫无区别

　　即什么时候使用变量什么时候声明，尽量重用，不要让他隐式初始化，浪费内存

　　static 关键字的修饰。

　　当它用于函数定义时，或用于代码块之外的变量声明时，static关键字用于修改标识符的链接属性，从external改为internal，但标识符的存储类型和作用域不受影响。用这种方式声明的函数或变量只能在声明他们的源文件中访问。

　　总结：

　　一下以文件解释

　　int a;

　　//a 变量存储在静态内存

　　特点：

　　在程序运行之前创建

　　可以被其他的C文件访问以及它的下方函数使用

　　初始化值为0

　　=================

　　static int a;

　　特点：在程序运行之前存在

　　静态内存存储

　　不能被其他文件访问

　　================

　　代码块中的变量

　　static int a ;

　　静态变量

　　与int a ;(局部变量)

　　的区别是：

　　一个存储在静态内存 也就是普通内存

　　另一个是局部变量，也就是运行时堆栈

　　函数上添加static的话：

　　不能被其他的文件访问该函数

　　几个关键字的处理

　　static 静态内存

　　auto 运行时堆栈

　　register 硬件寄存器

　　external 引用外部文件变量函数

　　internal 引用内部文件变量函数

　　=======================

　　关于代码块变量被static修饰

　　保证该函数多次调用时，我们为了防止该变量不变

　　进行的处理比如我们进行了多次的调用

——嵌入式C语言的关键字 (精选3篇)

嵌入式C语言的关键字1

　　这个关键字的作用是饿很难强大的。

　　要对static关键字深入了解，首先需要掌握标准C程序的组成。

　　标准C程序一直由下列部分组成：

　　1)正文段——CPU执行的机器指令部分，也就是你的程序。一个程序只有一个副本;只读，这是为了防止程序由于意外事故而修改自身指令;

　　2)初始化数据段(数据段)——在程序中所有赋了初值的全局变量，存放在这里。

　　3)非初始化数据段(bss段)——在程序中没有初始化的全局变量;内核将此段初始化为0。

　　注意：只有全局变量被分配到数据段中。

　　4)栈——增长方向：自顶向下增长;自动变量以及每次函数调用时所需要保存的信息(返回地址;环境信息)。这句很关键，常常有笔试题会问到什么东西放到栈里面就足以说明。

　　5)堆——动态存储分配。

　　在嵌入式C语言当中，它有三个作用：

　　作用一：在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

　　这样定义的变量称为局部静态变量：在局部变量之前加上关键字static，局部变量就被定义成为一个局部静态变量。也就是上面的作用一中提到的在函数体内定义的变量。除了类型符外，若不加其它关键字修饰，默认都是局部变量。比如以下代码：

　　void test1(void)

　　{

　　unsigned char a;

　　static unsigned char b;

　　…

　　a++;

　　b++;

　　}

　　在这个例子中，变量a是局部变量，变量b为局部静态变量。作用一说明了局部静态变量b的特性：在函数体，一个被声明为静态的变量(也就是局部静态变量)在这一函数被调用过程中维持其值不变。这句话什么意思呢?若是连续两次调用上面的函数test1：

　　void main(void)

　　{

　　…

　　test1();

　　test1();

　　…

　　}

　　然后使程序暂停下来，读取a和b的值，你会发现，a=1，b=2。怎么回事呢，每次调用test1函数，局部变量a都会重新初始化为0x00;然后执行a++;而局部静态变量在调用过程中却能维持其值不变。

　　通常利用这个特性可以统计一个函数被调用的次数。

　　声明函数的一个局部变量，并设为static类型，作为一个计数器，这样函数每次被调用的时候就可以进行计数。这是统计函数被调用次数的最好的办法，因为这个变量是和函数息息相关的，而函数可能在多个不同的地方被调用，所以从调用者的角度来统计比较困难。代码如下：

　　void count();

　　int main()

　　{

　　int i;

　　for (i = 1; i <= 3; i++)

　　{

　　count();

　　{

　　return 0;

　　}

　　void count()

　　{

　　static num = 0;

　　num++;

　　printf(" I have been called %d",num,"times/n");

　　}

　　输出结果为：

　　I have been called 1 times.

　　I have been called 2 times.

　　I have been called 3 times.

　　看一下局部静态变量的详细特性，注意它的作用域。

　　1)内存中的位置：静态存储区

　　2)初始化：未经初始化的全局静态变量会被程序自动初始化为0(自动对象的值是任意的，除非他被显示初始化)

　　3)作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域随之结束。

　　注：当static用来修饰局部变量的时候，它就改变了局部变量的存储位置，从原来的栈中存放改为静态存储区。但是局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中，直到程序结束，只不过我们不能再对他进行访问。

　　作用二：在模块内(但在函数体外)，一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。

　　这样定义的变量也称为全局静态变量：在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。也就是上述作用二中提到的在模块内(但在函数体外)声明的静态变量。

　　定义全局静态变量的好处：

　　不会被其他文件所访问，修改，是一个本地的局部变量。

　　其他文件中可以使用相同名字的变量，不会发生冲突。

　　全局变量的详细特性，注意作用域，可以和局部静态变量相比较：

　　1)内存中的位置：静态存储区(静态存储区在整个程序运行期间都存在)

　　2)初始化：未经初始化的全局静态变量会被程序自动初始化为0(自动对象的值是任意的，除非他被显示初始化)

　　3)作用域：全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。

　　当static用来修饰全局变量的时候，它就改变了全局变量的作用域(在声明他的文件之外是不可见的)，但是没有改变它的存放位置，还是在静态存储区中。

　　作用三：在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

　　这样定义的函数也成为静态函数：在函数的返回类型前加上关键字static，函数就被定义成为静态函数。函数的定义和声明默认情况下是extern的，但静态函数只是在声明他的文件当中可见，不能被其他文件所用。

　　定义静态函数的好处：

　　 其他文件中可以定义相同名字的函数，不会发生冲突

　　 静态函数不能被其他文件所用。它定义一个本地的函数。

　　这里我一直强调数据和函数的本地化，这对于程序的结构甚至优化都有巨大的好处，更大的作用是，本地化的数据和函数能给人传递很多有用的信息，能约束数据和函数的作用范围。在C++的对象和类中非常注重的私有和公共数据/函数其实就是本地和全局数据/函数的扩展，这也从侧面反应了本地化数据/函数的优势。

　　最后说一下存储说明符，在标准C语言中，存储说明符有以下几类：

　　auto、register、extern和static

　　对应两种存储期：自动存储期和静态存储期。

　　auto和register对应自动存储期。具有自动存储期的变量在进入声明该变量的程序块时被建立，它在该程序块活动时存在，退出该程序块时撤销。

　　关键字extern和static用来说明具有静态存储期的变量和函数。用static声明的局部变量具有静态存储持续期(static storage duration)，或静态范围(static extent)。虽然他的值在函数调用之间保持有效，但是其名字的可视性仍限制在其局部域内。静态局部对象在程序执行到该对象的声明处时被首次初始化。

嵌入式C语言的关键字2

　　const关键字也是一个优秀程序中经常用到的关键字。关键字const 的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。通过给优化器一些附加的信息，使用关键字const 也许能产生更紧凑的代码。合理地使用关键字const 可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

　　深入理解const关键字，你必须知道：

　　a. const关键字修饰的变量可以认为有只读属性，但它绝不与常量划等号。

　　如下代码：

　　const int i=5;

　　int j=0;

　　...

　　i=j; //非法，导致编译错误，因为只能被读

　　j=i; //合法

　　b. const关键字修饰的变量在声明时必须进行初始化。如下代码：

　　const int i=5; //合法

　　const int j; //非法，导致编译错误

　　c. 用const声明的变量虽然增加了分配空间，但是可以保证类型安全。const最初是从C++变化得来的，它可以替代define来定义常量。在旧版本(标准前)的c中，如果想建立一个常量，必须使用预处理器：

　　#define PI 3.

　　此后无论在何处使用PI，都会被预处理器以3.替代。编译器不对PI进行类型检查，也就是说可以不受限制的建立宏并用它来替代值，如果使用不慎，很可能由预处理引入错误，这些错误往往很难发现。而且，我们也不能得到PI的地址(即不能向PI传递指针和引用)。const的出现，比较好的解决了上述问题。

　　d. C标准中，const定义的常量是全局的。

　　e. 必须明白下面语句的含义，我自己是反复记忆了许久才记住，方法是：若是想定义一个只读属性的指针，那么关键字const要放到‘* ’后面。

　　char *const cp; //指针不可改变，但指向的内容可以改变

　　char const *pc1; //指针可以改变，但指向的内容不能改变

　　const char *pc2; //同上(后两个声明是等同的)

　　f. 将函数传入参数声明为const，以指明使用这种参数仅仅是为了效率的原因，而不是想让调用函数能够修改对象的值。

　　参数const通常用于参数为指针或引用的情况，且只能修饰输入参数;若输入参数采用“值传递”方式，由于函数将自动产生临时变量用于复制该参数，该参数本就不需要保护，所以不用const修饰。例子：

　　void fun0(const int * a );

　　void fun1(const int & a);

　　调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const int * a，则不能对传递进来的指针所指向的内容进行改变，保护了原指针所指向的内容;如形参为const int & a，则不能对传递进来的引用对象进行改变，保护了原对象的.属性。

　　g. 修饰函数返回值，可以阻止用户修改返回值。(在嵌入式C中一般不用，主要用于C++)

　　h. const消除了预处理器的值替代的不良影响，并且提供了良好的类型检查形式和安全性，在可能的地方尽可能的使用const对我们的编程有很大的帮助，前提是：你对const有了足够的理解。

　　最后，举两个常用的标准C库函数声明，它们都是使用const的典范。

　　1.字符串拷贝函数：char *strcpy(char *strDest，const char *strSrc);

　　2.返回字符串长度函数：int strlen(const char *str);

嵌入式C语言的关键字3

　　一个定义为volatile 的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。

　　由于访问寄存器的速度要快过RAM，所以编译器一般都会作减少存取外部RAM的优化。比如：

　　static int i=0;

　　int main(void)

　　{

　　...

　　while (1)

　　{

　　if (i)

　　dosomething();

　　}

　　}

　　/* Interrupt service routine. */

　　void ISR_2(void)

　　{

　　i=1;

　　}

　　程序的本意是希望ISR_2中断产生时，在main当中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远也不会被调用。

　　如果将将变量加上volatile修饰，则编译器保证对此变量的读写操作都不会被优化(肯定执行)。此例中i也应该如此说明。

　　一般说来，volatile用在如下的几个地方：

　　1、中断服务程序中修改的供其它程序检测的变量需要加volatile;

　　2、多任务环境下各任务间共享的标志应该加volatile;

　　3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能有不同意义;

　　不懂得volatile 的内容将会带来灾难，这也是区分C语言和嵌入式C语言程序员的一个关键因素。为强调volatile的重要性,再次举例分析:

　　代码一:

　　int a,b,c;

　　//读取I/O空间0x100端口的内容

　　a= inword(0x100);

　　b=a;

　　a=inword(0x100)

　　c=a;

　　代码二:

　　volatile int a;

　　int a,b,c;

　　//读取I/O空间0x100端口的内容

　　a= inword(0x100);

　　b=a;

　　a=inword(0x100)

　　c=a;

　　在上述例子中,代码一会被绝大多数编译器优化为如下代码:

　　a=inword(0x100)

　　b=a;

　　c=a;

　　这显然与编写者的目的不相符,会出现I/O空间0x100端口漏读现象,若是增加volatile,像代码二所示的那样,优化器将不会优化掉任何代码.

　　从上面来看,volatile关键字是会降低编译器优化力度的,但它保证了程序的正确性,所以在适合的地方使用关键字volatile是件考验编程功底的事情.

——狮子座女生的关键字

狮子座女生的关键字1

狮子座：热情、浪漫、自信、炫耀

　　狮子座的人有一种贵族气息或是王者风范，在哪里都受人尊重，做事相当独立，他们本质是阳刚、专制、具有太阳般的生气、宽宏大量、乐观、海派、光明磊落、不拘小节、心胸开阔。不过也会有顽固、傲慢、独裁的一面。但有时也相当浪漫，喜欢美丽的事并爱炫耀、豪华及被人围绕与赞美。狮子座的人热爱生命、好享乐、勇敢、坚持原则及理念。个性温暖、友善、体贴、外向、对人慷慨大方，所以人缘当然也很不错。可是因为他们太在乎别人对他的看法，往往因此而不快乐；不肯认输的个性，也是令自己不愉快的泉源。

——C语言测试题及答案3篇

C语言测试题及答案1

　　1.(A )是构成C语言程序的基本单位。

　　A、函数

　　B、过程

　　C、子程序

　　D、子例程

　　2.C语言程序从 C 开始执行。

　　A、 程序中第一条可执行语句

　　B、 程序中第一个函数

　　C、 程序中的main函数

　　D、包含文件中的第一个函数

　　3、以下说法中正确的是( C )。

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

　　B、在C语言程序中，要调用的函数必须在main( )函数中定义

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

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

　　4.下列关于C语言的说法错误的是( B ) 。

　　A、 C程序的工作过程是编辑、编译、连接、运行

　　B、 C语言不区分大小写。

　　C、 C程序的三种基本结构是顺序、选择、循环

　　D、C程序从main函数开始执行

　　5.下列正确的标识符是(C　)。

　　A、-a1

　　B、a[i]

　　C、a2_i

　　D、int t

　　5~8题为相同类型题

　　考点：标识符的命名规则

　　只能由字母、数字、下划线构成

　　数字不能作为标识符的开头

　　关键字不能作为标识符

　　选项A中的“-” ，选项B中“[”与“]”不满足(1);选项D中的int为关键字，不满足(3)

　　6.下列C语言用户标识符中合法的是(B )。

　　A、3ax

　　B、x

　　C、case

　　D、-e2 E)union

　　选项A中的标识符以数字开头不满足(2);选项C，E均为为关键字，不满足(3);选项D中的“-”不满足(1);

　　7.下列四组选项中，正确的C语言标识符是( C )。

　　A、 %x

　　B、a+b

　　C、a123

　　D、123

　　选项A中的“%” ，选项B中“+”不满足(1);选项D中的标识符以数字开头不满足(2)

　　8、下列四组字符串中都可以用作C语言程序中的标识符的是( A)。

　　A、print _3d db8 aBc

　　B、Iam one_half start$it 3pai

　　C、str_1 Cpp pow while

　　D、Pxq My->book line# His.age

　　选项B中的“”，”$” ，选项D中“>”，”#”，”.”，”-”不满足(1);选项C中的while为关键字，不满足(3)

　　9.C语言中的简单数据类型包括(D )。

　　A、整型、实型、逻辑型

　　B、整型、实型、逻辑型、字符型

　　C、整型、字符型、逻辑型

　　D、整型、实型、字符型

　　10.在C语言程序中，表达式5%2的结果是 C 。

　　A、2.5

　　B、2

　　C、1

　　D、3

　　%为求余运算符，该运算符只能对整型数据进行运算。且符号与被模数相同。5%2=1; 5%(-2)=1;(-5)%2=-1;(-5)%(-2)=-1;

　　/为求商运算符，该运算符能够对整型、字符、浮点等类型的数据进行运算，5/2=2

　　11.如果int a=3,b=4;则条件表达式"aA、 3

　　B、 4

　　C、 0

　　D、1

　　详见教材P97.

　　表达式1?表达式2：表达式3

　　先计算表达式1，

　　若表达式1成立， 则选择计算表达式2，并表达式2的值作为整个大表达式的值;

　　若表达式1不成立，则选择计算表达式3，并将表达式3的值作为整个大表达式的值

　　此题中的aa为3，b为4。a12.若int x=2,y=3,z=4 则表达式x

　　A、4

　　B、3

　　C、2

　　D、0

　　E)1

　　13.C语言中，关系表达式和逻辑表达式的值是( B ) 。

　　A、0

　　B、 0或1

　　C、 1

　　D、‘T’或’F’

　　14. 下面( D )表达式的值为4.

　　A、 11/3

　　B、 11.0/3

　　C、 (float)11/3

　　D、 (int)(11.0/3+0.5)

　　14~16题为同一类型

　　详见教材P54~56.

　　(1)相同数据类型的元素进行数*算(+、-、*、/)得到结果还保持原数据类型。

　　(2)不同数据类型的元素进行数*算，先要统一数据类型，统一的标准是低精度类型转换为高精度的数据类型。

　　选项A，11与3为两个整数，11/3结果的数据类型也应为整数，因此将3.的小数部分全部舍掉，仅保留整数，因此11/3=3.

　　选项B，11.0为实数，3为整数，因此首先要统一数据类型，将整型数据3转换为3.0，转换后数据类型统一为实型数据，选项B变为11.0/3.0,结果的数据类型也应为实型数据，因此选项B 11.0/3=3.

　　选项C，先将整数11强制类型转换，转换为实型11.0，因此选项C变为11.0/3，其后计算过程、结果与选项B同

　　选项D，首先计算11.0/3，其计算过程、结果与选项B同，得到3.;再计算3.+0.5=4.，最后将4.强制类型转换为整型，即将其小数部分全部舍掉，结果为4

　　15.设整型变量 a=2，则执行下列语句后，浮点型变量b的值不为0.5的是( B　)

　　A、b=1.0/a

　　B、b=(float)(1/A、

　　C、b=1/(float)a

　　D、b=1/(a*1.0)

　　16. 若“int n; float f=13.8;”,则执行“n=(int)f%3”后，n的值是(A)

　　A、1

　　B、4

　　C、4.

　　D、4.6

　　“(int)f“表示将f中的值强制类型转换为整型，即将13.8的小数部分舍掉，转换为13;然后计算13%3，结果为1，再将结果赋给变量n，因此n的值为1

　　17. 以下对一维数组a的正确说明是： D

　　A、char a(10);

　　B、 int a[];

　　C、int k=5，a[k];

　　D、char a[3]={‘a’,’b’,’c’};

　　详见教材P143~144，一维数组的定义、初始化

　　类型符 数组名 [常量表达式]

　　类型符是指数组中数组元素的类型;数组名要符合标识符命名规则;常量表达式是指数组的长度(数组中包含元素的个数)，其值只能是整数，不可以是变量，而且从1开始计数。

　　选项A，常量表达式只能放在中括号 [ ]中

　　选项B，只有在对数组初始化(即赋值)的时候才可以省略数组的长度，B中并未对a进行初始化。

　　选项C，常量表达式不能为变量。

　　18.以下能对一维数组a进行初始化的语句是:( C )

　　A、int a[5]=(0,1,2,3,4,)

　　B、 inta(5)={}

　　C、 int a[3]={0,1,2}

　　D、 int a{5}={10*1}

　　详见教材P145，一维数组的定义、初始化

　　选项B,D，常量表达式只能放在中括号 [ ]中

　　选项A，数组可以看做是若干个相同数据类型元素的有序集合，因此以集合的形式对其初始化，使用{ }对其初始化，选项A用了().

　　19.在C语言中对一维整型数组的正确定义为 D 。

　　A、int a(10);

　　B、int n=10,a[n];

　　C、int n;a[n];

　　D、#define N 10

　　int a[N];

　　20、已知：int a[10]; 则对a数组元素的正确引用是( D )。

　　A、a[10]

　　B、a[3.5]

　　C、a(5)

　　D、a[0]

　　详见教材P144，数组元素的引用

　　数组名[下标]

　　引用数组元素时，[ ]中的下标为逻辑地址下标，只能为整数，可以为变量，且从0开始计数

　　int a[10]表示定义了一个包含10个整型数据的数组a，数组元素的逻辑地址下标范围为0~9，即a[0] 表示组中第1个元素; a[1] 表示组中第2个元素; a[2] 表示组中第3个元素; ......;a[9] 表示组中第10个元素.

　　选项A，超过了数组a的逻辑地址下标范围;

　　选项B，逻辑地址下标只能为整数

　　选项C，逻辑地址下标只能放在[ ]中

　　21.若有以下数组说明，则i=10;a[a[i]]元素数值是(C　)。

　　int a[12]={1,4,7,10,2,5,8,11,3,6,9,12};

　　A、10

　　B、9

　　C、6

　　D、5

　　先算a[a[i]]内层的a[i]，由于i=10,因此a[i]即a[10].

　　a[10]对应下面数组中的元素为9. 因此a[a[i]]即为a[9]

　　a[9]对应下面数组中的元素为6. 因此a[9]即为6

　　22.若有说明：int a[][3]={{1,2,3},{4,5},{6,7}}; 则数组a的第一维的大小为: ( B )

　　A、2

　　B、3

　　C、4

　　D、无确定值

　　5 7

　　D、3 6 9

　　二维数组的一维大小，即指二维数组的行数，在本题中，按行对二维数组赋值，因此内层有几个大括号，数组就有几行

　　23.对二维数组的正确定义是(C　)

　　详见教材P149~152，二维数组的定义、初始化

　　类型符 数组名 [常量表达式][常量表达式]

　　二维数组可以看做是矩阵

　　类型符是指数组中数组元素的类型;数组名要符合标识符命名规则;第一个常量表达式是指数组的行数;第二个常量表达式是指数组的列数;常量表达式的值只能是整数，不可以是变量，而且从1开始计数。

　　一维数组初始化时可以省略数组长度

　　二维数组初始化时可以省略行数，但不能省略列数

　　选项A,B，都省略了列数

　　选项D，不符合二维数组定义的一般形式，行、列常量表达式应该放在不同的[]中

　　A、int a[ ][ ]={1,2,3,4,5,6};

　　B、int a[2] []={1,2,3,4,5,6};

　　C、int a[ ] [3]={1,2,3,4,5,6};

　　D、int a[2,3]={1,2,3,4,5,6};

　　24.已知int a[3][4];则对数组元素引用正确的是__C___

　　A、a[2][4]

　　B、a[1,3]

　　C、a[2][0]

　　D、a(2)(1)

　　详见教材P150，数组元素的引用

　　数组名[下标] [下标]

　　引用数组元素时，[ ]中的下标为逻辑地址下标，只能为整数，可以为变量，且从0开始计数

　　第一个[下标]表示行逻辑地址下标，第二个[下标]表示列逻辑地址下标。

　　本题图示详见P149图6.7

　　因此a的行逻辑地址范围0~2;a的列逻辑地址范围0~3;

　　选项A，列逻辑地址下标超过范围

　　选项B,D，的引用形式不正确。

　　25.C语言中函数返回值的类型是由 A 决定的.

　　A、函数定义时指定的类型

　　B、 return语句中的表达式类型

　　C、 调用该函数时的实参的数据类型

　　D、形参的数据类型

　　26. 在C语言中，函数的数据类型是指(A )

　　A、 函数返回值的数据类型

　　B、 函数形参的数据类型

　　C、 调用该函数时的实参的数据类型

　　D、任意指定的数据类型

　　27.在函数调用时，以下说法正确的是( B　)

　　A、函数调用后必须带回返回值

　　B、实际参数和形式参数可以同名

　　C、函数间的数据传递不可以使用全局变量

　　D、主调函数和被调函数总是在同一个文件里

　　28. 在C语言中，表示静态存储类别的关键字是: ( C )

　　A、 auto

　　B、 register

　　C、static

　　D、extern

　　29.未指定存储类别的变量，其隐含的存储类别为(A )。

　　A、auto

　　B、static

　　C、extern

　　D、register

　　30. 若有以下说明语句：

　　struct student

　　{ int num;

　　char name[ ];

　　float score;

　　}stu;

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

　　A、 struct是结构体类型的关键字

　　B、 struct student 是用户定义的结构体类型

　　C、 num, score都是结构体成员名

　　D、 stu是用户定义的结构体类型名

　　31.若有以下说明语句：

　　struct date

　　{ int year;

　　int month;

　　int day;

　　}brithday;

　　则下面的叙述不正确的是__C___.

　　A、 struct是声明结构体类型时用的关键字

　　B、 struct date 是用户定义的结构体类型名

　　C、 brithday是用户定义的结构体类型名

　　D、year,day 都是结构体成员名

　　32. 以下对结构变量stul中成员age的非法引用是 B

　　struct student

　　{ int age;

　　int num;

　　}stu1,*p;

　　p=&stu1;

　　A、 stu1.age

　　B、 student.age

　　C、 p->age

　　D、(*p).age

　　33.设有如下定义：

　　struck sk

　　{ int a;

　　float b;

　　}data;

　　int *p;

　　若要使P指向data中的a域，正确的赋值语句是 C

　　A、 p=&a;

　　B、 p=datA、a;

　　C、p=&datA、a;

　　D、*p=datA、a;

　　34.设有以下说明语句：

　　typedef struct stu

　　{ int a;

　　float b;

　　} stutype;

　　则下面叙述中错误的是( D )。

　　A、struct是结构类型的关键字

　　B、struct stu是用户定义的`结构类型

　　C、a和b都是结构成员名

　　D、stutype是用户定义的结构体变量名

　　35.语句int *p;说明了 C 。

　　A、p是指向一维数组的指针

　　B、p是指向函数的指针,该函数返回一int型数据

　　C、p是指向int型数据的指针 // 指针的定义教材P223

　　D、p是函数名,该函数返回一指向int型数据的指针

　　36.下列不正确的定义是(　A )。

　　A、int *p=&i,i;

　　B、int *p,i;

　　C.int i,*p=&i;

　　D、int i,*p;

　　选项A先定义一个整型指针变量p，然后将变量i的地址赋给p。然而此时还未定义变量i因此编译器无法获得变量i的地址。(A与C对比，选项C先定义变量i，则在内存中为i分配空间，因此i在内存空间的地址就可以确定了;然后再定义p，此时可以为p赋i的地址，C正确)

　　37. 若有说明：int n=2,*p=&n,*q=p,则以下非法的赋值语句是: (　D )

　　A、p=q

　　B、*p=*q

　　C、n=*q

　　D、p=n

　　p,q同为整型指针变量，二者里面仅能存放整型变量的地址。

　　选项A，q中为地址，因此可将此地址赋给p

　　选项B，*p表示p所指向对象n的内容，即一个整数;*q表示q所指向对象的内容，由于在定义q时为其初始化，将p中n的地址给q，因此p中存放n的地址，*q表示q所指向对象n的内容.因此*p=*q 相当于 n=n;

　　选项C，n=*q 等价于n=n;

　　选项D，p中只能存放地址，不能将n中的整数值赋给p

　　38.有语句：int a[10],;则 B 是对指针变量p的正确定义和初始化。

　　A、int p=*a;

　　B、int *p=a;

　　C、int p=&a;

　　D、int *p=&a;

　　选项A，a是数组名，不是指针变量名，因此不可用*标注数组名a

　　选项C，a是数组名，数组名就是地址，无需再用地址符号。而且在定义指针变量p时，应在变量名前加*，标明p是指针变量

　　选项D，a是数组名，数组名就是地址，无需再用地址符号。

　　39.若有说明语句“int a[5],*p=a;”,则对数组元素的正确引用是( C )。

　　A、a[p]

　　B、p[a]

　　C、*(p+2)

　　D、p+2

　　首先定义一个整型数组a，a的长度为5，然后定义一个指针变量p，并同时对p进行初始化，将数组a的地址赋给p。因此此时p中存放的数组a的首地址，即数组中第一个元素a[0]的地址。

　　对于数组元素下标的引用(详见p144), 一般形式 数组名[下标] 其中下标为逻辑地址下标，从0开始计数，方括号中的下标可以是变量，可以是表达式，但结果一定要是整数。

　　选项A，p中存放的是地址，不是整数，不能做数组元素的下标

　　选项B，a是数组名，数组名就是地址，不是整数，不能做数组元素的下标

　　选项C，(重点!!!详见p231~234) p+2表示指向同一数组中的下两个元素的地址，当前p指向a[0]，则p+2表示a[2]的地址，因此*(p+2)表示a[2]的内容

　　40. 有如下程序

　　int a[10]={1,2,3,4,5,6,7,8,9,10},*P=a;

　　则数值为9的表达式是 B

　　A、 *P+9

　　B、 *(P+8)

　　C、 *P+=9

　　D、P+8

　　(重点!!!详见p231~234)

　　首先定义一个整型数组a，a的长度为5，然后定义一个指针变量P，并同时对P进行初始化，将数组a的地址赋给P。因此此时P中存放的数组a的首地址，即数组中第一个元素a[0]的地址。

　　数组中9对应的是a[8], 选项B，P+8表示数组中后8个元素的地址，即a[8]的地址。*(P+8)则表示该地址内所存放的内容，即a[8]的值。

　　选项A，*P表示P所指向对象的内容，此时P指向a[0], *P即a[0]的值1. *P+9=1+9=10

　　选项C，*P表示P所指向对象的内容，此时P指向a[0], *P即a[0]的值。因此*P+=9 即*P =*P+9, 等价于a[0]=a[0]+9.

　　选项D，P+8表示数组中后8个元素的地址，即a[8]的地址，而非a[8]中的值。

　　41. 在C语言中，以 D 作为字符串结束标志

　　A、’ ’

　　B、’ ’

　　C、 ’0’

　　D、’’

　　42.下列数据中属于“字符串常量”的是(　A )。

　　A、“a”

　　B、{ABC}

　　C、‘abc’

　　D、‘a’

　　若干个字符构成字符串

　　在C语言中，用单引号标识字符;用双引号标识字符串

　　选项B，C，分别用{}和’’标识字符串

　　选项D，标识字符。

　　43.已知char x[]="hello", y[]={"h","e","a","b","e"};, 则关于两个数组长度的正确描述是 B .

　　A、相同

　　B、x大于y

　　C、x小于y

　　D、以上答案都不对

　　C语言中，字符串后面需要一个结束标志位""，通常系统会自动添加。

　　对一维数组初始化时可采用字符串的形式(例如本题数组x)，也可采用字符集合的形式(例如本题数组y)。在以字符串形式初始化时，数组x不尽要存储字符串中的字符，还要存储字符串后的结束标志位，因此数组x的长度为6;在以字符集合形式初始化时，数组y，仅存储集合中的元素，因此数组y长度为5。

C语言测试题及答案2

　　(1)算法的时间复杂度是指_______。

　　A)执行算法程序所需要的时间

　　B)算法程序的长度

　　C)算法执行过程中所需要的基本运算次数

　　D)算法程序中的指令条数

　　答案：C

　　评析：所谓算法的时间复杂度，是指执行算法所需要的计算工作量。

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

　　A)线性表是线性结构B)栈与队列是非线性结构

　　C)线性链表是非线性结构D)二叉树是线性结构

　　答案：A

　　评析：一般将数据结构分为两大类型：线性结构与非线性结构。线性表、栈与队列、线性链表都是线性结构，而二叉树是非线性结构。

　　(3)下面关于完全二叉树的叙述中，错误的是_________。

　　A)除了最后一层外，每一层上的结点数均达到最大值

　　B)可能缺少若干个左右叶子结点

　　C)完全二叉树一般不是满二叉树

　　D)具有结点的完全二叉树的深度为[log2n]+1

　　答案：B

　　评析：满二叉树指除最后一层外每一层上所有结点都有两个子结点的二叉树。完全二叉树指除最后一层外，每一层上的结点数均达到最大值，在最后一层上只缺少右边的若干子结点(叶子结点)的二叉树。

——c语言中%s的用法3篇

c语言中%s的用法1

　　%s在C语言中代表字符串型格式符。

　　%c和%s一般用在printf、sprintf等字符串格式化函数中，用于决定格式化参数的数据类型。如printf("%s", a)会将变量a作为字符串类型进行格式化。

　　%s需要配合printf函数一起使用，如下所示：

　　printf("%s","adfds");//输出字符串adfds。

　　c语言中%s的搭配用法：

　　C语言的格式输出中，%c，%s这些代表要输出的数据的数据类型，例如：

　　1、%d：十进制有符号整数。

　　2、%u：十进制无符号整数。

　　3、%f：浮点。

　　4、%s：字符串。

——大学《C语言》试题及答案3篇

大学《C语言》试题及答案1

　　改错题(每个程序只有一个错误，填入错误语句所在的行号以及修改后的语句)

　　1、下段程序的功能是先输入一个整数，然后将输入的整数输出。

　　1 main()

　　2 {int x;

　　3 scanf(“%d”,x);

　　4 printf(“x=%d\n”,x); }

　　行号：3 改为：scanf(“%d”,&x);

　　2、下段程序的功能是求1+2+3+4+……+99+100的和。

　　1 main()

　　2 { int j=1,sum=0;

　　3 while(j<=100)

　　4 sum=sum+j;j++;

　　5 printf(“%d”,sum);}

　　行号：4 改为：{sum=sum+j;j++; ｝

　　3、下段程序的.功能是当输入x的值为90时，输出“right”，否则输出“error”。

　　1 main()

　　2 { int x;

　　3 if (x=90) printf(“right”);

　　4 else printf(“error”);}

　　行号：3 改为： if (x==90) printf(“right”);

　　(4)下面程序的功能是输出字符串S

　　1 main()

　　2 { char s[]=”china”;

　　3 printf(“s=%s\n”,s[]);}

　　行号： 3 改为： printf(“s=%s\n”,s);

　　(5)下面程序的功能是按照下面的格式输入a和b的值，计算y=a2+b2并输出。

　　输入： 3 2 ?

　　输出： y=13

　　1 main()

　　2 { int a,b;

　　3 int y;

　　4 scanf(“a=%d,b=%d”,&a,&b);

　　5 y=a*a+b*b;

　　6 printf(“y=%d\n”,y);

　　7 }

　　行号： 4 改为：scanf(“%d, %d”,&a,&b);