请简述以下两个for循环的优缺点（5分）
1）for (i=0; i&n; i++)
if (condition)
DoSomething();
DoOtherthing();
2）if (condition)
for (i=0; i&n; i++)
DoSomething();
for (i=0; i&n; i++)="" dootherthing();="" }=""
[问答题] 请简述以下两个for循环的优缺点（5分）
1）for (i=0; i&n; i++)
if (condition)
DoSomething();
DoOtherthing();
2）if (condition)
for (i=0; i&n; i++)
DoSomething();
for (i=0; i&n; i++)="" dootherthing();="" }=""
正确答案：
答案解析 1）优点：程序简洁。="" 缺点：多执行了n-1次逻辑判断，并且打断了循环“流水线”作业，使得编译器不能对循环进行优化处理，降低了效率。="" 2）优点：循环的效率高。缺点：程序不简洁。=""
发表or还没有账号？去
realloc函数在使用上要注意什么问题。
C语言的const的含义是什么。在定义常量时，为什么推荐使用const，而不是#define。
如何在两个.c文件中引用对方的变量。
如何让局部变量具有全局生命期。
要使用CHAR_BIT需要包含哪个头文件。
C语言的volatile的含义是什么。使用时会对编译器有什么暗示。
C语言的词法分析在长度规则方面采用的是什么策略？
对(-1.2345)取整是多少？
如何在C中为一个数组分配空间。
s[10]的另外一种表达方式是什么。
能动手，就不吵吵!
下载APP，为一份好工作而努力!
(JAVA/android/IOS)
QQ一群: 已满（C/C++/C#/PHP）
bishi.jisupeixun (C)2015 All rights reserved&&/&&&&/&&
用if语句可以构成分支结构。它根据给定的条件进行判断，以决定执行某个分支程序段。C语言的if语句有三种基本形式。
语句的三种形式
1) 第一种形式为基本形式：if
& & & & if(表达式) 语句
其语义是：如果表达式的值为真，则执行其后的语句，否则不执行该语句。其过程可表示为下图。
#include &stdio.h&
int main(void){
printf(&\n input two numbers:
scanf(&%d%d&,&a,&b);
if (max&b) max=b;
printf(&max=%d&,max);
本例程序中，输入两个数a、b。把a先赋予变量max，再用if语句判别max和b的大小，如max小于b，则把b赋予max。因此max中总是大数，最后输出max的值。
2) 第二种形式为: if-else
if(表达式)&
& & 语句1;
& & 语句2;
其语义是：如果表达式的值为真，则执行语句1，否则执行语句2 。其执行过程可表示为下图。
#include &stdio.h&
int main(void){
printf(&input two numbers:
scanf(&%d%d&,&a,&b);
printf(&max=%d\n&,a);
printf(&max=%d\n&,b);
输入两个整数，输出其中的大数。改用if-else语句判别a,b的大小，若a大，则输出a，否则输出b。
3) 第三种形式为if-else-if形式
前二种形式的if语句一般都用于两个分支的情况。当有多个分支选择时，可采用if-else-if语句，其一般形式为：
& & &if(表达式1)
&&&&&&& 语句1;
&&& else& if(表达式2)&
&&&&&&& 语句2;
&&& else& if(表达式3)&
&&&&&&& 语句3;
&&&&&&& &&
&&& else& if(表达式m)&
&&&&&&& 语句m;
&&&&&&& 语句n;
其语义是：依次判断表达式的值，当出现某个值为真时，则执行其对应的语句。然后跳到整个if语句之外继续执行程序。 如果所有的表达式均为假，则执行语句n。然后继续执行后续程序。 if-else-if语句的执行过程如下图所示。
#include &stdio.h&
int main(void){
printf(&input a character:
c=getchar();
printf(&This is a control character\n&);
else if(c&='0'&&c&='9')
printf(&This is a digit\n&);
else if(c&='A'&&c&='Z')
printf(&This is a capital letter\n&);
else if(c&='a'&&c&='z')
printf(&This is a small letter\n&);
printf(&This is an other character\n&);
本例要求判别键盘输入字符的类别。可以根据输入字符的ASCII码来判别类型。由ASCII码表可知ASCII值小于32的为控制字符。在&0&和&9&之间的为数字，在&A&和&Z&之间为大写字母， 在&a&和&z&之间为小写字母，其余则为其它字符。这是一个多分支选择的问题，用if-else-if语句编程，判断输入字符ASCII码所在的范围，分别给出不同的输出。例如输入为&g&，输出显示它为小写字符。
在使用if语句中还应注意以下问题：
在三种形式的if语句中，在if关键字之后均为表达式。 该表达式通常是逻辑表达式或关系表达式，但也可以是其它表达式，如赋值表达式等，甚至也可以是一个变量。例如：
& & if(a=5) 语句;
& & if(b) 语句;
都是允许的。只要表达式的值为非0，即为&真&。如在：
& & if(a=5)&;
中表达式的值永远为非0，所以其后的语句总是要执行的，当然这种情况在程序中不一定会出现，但在语法上是合法的。
又如，有程序段：
printf(&%d&,a);
printf(&a=0&);
本语句的语义是，把b值赋予a，如为非0则输出该值，否则输出&a=0&字符串。这种用法在程序中是经常出现的。
在if语句中，条件判断表达式必须用括号括起来，在语句之后必须加分号。
在if语句的三种形式中，所有的语句应为单个语句，如果要想在满足条件时执行一组(多个)语句，则必须把这一组语句用{}括起来组成一个复合语句。但要注意的是在}之后不能再加分号。例如：
if(a&b){a++;
if语句的嵌套
当if语句中的执行语句又是if语句时，则构成了if 语句嵌套的情形。其一般形式可表示如下：
& & if(表达式)&
& & & & if语句;&
& & if(表达式)&
& & & & if语句；&
& & & & if语句；
在嵌套内的if语句可能又是if-else型的，这将会出现多个if和多个else重叠的情况，这时要特别注意if和else的配对问题。例如：
& & if(表达式1)
& & & & if(表达式2)
& & & & & & 语句1;
& & & & else
& & & & & & 语句2;
其中的else究竟是与哪一个if配对呢？应该理解为：
& & if(表达式1)
& & & & if(表达式2)
& & & & & & 语句1;
& & & & else
& & & & & & 语句2;
还是应理解为：
& & if(表达式1)
& & & & if(表达式2)
& & & & & & 语句1;
& & & & 语句2;
为了避免这种二义性，C语言规定，else 总是与它前面最近的if配对，因此对上述例子应按前一种情况理解。
#include &stdio.h&
int main(void){
printf(&please input A,B:
scanf(&%d%d&,&a,&b);
printf(&A&B\n&);
printf(&A&B\n&);
printf(&A=B\n&);
比较两个数的大小关系。本例中用了if语句的嵌套结构。采用嵌套结构实质上是为了进行多分支选择，实际上有三种选择即A&B、A&B或A=B。这种问题用if-else-if语句也可以完成。而且程序更加清晰。因此，在一般情况下较少使用if语句的嵌套结构。以使程序更便于阅读理解。
#include &stdio.h&
int main(void){
printf(&please input A,B:
scanf(&%d%d&,&a,&b);
if(a==b) printf(&A=B\n&);
else if(a&b)
printf(&A&B\n&);
printf(&A&B\n&);
推荐文章 TOP10优先级：当表达式中存在不同优先级的运算符参与操作；（1）算数运算符；算数运算符是C语言中使用较多的的运算符号，不同的；表3-1-4算术运算；虽然对于基本数据类型的变量进行++、--运算完全；n=n±1则要对应3条机器指令；自增、自减运算符的运算对象只能是简单变量，不能是；赋值运算符：“=”；（2）关系运算符；关系运算符用来测试两个操作数之间的关系；表3-1-
优先级：当表达式中存在不同优先级的运算符参与操作时，优先级较高的先于优先级 较低的进行运算。
结合性：当表达式中各种运算符优先级相同时，由运算符的结合性确定表达式的运算顺序。一类运算符的结合性为从左到右（占多数运算符），这是人们习惯的运算顺序；另一类运算符的结合性是从右到左，即单目、三目和赋值运算符。
（1）算数运算符
算数运算符是C语言中使用较多的的运算符号，不同的运算符用法见表表2-1-4所示，为了便于了解运算符的应用，表中假设a等于8，b等于2。
表3-1-4算术运算
虽然对于基本数据类型的变量进行++、--运算完全可以用n=n±1完成，但使用++、--运算可以提高程序的执行效率。这是因为++、--运算只需要一条机器指令就可以完成，而
n=n±1则要对应3条机器指令。
自增、自减运算符的运算对象只能是简单变量，不能是常量或是带有运算符的算式。例如，123++、（x+y）++是错误的。
赋值运算符：“=”。 赋值运算符是一个双目运算符，其结合性是从右至左。赋值运算符的左边部分称为左值，左值只能是一个变量；赋值运算符的右边部分称为右值，右值可以是一个表达式。赋值表达式：由“=”连接的式子称为赋值表达式。其功能是将赋值号右边表达式的结果送到左边的变量中保存。“==”和“=”是两种完全不同的运算符，前者为关系运算符中的相等运算符，后者为赋值运算符。
（2）关系运算符
关系运算符用来测试两个操作数之间的关系。C语言中的关系运算符均为双目运算符，包括&(大于)，&(小于)，&=(大于等于)，&=(小于等于)，==（等于），！=（不等于），其中前4个的优先级相同且高于后两个的优先级（后两个的优先级相同）。关系运算符主要用在条件语句中，其结果为逻辑值（或称为布尔值）。如果比较后关系式成立，则称之为“真”（结果为非0）；如果比较后关系式不成立，则称之为“假”（结果为0）。如表2-1-5所示。
（3）逻辑运算符
逻辑运算符用于对几个关系运算表达式的运算结果进行组合，做出综合的判断。逻辑运算的结果以非0为“真”，0为“假”。如果A代表一个关系表达式的运算结果，B代表另一个关系表达式的运算结果，则A和B的各种逻辑运算的真值关系如表2-1-6所示。
逻辑运算真值表
对于与运算，全真为真，有假为假；对于或运算，有真为真，全假为假。 C语言程序中可以使用以下的逻辑运算，逻辑运算的结果是一个布尔值：TRUE 或FALSE。在以下的运算中，假设a=8,如表2-1-6所示。
逻辑运算 （4）位运算符
位逻辑运算是针对运算元的每一个位逐一地实施逻辑运算。在以下的运算中假设
a=5，如表3-1-7所示。
位运算 3.1.3程序的三种基本控制结构
程序的三种基本控制结构为顺序结构、选择结构和循环结构，这三种基本结构可以组成所有的复杂程序。
一、顺序结构
顺序结构是C语言程序最简单的程序结构，是构成复杂程序的基础。仅包含顺序结构的程序会按照语句的书写顺序执行。
C语言程序是由若干语句组成的，每个语句以分号作为结束符。C语言的语句可以分为5类，分别是控制语句、表达式语句 、函数调用语句、空语句和复合语句。除了控制语句外，其余4类都属于顺序执行语句。
（1）表达式语句
表达式语句由表达式加上分号组成的，最常见的就是赋值语句，它是由一个赋值表达
式后跟一个分号形成。例如：
//将7赋值给变量
事实上，任何表达式都可以加上分号而成为语句，例如：
//使i变量的值加1
（2）函数调用语句
由函数调用加上分号组成，例如：
//调用延时函数
函数是一段程序，这段程序可能存在于函数库中，也可能是由用户自己定义的当调用函数时会转到该程序执行。但函数调用语句与前后语句之间的关系是按顺序执行的。
（3）空语句
只有分号组成的语句称为空语句。在程序中，如果没有什么操作需要进行，但从语句的结构上来说必须有一个语句在进，可以书写一个空语句。
（4）复合语句
把多个语句用大括号“｛｝”括号来组成一个语句称复合语句。 例如：
delay(); LED=!LED;
复合语句内的各条语句都必须以分号结尾，在大括号外不能加分号。 二、选择结构
在解决实际问题中，有进需要根据给定的条件来做决定，即条件满足时做什么，条件不满足时做什么。选择结构程序可解决这类问题，其作用是根据所给定的两个或多个分支中，选择其中的一个分支来执行。C语言中有两种选择结构语句，即if语句和switch-case语句。
（1）if语句
1） 单分支if语句结构
if(条件）语句1；
如果表达式的值为真，则执行其后的语句，否则不执行该语句；
2）双分支if 语句
双分支if语句的语法格式如下：
if(表达式)语句1； else 语句2;
如果表达式的值的为真，则执行语句1，否则执行语句2其中else的部分可以省略。电脑首先判断if后面的条件是真还是假，如果是真就执行语名1，否则就执行语句2。else子句不能作为语句单独使用，必须与if配对使用。例如：
if(i&3) i=0; else i=2;
嵌套if语句是指if语句中又有if语句，：
当if语句嵌套使用时，会出现if与else的配对问题。C语言规定，else总是与其上面最近的if 配对。如果要改变这种默认的配对关系，可以在相应的if选择语句上加上”{}”来重新确定配对关系。
3）多分支if 语句
多分支语句的语法格式如下：
if (表达式1)语句1； else if(表达式2)语句2；
else if (表达式n)语句n;
else 语句n+1;
依次判断表达式的值，当出现某个值为真时，则执行其对应的语句。然后跳到整个if语句之外继续执行程序。如果所有的表达式均为假，则执行语句n。然后继续执行。
（2）switch-case语句
使用语句的嵌套结构实现多分支选择功能时，程序的结构显得不够清晰，因此使用switch语句。switch 语名的格式：
switch (变量）
case 常量1：语句1； case 常量2：语句2； case 常量3：语句3； ......
计算表达式的值，并将其逐个与其后的常量表达式的值相比较，当表达式的值与某个常量表达式的值相等时，即执行其后的语句，而不再进行判断，但继续执行case后面所有的语句；如果表达式的值与所有case后的常量表达式均不相同时，则执行default后的语句。
case后的语句既可以是单个语句，也可以是复合语句，不需要用大括号括起来。case常量表达式和default子句可以按任何顺序出现，但其本身不改变控制流程。
switch号内的表达式的值和case后面常量表达式的值，都必须是整型的或字符型的，不允许是实数在后的各个常量表达式的值不能相同。否则会出现错误。
三、循环结构
循环是计算机解题的一个重要特征。其特点是，在给定条件成立时，反复执行某程序段，直到条件不成立为止。给定的条件称为循环条件，反复执行的程序段称为循环体。C语言提供了5种循环语句：while语句、do-while语句、for语句、goto语句和if语句。
（1）for循环
for 循环格式如下：
for（表达式1；表达式2；表达式3）
语句或{程序}；
执行过程是：(1)计算“表达式1”；(2)进行第一轮循环：“计算表达式2”，若值为假，则退出循环；否则执行“语句”；(3)计算“表达式3”；(4)进行第二轮循环：计算“表达式2”，若值为假，则退出循环；否则执行“语句”；(5)计算“表达式3”??其执行过程如图所示。
图2.1.1 for循环语句的执行流程
for(i=1;i&=200;i++)
//延时一段时间
for(j=1;j&=200;j++);
//前一个for语句的循环体
“表达式1”、“表达式2”，和“表达式3”都是选择项，可以省略，但其后的分号不能省略。省略“表达式1”，表示不对循环控制变量赋初值。省略“表达式2”，则不作其他处理时变成为死循环，需要在循环体中用break等语句退出循环。省略表达式3，则不对循环控制变量进行操作，这进可在语句体中加入修改循环控制变量的语句。“表达式1”和“表达式3”可以同时省略，需要使用相关语句保证循环结束。3个表达式都可省略。例如，for(; ;)语句相当于while(1)语句。
（2）while 循环
while语句的使用格式：
while（表达式）语句；
计算表达式的值，当值为真(非0)时，执行循环体语句。例如：
while(i--) a=a++;
当循环体由多个语句组成时，必须用大括号括起来，使其形成复合语句。
while(i&5)
下面是一个无穷while循环：
（3）do/while 循环
do-while语句的使用格式如下：
语句或{程序}； while(表达式)；
do-while 循环与while循环的不同在于，do-while循环语句先执行循环中的语
包含各类专业文献、行业资料、生活休闲娱乐、文学作品欣赏、各类资格考试、幼儿教育、小学教育、外语学习资料、第三讲-C语言基础03等内容。　
　5 C语言 第三讲 基础语句 C语言讲解C语言讲解隐藏&& 从程序流程的角度来看,程序可以分为三种基本结构, 即顺序结构、分支结构、循环 结构。 这三种基本结构可以组... 　第三讲 C++语言基础 C++语言基础 例 1-1 示例 C++程序的基本组成。 //example...c; cin&&a&&b; c=max(a,b); //函数调用 cout&&&max is:&&&c&&... 　第三讲 C语言的数据类型_IT/计算机_专业资料。C语言的数据类型C语言的数据类型简述 语言的数据类型简述 3.1、数据类型可分为:基本数据类型,构造数据类型,指针类型,... 　C语言中的常用函数 4页 免费 Javascript基础教程(文字版... 74页 免费 C语言...C语言C语言隐藏&& C 语言第三讲 变量与函数 教学重点 1、变量的含义和定义规则... 　C语言第3讲--数据的基本... 32页 1下载券 c语言操作第1---3章 5页 免费...第3 讲 作业 1、与“3 乘以 x 的 n 次方,除以 2 乘 x 减 1” ,对应... 　95页 免费 第三讲-C语言基础 26页 免费 C语言基础知识 10页 2财富值如要投诉违规内容,请到百度文库投诉中心;如要提出功能问题或意见建议,请点击此处进行反馈。 ... 　C语言基础 78页 免费 第三讲-C语言基础 26页 免费 第1章 C语言基础 38页 免费 第二讲 C语言基础知识 暂无评价 42页 免费 C语言基础题 30页 2财富值喜欢... 　第三讲-C语言基础 26页 免费 第1章 C语言基础 38页 免费 第2章 c语言基础 45页 2财富值 C语言基础题 30页 2财富值 c语言公共基础 2页 2财富值 C语言... 　C语言基础 43页 5财富值 C语言基础 78页 免费 C语言基础 6页 2财富值 第三讲-C语言基础 26页 免费 第1章 C语言基础 38页 免费 第2章 c语言基础 45页...> 问题详情
有以下程序 main() { for(i=1;i＜=40;i＋＋) { if(i＋＋%
悬赏：0&答案豆
提问人：匿名网友
发布时间：
有以下程序 main() { for(i=1;i＜=40;i＋＋) { if(i＋＋%5=0) if(＋＋i%8=0) printf ("%d",i); } printf("\n"); }A．5B．24C．32D．40
论文写作技巧
您可能感兴趣的试题
1以下选项中，值为1的表达式是______。A．1-'0'B．1-'、0'C．'1'-0D．'\0'-'0'2有以下程序　　　　　　　　　fun(int　x,int　y){return(x＋y);}　　　　　　　　　main()　　　　　　　　　{　int　a=1,b=2,c=3,　　　　　　　　　　　　sum=fun((a＋＋,b＋＋,a+b),c＋＋);　　　　　　　　　　　printf("%d\n",sum);　　　　　　　　　}A．6B．7C．8D．9
有如下程序#include void main(){int
a[3][3]={{<a href="/ask/8167075.html" target="_blank" title="#includemain(){ int i, for(i=1;i#includemain(){ int i, for(i=1;i<=3;s
我有更好的答案
相关考试课程
请先输入下方的验证码查看最佳答案
图形验证：
验证码提交中……1.static有什么用途？（请至少说明两种）
1）限制变量的作用域
2）设置变量的存储域（堆，主动分配内存也是堆）
1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。?&&&
&2)&在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。?&&&
&3)&在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
2.全局变量和局部变量在内存中是否有区别？如果有，是什么区别？
全局变量储存在静态数据库，局部变量在栈
3.堆栈溢出一般是由什么原因导致的？
&堆栈溢出一般是循环的递归调用导致的，如果使用的大数据结构的局部变量，也可能导致堆栈溢出。没有回收垃圾资源导致的是内存泄露最后内存耗尽。
4.不能做switch()的参数类型是：
switch的参数不能为实型。（只能是int char）
5.写出float x 与&零值&比&较的if语句。
if(x&0.000001&&x&-0.000001)&&&
6.在c语言库函数中将一个字符转换成整型的函数是atol()吗，这个函数的原型是什么？
函数名: atol
功能:&把字符串转换成长整型数
函数的原型: long atol(const char *nptr);
#include &stdlib.h&
#include &stdio.h&
int main(void)
char *str = "";
l = atol(lstr);
printf("string = %s integer = %ld\n", str, l);
return(0);
7.对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现?
c用宏定义，c++用inline
8.软件测试都有那些种类?
黑盒：针对系统功能的测试&&&&白合：测试函数功能，各函数接口
9.确定模块的功能和模块的接口是在软件设计的那个阶段完成的?
概要设计阶段
10.unsigned char *p1;
&&&unsigned long *p2;&
&&&p1=(unsigned char *)0x801000;
&&& p2=(unsigned long *)0x810000;
&&&请问p1+5=？& ;
&&&&&&&& p2+5=？& ;
答：p1+5=0x801005&;
&&&&&&&&&&p2+5=0x810014& ;
11.请问下面程序有什么错误?
&&int a[60][250][1000],i,j,k;
&&for(k=0;k&1000;k++)
&&&for(j=0;j&250;j++)
&&&& for(i=0;i&60;i++)
&&&&& a[i][j][k]=0;
把循环语句内外换一下
（编译的时候没错，运行的时候出错，但这个数组太大，如果放在栈中，还是会溢出，要作为全局变量）
12.#define Max_CB 500
&&&void LmiQueryCSmd(Struct MSgCB * pmsg)
&&&& unsigned charucCmdN
&&&& ......
&&&&for(ucCmdNum=0;ucCmdNum&Max_CB;ucCmdNum++)
&&&&& ......;
死循环(unsignedchar 0&到&255)
13.以下是求一个数的平方的程序,请找出错误:
&&&#define SQUARE(a)((a)*(a))
&&&int a=5;
b=SQUARE(a++);//a被加了2次& a=7,b=25
14．有一个16位的整数，每4位为一个数，写函数求他们的和。
和& 11+0111
/* n就是16位的数，函数返回它的四个部分之和&*/
char SumOfQuaters(unsigned short n)
&&& char c = 0;
&&& int i = 4;
&&&&&&&c += n & 15;
&&&&&&&n = n && 4;
&&& } while (--i);
15、两个字符串，s,t;把t字符串接到s字符串尾，s字符串有足够的空间存放t字符串
void connect(char *s, char *t, int i)
char *q =t;
char *p =s;
if(q ==NULL)
while(*p!='\0')
while(*q!=0)
*p = '\0';
void main()
charp[7]="ABC";
charp2[]="EFG";
connect(p,p2,3);
printf("%s",p);
16、分析下面的代码：
char *a = "hello";
char *b = "hello";
printf("YES");
printf("NO");
常量字符串。位于静态存储区，它在程序生命期内恒定不变。如果编译器优化的话，会有可能a和b同时指向同一个hello的。则地址相同。如果编译器没有优化，那么就是两个不同的地址，则不同。对VC，是相同。
17、局部变量能否和全局变量重名？ 　
　答：能，局部会屏蔽全局。要用全局变量，需要使用"::" ;局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。
18、如何引用一个已经定义过的全局变量？ 　　
答：extern&　例如在某个.cpp中定义了一个全局变量int a,可在头文件中加入然后在需要引用的文件中包含该头文件。或者直接在文件中加入　　extern a；
19、全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？ 　　
在头文件中用static来定义同名全局变量。
另外某个.C文件中定义的非静态全局变量，可以在其头文件中用extern声明，需引用此全局变量的其他.C只需包含此头文件即可。
20、请写出下列代码的输出内容 　　
#include&&stdio.h&　　
int main(void) 　　
int a,b,c,d;
　　a=10; 　
　　b=a++; 　
　　c=++a; 　
　& d=10*a++;
　　printf("b，c，d：%d，%d，%d"，b，c，d）; 　
　　return 0; 　
答：10，12，120
21、static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？ 　　
答: 1)&全局变量(外部变量)的说明之前再冠以static&就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。
这两者的区别在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。
2)&从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。　　&&&&&&&&&&&&&&&&
3) static函数与普通函数作用域不同,仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件
static全局变量与普通的全局变量有什么区别：
static全局变量只初使化一次，防止在其他文件单元中被引用;
static局部变量和普通局部变量有什么区别：
static局部变量只被初始化一次，下一次依据上一次结果值；
static函数与普通函数有什么区别：
static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝
22、设有以下说明和定义： 　
　 typedef union
int k[5];//20
} DATE; 　
　struct data
&&DATE //20
　DATE 　　
则语句printf("%d",sizeof(struct data)+sizeof(max));的执行结果是：
考点:区别struct与union.(一般假定在32位机器上)
答：DATE是一个union,&变量公用空间.&里面最大的变量类型是int[5],&占用20个字节.&所以它的大小是20. data是一个struct,&每个变量分开占用空间.&依次为int4 + DATE20 + double8 = 32.&所以结果是&20 + 32 = 52.　
23、请找出下面代码中的所有错误 (题目不错,值得一看)　　
说明：以下代码是把一个字符串倒序，如&abcd&倒序后变为&dcba&　　
#include"string.h" 　　
main() 　　
char*src="hello,world";　　
char* dest=NULL; 　　
int len=strlen(src); 　　
dest=(char*)malloc(len); 　　&&
char* d= 　　
char* s=src[len]; 　&&&&&&&&
while(len--!=0) 　　
*d++=*s--; 　　&&&&&&
printf("%s",dest);　　
return 0; 　　
方法1：一共有4个错误;
int main()
char* src ="hello,world";
int len = strlen(src);
char* dest =(char*)malloc(len+1);//要为分配一个空间
char* s =&src[len-1];&&&&&&&&& //指向最后一个字符　　
while( len--!= 0 )
*d++=*s--;
*d = 0;&&&&&&&&&& //尾部要加&\0&
printf("%sn",dest);
free(dest);&&&&&&& //&使用完，应当释放空间，以免造成内存汇泄露
dest = NULL;&//防止产生野指针　
方法2： (方法一需要额外的存储空间,效率不高.)　不错的想法
#include &stdio.h&
#include &string.h&
charstr[]="hello,world";
intlen=strlen(str);
for(int i=0;i&len/2; i++)
str[i]=str[len-i-1];//小心一点
str[len-i-1]=t;
printf("%s",str);
24．Heap与stack的差别。
答:Heap是堆，stack是栈。
Stack的空间由操作系统自动分配/释放，Heap上的空间手动分配/释放。
Stack空间有限，Heap是很大的自由存储区
C中的malloc函数分配的内存空间即在堆上,C++中对应的是new操作符。
程序在编译期对变量和函数分配内存都在栈上进行,且程序运行过程中函数调用时参数的传递也在栈上进行
// 1& 2&4 8 16。。。
// 1&& 10&& 100&&1000&& 1 0000
// 0&&& 1&&& 11&&& 111&&&& 1111
25. 一语句实现x是否为2的若干次幂的判断
#define is2*n(x) ((x & (x - 1))? 0 :1)?
int main(void)?
{?int m = 512;?
cout && ((m & (m - 1)) ? false: true) &&?
//即当m中只有一位为1时，才为若干次幂值
//考试大提示:若有两个及以上1，则(m & (m - 1))不为0，输出0，表示不为2的若干次幂
return(0);?
类比：x为2的若干次幂即表示x中1的位数为1，题目转化为求一个32位数中1的位数，如果为1，则表示该数为2的若干次幂　　同理也可以利用此规则求一个32位数中1的位数，&(m & (m -1)每次可用消除一个1，计算的次数即为1的个数！&
26. 下述三个有什么区别？
char const * p
const char *p
char * //常量指针，p的值不可以修改
char const * p；//指向常量的指针，指向的常量值不可以改
const char *p；&//和char const *p
27. 解释下列输出结果
char str1[] = "abc";
char str2[] = "abc";
const char str3[] = "abc";&
const char str4[] = "abc";
const char *str5 = "abc";
const char *str6 = "abc";
char *str7 = "abc";
char *str8 = "abc";
cout && ( str1 == str2 ) &&
cout && ( str3 == str4 ) &&
cout && ( str5 == str6 ) &&
cout && ( str7 == str8 ) &&
结果是：0 0 1 1
答：str1,str2,str3,str4是数组变量，它们有各自的内存空间；
而str5,str6,str7,str8是指针，它们指向相同的常量区域。节省内存。
28. 以下代码中的两个sizeof用法有问题吗？[C易]
#include &stdio.h&
#include"iostream.h"
void UpperCase( char str[] )// 将 str 中的小写字母转换成大写字母
for( i=0; i&sizeof(str)/sizeof(str[0]); ++i )//是指针的大小4，只循环了4次。数组做参数，会退化为指针。可改为strlen(str)
if( 'a'&=str[i] &&str[i]&='z' )
str[i] -= ('a'-'A' );//由小写转大写
void main()
char str[] = "aBcDefg";
cout && "str字符长度为: " &&sizeof(str)/sizeof(str[0]) &&//是数组的大小6
UpperCase( str );
cout && str &&
答：函数内的sizeof有问题。根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组，因此其大小为8，函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此sizeof作用于上只将其当指针看，一个指针为4个字节，因此返回4。
&&&注意:数组名作为函数参数时,退化为指针.
&&&&&&&&数组名作为sizeof()参数时,数组名不退化,因为sizeof不是函数.
29. 一个32位的机器,该机器的指针是多少位& 2^32& =4G&&&
地址总线宽度决定了CPU可以访问的物理地址空间.简单地说就是CPU到底能够使用多大容量的内存.对于386以上的微机系统.地址线的宽度为32位.最多可以直接访问4096MB (4GB)的物理空间.对大多数人来说已经够用了.
指针是多少位只要看地址总线的位数就行了。80386以后的机子都是32的数据总线。所以指针的位数就是4个字节了。
8位处理器、16位处理器、32位处理器和64位处理器，其计数都是8的倍数。它表示一个时钟周期里，处理器处理的二进制代码数。&0&和&1&就是二进制代码，线路上有电信号，则计做1,没有电信号则为0。8位机有8条线路，每个时钟周期有8个电信号，组成一个字节。所以，随8位处理器上升至64位处理器，每个时钟周期传送1个字节到8个字节，关联到时钟速度提高到若干个千兆赫之后，处理器处理信息的能力越来越大。
CPU&的一次基本运算&(and, or, xor, not),&能处理/运算几个&bits. 64 bits data&交由&32-bit CPU&去运算,&得分两次才行.
30. 指出下面代码的输出，并解释为什么。(不错,对地址掌握的深入挖潜)
int a[5]={1,2,3,4,5};
int *ptr=(int *)(&a+1);//指针是数组类型，+1相当于加20.如果是(a+1)是+4
printf(&%d& %d&,a,ptr)；&
printf("%d,%d",*(a+1),*(ptr-1));
输出：56 2,5
a,&a的地址是一样的，但意思不一样，a是数组首地址，也就是a[0]的地址，&a是对象（数组）首地址，a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的地址，即a[5].
31.请问以下代码有什么问题：
1).int main()
char *str=&a;
strcpy(str,"hello");
printf(str);
答;没有为str分配内存空间，将会发生异常问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。
2).char* s="AAA";//常量的内容不能改，可定义为数组
printf("%s",s);
printf("%s",s);
有什么错？
答:"AAA"是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。
cosnt char* s="AAA";
然后又因为是常量，所以对是s[0]的赋值操作是不合法的。
32.用变量a给出下面的定义
a)一个整型数（An integer）
?b)&一个指向整型数的指针（A pointer to an integer）
c)&一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）
d)&一个有10个整型数的数组（An array of10 integers）
e)&一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers）
?f)&一个指向有10个整型数数组的指针（A pointerto an array of 10 integers）
?g)&一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as anargument and returns an integer）
?h)&一个有10个函数指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（&An array of ten pointers to functions that take aninteger argument and return an integer&）
Int (*p[10])(int);?a) // Aninteger ?
b) int *a; // A pointer to an integer
?c) int **a; // A pointer to apointer to an integer
?d) int a[10]; // An array of 10integers
?e)&int *a[10];&// An array of 10 pointers to integers
?f)&&&&int (*a)[10];&// Apointer to an array of 10 integers
?g) int (*a)(int);// A pointer to afunction a that takes an integer argument and returns an integer
?h) int (*a[10])(int); // An array of10 pointers to functions that take an integer argument and return an integer
33.用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）
#define SECONDS_PER_YEAR (60 * 60 *24 * 365)UL
34.写一个&标准&宏MIN，这个宏输入两个参数并返回较小的一个。
#defineMIN( A,B) ((A) &= (B)&？(A) :(B))&& A &= B&？A : B
35.关键字static的作用是什么？
在C语言中，关键字static有三个明显的作用：
1).&在函数体，一个被声明为静态的全局变量在这一函数被调用过程中维持其值不变。（值的保存）
2).&在模块内（但在函数体外），一个被声明为静态的全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。（限制作用域）
3).&在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。（限制作用域）
36.关键字const是什么含意？下面的声明都是什么意思？
3 const int *a;?& 4 int const *
?5 int * &?6 int const *
答：1、 &2、
3、&4、内容不可变，指针可变：&const int *a;
5、内容不可变，指针可变：&int *
6、内容可变，指针不可变&:&&&intconst * &
37. 关键字volatile有什么含意 并给出三个不同的例子。
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。
精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。
下面是volatile变量的几个例子：
1).&并行设备的硬件寄存器（如：状态寄存器）
2).&一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
3).&多线程应用中被几个任务共享的变量
39. int (*s[10])(int) 表示的是什么？
int (*s[10])(int)&函数指针数组，每个指针指向一个int func(int param)的函数。
40.有以下表达式：
int a=248; b=4;int const c=21;const int *d=&a;
int *const e=&b;int&const&int& *const&f=&a;
请问下列表达式哪些会被编译器禁止？为什么？
*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;
答:*c&这是个什么东东，禁止
d=&b是很OK
e = &a&说了是const&禁止& e的地址不能改
const int& *const f&=&a;&禁止&f的内容和地址都不能改
41.交换两个变量的值，不使用第三个变量。即a=3,b=5,交换之后a=5,b=3;
答:有两种解法,一种用算术算法, 一种用^(异或)
a = a^b;//&只能对int,char..&&
2个bit (bit1与bit2异或，结果为0说明它们不同，则bit2异或0可把bit1还原。
结果为1说明它们相同，则bit2异或1可把bit1还原。
#include &stdio.h&
#include &stdlib.h&
void getmemory(char&*p)//函数的参数是局部变量，在这里给它分配内存还在，但是P释放了。
p=(char *) malloc(100);
int main( )
char *str=NULL;
getmemory(str);
strcpy(str,"helloworld");
printf("%s/n",str);
free(str);
答:&程序崩溃，getmemory中的malloc&不能返回动态内存，&free（）对str操作很危险
解决方案1：可改为按引用传递：void getmemory(char *&p)
解决方案2：返回指针
Char* getmemory(char *p)
p=(char *)malloc(100);
43.char szstr[10];
strcpy(szstr,"");
产生什么结果？为什么？
答;正常输出,长度不一样，会造成非法的OS,覆盖别的内容.&\0&没保存
int *p[n];-----指针数组，每个元素均为指向整型数据的指针。
int (*p)[n];------p为指向一维数组的指针，这个一维数组有n个整型数据。
int *p();----------函数带返回指针，指针指向返回的值。
int (*p)();------p为指向函数的指针。
45. 数组越界问题 (这个题目还是有点小险的)
下面这个程序执行后会有什么错误或者效果:
#define MAX 255
int main()
unsigned char A[MAX],i;
for (i=0;i&=MAX;i++)
解答：MAX=255,数组A的下标范围为:0..MAX-1,这是其一,其二当i循环到255时,循环内执行: A[255]=255;这句本身没有问题，但是返回for (i=0;i&=MAX;i++)语句时,由于unsigned char的取值范围在(0..255),i++以后i又为0了..无限循环下去.
注：char类型为一个字节，取值范围是[-128，127]，unsigned char [0 ,255]
46. C++:memset ,memcpy 和strcpy 的根本区别？
答:#include"memory.h"
memset用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化为' '或''；例:char a[100];memset(a, '', sizeof(a));
memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度；例：char a[100],b[50]; memcpy(b, a, sizeof(b));注意如用sizeof(a)，会造成b的内存地址溢出。
strcpy就只能拷贝字符串了，它遇到'\0'就结束拷贝；例：chara[100],b[50];strcpy(a,b);如用strcpy(b,a)，要注意a中的字符串长度（第一个'\0'之前）是否超过50位，如超过，则会造成b的内存地址溢出。
void main()
chara[100];
memset(a,'a', sizeof(a)-1);
&&& memset(&a[99], '\0',1);
printf("%s\n",a);
charstr1[100]="abc";
charstr2[50]="efghdfkdjf";
memcpy(str1,str2, sizeof(str2));
printf("%s\n",str1);
strcpy(str1,str2);
printf("%s\n",str1);
strcpy&原型：
char *strcpy_su(char *dest,char *src)
assert((dest!=NULL)&&(src!=NULL));
char*address =
while((*dest++=*src++)!='\0')
用法：#include&string.h&
功能：把src所指由NULL结束的字符串复制到dest所指的数组中。
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
返回指向dest的指针。
memcpy原型：
void *memcpy_su(void *dest, void *src,unsigned int count)
assert((dest!=NULL)&&(src!=NULL));
char*bdest = (char*)
char*bsrc = (char*)
while(count--&0)
&&&&&&& *bdest++ = *bsrc++;
用法：#include&memory.h&
功能：由src所指内存区域复制count个字节到dest所指内存区域。
说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。
Memset原型：
原型：extern void*memset(void *buffer, char c, int count);
用法：#include
功能：把buffer所指内存区域的前count个字节设置成字符c。
说明：返回指向buffer的指针。
&void *memset_su(void *buffer, int c, int count)
&& assert ((buffer!=NULL));
&& char* buffer2 = (char*)
&& while(count--&0)
&&&&&&& *buffer2++ =
47. ASSERT()是干什么用的
答:ASSERT()是一个调试程序时经常使用的宏，在程序运行时它计算括号内的表达式，如果表达式为FALSE (0),&程序将报告错误，并终止执行。如果表达式不为0，则继续执行后面的语句。这个宏通常用来判断程序中是否出现了明显非法的数据，如果出现了终止程序以免导致严重后果，同时也便于查找错误。例如，变量n在程序中不应该为0，如果为0可能导致错误，你可以这样写程序：
ASSERT( n != 0);
ASSERT只有在Debug版本中才有效，如果编译为Release版本则被忽略。
assert()的功能类似，它是ANSI C标准中规定的函数，它与ASSERT的一个重要区别是可以用在Release版本中。
#include&stdio.h&
#include&assert.h&
void main()
assert( n != 0);&&& //c c++中使用
//ASSERT( n != 0); //什么头文件?
printf("su\n");
48. 编写用C语言实现的求n阶阶乘问题的递归算法：
答:long intfact(int n)
If(n==0||n==1)
&& Return 1;
&Return n*fact(n-1);
49. 冒泡排序：
#include"stdio.h"
voidprintArr(int R[],int n)
for(i=0;i&n;i++)
printf("%d& ",R[i]);
printf("\n");
void swap(int* a ,int * b)
//4&冒泡排序
voidmaopaoSort(int R[],int n)
for(int i=0;i&n-1;i++)& //&需要冒泡的次数
for(intj=0;j&n-1-i;j++)&& // //&每次需要比较的次数
if(R[j]&R[j+1])&&&&& //大的往下沉
swap(&R[j],&R[j+1]);
&&&&& for(int j=n-1;j&i;j--)&& // //&每次需要比较的次数
if(R[j]&R[j-1])&&&&& //小的往上冒
swap(&R[j],&R[j-1]);
void main()
int num[6]={0};
printf("Please input 6 numbers:\n");
for(i=0;i&6;i++)
scanf("%d",&num[i]);
puts("before sort:");
printArr(num,6);
&&& maopaoSort(num,6);
puts("after sort:");
printArr(num,6);
50．再看看下面的一段程序有什么错误：
swap( int* p1,int* p2 )
　int *p;&
　*p = *p1;
　*p1 = *p2;
　*p2 = *p;
　在swap函数中，p是一个&野&指针，有可能指向系统区，导致程序运行的崩溃。在VC++中DEBUG运行时提示错误&Access Violation&。该程序应该改为：
swap( int* p1,int* p2 )
*p1 = *p2;
51.分别给出BOOL，int，float，指针变量 与&零值&比较的if 语句（假设变量名为var）
　　解答：
BOOL型变量：if(!var)
int型变量：&if(var==0)
float型变量：
const floatEPSINON = 0.00001;
if ((x &= -EPSINON) && (x &= EPSINON)
　　　指针变量：　　if(NULL ==var)
52.以下为Windows NT下的32位C++程序，请计算sizeof的值
void Func ( char str[100] )
　sizeof( str ) = ?
void *p = malloc( 100 );
sizeof ( p ) = ?
sizeof( str ) = 4
sizeof ( p ) = 4
Func ( char str[100] )函数中数组名作为函数形参时，在函数体内，数组名失去了本身的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。
数组名的本质如下：
（1）数组名指代一种数据结构，这种数据结构就是数组；
　　例如：
char str[10];
cout && sizeof(str) &&
　　输出结果为10，str指代数据结构char[10]。
（2）数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改；
char str[10];
str++; //编译出错，提示str不是左值　
（3）数组名作为函数形参时，沦为普通指针。
Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str )&、sizeof ( p )&都为4。
53．写一个&标准&宏MIN，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事？
least = MIN(*p++, b);
#define MIN(A,B) ((A) &= (B) ? (A) :(B))
MIN(*p++, b)会产生宏的副作用
　　（1）谨慎地将宏定义中的&参数&和整个宏用用括弧括起来。所以，严格地讲，下述解答：
#define MIN(A,B) (A) &= (B) ? (A) : (B)
#define MIN(A,B) (A &= B ? A : B )
#define MIN(A,B) ((A) &= (B) ? (A) :(B));&
　　都应判0分；
　　（2）防止宏的副作用。
　　宏定义#defineMIN(A,B) ((A) &= (B) ? (A) : (B))对MIN(*p++, b)的作用结果是：
((*p++) &= (b) ? (*p++) : (b))
这个表达式会产生副作用，指针p会作2次++自增操作。
//&dfjdosfjkodskf&& &dos&& 1000& 3
54.请编写能直接实现strstr()函数功能的代码。&// strstr(str,substr);在str中找substr，找到后把后面的全部截取返回。
#include&&iostream&?
using&std::?
using&std::?
char*&my_strstr(&char*&str1,&char*&str2&)?
& if&(NULL&==&str1&||&NULL&==&str2)?&
& {?&&&&&&
&char&*p&=&NULL;?
& char&*q&=&NULL;?&
&const&char&v&=&'\0';?
&for&(int&i=0;&v&!=&str1[i];&++i)?&
& p&=&&str1[i];?&&
&&q&=&str2;?&&&?&&&
& while&(v&!=&*q&&&&*q&==&*p)?&&
& {?&&&&&&
&&& ++p;?&&&&&&++q;?&&
& if&('\0'&==&*q)?&
& {?&&&&&&&
&&&& return&&str1[i];?&&
&return&NULL;
int&main(&void&)?
{?&&char&a[]&=&"";?&
& &char*&p&=&my_strstr(&a,&"com"&);?&
& &if&(NULL&==&p)?&&
& {?&&&&&&&
&&&& cout&&&&"not&find"&&&&?&
&&else?&{?&&&
&&& cout&&&&p&&&&?&
&&p&=&my_strstr(&a,&"2002"&);
? &if&(NULL&==&p)?
& {?&&&&&&&cout&&&&"not&find"&&&&?&}?&?&
& else?&{?&
&&&& cout&&&&p&&&&?
55.写一个函数，检查字符是否是整数，如果是，返回其整数值。（或者：怎样只用4行代码,编写出一个从字符串到长整形的函数？）
析 ：扫描一遍，每次生成对应整数的最高位。一行也就搞定了！
//&1234&-&1*+3*10+4& &0&---&9&&
longconvert(char* s_string)
&& long s_integer=0;
&& for(int sLen = strlen(s_string),i = 0; i & sLs_integer += (s_string[i++] - '0')*pow(10,sLen - i - 1));
& 12 21 23 34 15
56．对1，2，3， 4， 5 这五个数任意取出两个数，列出他们的所有组合。
void main()
char a[]={'1','2','3','4','5'};
for(int i=0;i&5-1;i++)
for(intj=i+1;j&5;j++)
if(a[i]!=a[j])
cout&&a[i]&&a[j]&&"& ";
cout&&a[j]&&a[i]&&"& ";
//12 21 13 31
//23 32 24 42 2552
//34 43 35 53
57 . 用预处理指令#define 声明一个常数，用以表明1年中有多少秒(忽略闰年问题)
#define SECONDS_PER_YEAR (60 * 60 *24 * 365)UL
1) #define&语法的基本知识(例如：不能以分号结束，括号的使用，等等)
2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是怎么样计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。
3)&意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
4)&如果你在你的表达式中用到UL(表示无符号长整型)，那么你有了一个好的起点。记住，第一印象很重要。
1). 一个参数既可以是const还可以是volatile吗？解释为什么。
2). 一个指针可以是volatile吗？解释为什么。
3). 下面的函数有什么错误：
int square(volatile int *ptr)
return (*ptr) * (*ptr);
下面是答案：
1). 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
2). 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
3). 这段代码的有个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，
编译器将产生类似下面的代码：
int square(volatile int *ptr)
return a *b;
由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：
long square(volatile int *ptr)
return a *a;
59. 嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a的bit 3，
第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。
#define BIT3 (0x1&&3)
void set_bit3(void)
a |= BIT3;
void clear_bit3(void)
a &=~BIT3;
访问固定的内存位置（Accessing fixed memorylocations） CC++ Development
60. 嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，
要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。
这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。
这一问题的实现方式随着个人风格不同而不同。典型的类似代码如下：
ptr = (int *)0x67a9;
*ptr = 0xaa66;
61. 中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展&让标准C支持中断。
具代表事实是，产生了一个新的关键字__interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR)，
请评论一下这段代码的。
__interrupt double compute_area (double radius)
double area = PI * radius*
printf(" Area =%f", area);
这个函数有太多的错误了，以至让人不知从何说起了：
1). ISR&不能返回一个值。如果你不懂这个，那么你不会被雇用的。
2). ISR&不能传递参数。如果你没有看到这一点，你被雇用的机会等同第一项。
3).&在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，
有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。
4).&与第三点一脉相承，printf()经常有重入和性能上的问题。
62 . 下面的代码输出是什么，为什么？
Void foo(void)
unsigned int a = 6;
int b = -20;&&&
(a+b & 6)?puts("& 6") : puts("&= 6");
这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，
这无符号整型问题的答案是输出是&&6&。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。
因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。
这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。
63. 评价下面的代码片断：
unsigned int zero = 0;&&
unsigned int compzero = 0XFFFF FFFF;
/*1's complement of zero */
对于一个int型不是16位的处理器为说，上面的代码是不正确的。应编写如下：
unsigned int compzero = ~0;
这一问题真正能揭露出应试者是否懂得处理器字长的重要性。在我的经验里，好的嵌入式程序员非常准确地明白硬件的细节和它的局限.
阅读(...) 评论()