|
第一题：
运行下面的代码，输出结果是什么，请解释说明：
#include<stdio.h>
int i;
int main(int argc, char *argv[])
{
i--;
if (i > sizeof(i))
{
printf(">\n");
}
else
{
printf("<\n");
}
return 0;
}
输出结果为：>
说明：sizeof运算符返回一个unsigned类型，而当i和sizeof（i）比较大小时，先将int类型的i转化为unsigined int类型，而-1转化成unsigined int类型是4294967295大于sizeof（i）=4；所以该程序输出>.
第二题：
执行下面的代码段，输出结果和你预想的一样没吗？谈谈你对宏的理解：
#include<stdio.h>
#define A 2+2
#define B 3+3
#define C A*B
int main(int argc,char *argv[])
{
printf("%d\n",C);
return 0;
}
?该程序输出11；
在编译时，编译器会把C替换成2+2×3+3,因此计算结果是11.
宏：一些命令组织在一起，作为一个单独命令完成一个特定任务
它在某些地方与函数相似，但可省去函数调用的代价，但是代码长度会大一些。因为不管宏语句在代码中出现了多少次，每次都被完整的宏体所替代，而函数码在程序中只存在一次就可以了。
与函数的区别，是宏将代码复制到调用处，而函数是转去执行，如调用10次，则宏的代码被复制10次，而函数的代码只有一份。使用宏的速度快，但程序较大，使用函数程序较小，但相对速度要慢。
所以比较短小又使用频繁的功能适合做成宏，而相对大些的写成函数。
宏嵌套的展开规则：
1.一般的展开规律像函数的参数一样：先展开参数，再分析函数，即由内向外展开
2.当宏中有#的时候，不展开参数
3.当宏中有##的时候，先展开函数，再分析参数
4.##运算符用于将参数连接到一起，预处理过程把出现在##运算符两侧的参数合并成一个符号，注意不是字符串。
第三题：分析下面程序的输出结果：
#include<stdio.h>
int main(int argc,char*argv[])
{
char str[]="Welcome to XiyouLinuxGroup";
printf("%zu %zu\n",strlen(str),sizeof(str));
return 0;
}
该程序输出26 27；
strlen函数计算字符串的长度，遇到\0则停止并返回，而sizeof是计算字符串所占内存大小，sizeof运算符算入了字符串最后一个\0而strlen遇到则\0立即返回因此strlen函数计算出的结果比sizeof运算符计算出的结果小1。
第五题：
分析以下程序，推测并验证其作用：
#include<stdio.h>
int main(int argc,char*argv[])
{
int number;
unsigned mask;
mask=1u<<31;
scanf("%d",&number);
while(mask)
{
printf("%d",(number&mask)?1:0);
mask>>=1;
}
return 0;
}
该程序的作用是将输入的整数number以二进制形式输出。
1U 表示 无符号整型 1，语句mask=1u<<31的作用是将1左移31位后赋值，mask的值就是1000 0000 0000 0000 0000 0000 0000 0000,
接下来读入一个数字number，循环时对number与mask进行按位与计算，如果（number&&mask）则输出1,否则输出0,每循环一次将mask右移一位并赋值，直到mask每一位全部为0推出循环。
C按位运算符：
（1）二进制反码或按位取反：～
一元运算符～把1变为0,把0变为1.? ?例如：
～（10010011）//表达式
（01101100）//结果值
（2）按位与：&
二元运算符&通过逐位比较两个运算对象，生成一个新值，对于每个单位，只有两个运算对象中相应的位都为1时，结果才为1,否则都为0.例如：
（10010011）&（11110001）//表达式
（10010001）//结果值
（3）按位或：|
二元运算符|，通过逐位比较两个运算对象，生成一个新值。对于每个位，如果两个运算对象中相应的位为有一个为1,结果为1.例如：
（10010011）|（11110001）//表达式
（11110011）//结果值
（4）按位异或：^
二元运算符^逐位比较两个运算对象，对于每个位，如果两个运算对象中相应的位一个为1,一个不为1,则结果为1,否则结果为0.例如：
（10010011）^（11110001）//表达式
（01100010）//结果值
移位运算符：
（1）左移：<<
左移运算符<<将其左侧运算对象每一位的值向左移动其右侧运算对象指定的位数，左侧运算对象移出左末端位的值丢失，用0填充空出的位置
（01100111）<<2//表达式
（10011100）//结果值
（2）右移：>>
右移运算符>>将其左侧运算对象每一位的值向右移动其右侧运算对象指定的位数，右侧运算对象移出右末端位的值丢失，用0填充空出的位置
（01100111）>>2 //表达式
（00011001） //结果值
第六题：
下面程序的运行结果是什么，请解释说明：
#include<stdio.h>
int main()
{
char *str="Xiyou Linux Group";
printf("%c\n",*str+1);
return 0;
}
程序运行的结果是Y；
说明：printf("%c\n",*str+1);语句的作用是打印一个字符，*的优先级比+高，因此*str为X，*str+1为Y故输出Y。
C语言运算符优先级：
| 优先级 | 运算符 | 名称或含义 | 使用形式 | 结合方向 | 说明 | | 1 | [] | 数组下标 | 数组名[常量表达式] | 左到右 | -- | | () | 圆括号 | (表达式）/函数名(形参表) | -- | | . | 成员选择（对象） | 对象.成员名 | -- | | -> | 成员选择（指针） | 对象指针->成员名 | -- | | 2 | - | 负号运算符 | -表达式 | 右到左 | 单目运算符 | | ~ | 按位取反运算符 | ~表达式 | | ++ | 自增运算符 | ++变量名/变量名++ | | -- | 自减运算符 | --变量名/变量名-- | | * | 取值运算符 | *指针变量 | | & | 取地址运算符 | &变量名 | | ! | 逻辑非运算符 | !表达式 | | (类型) | 强制类型转换 | (数据类型)表达式 | -- | | sizeof | 长度运算符 | sizeof(表达式) | -- | | 3 | / | 除 | 表达式/表达式 | 左到右 | 双目运算符 | | * | 乘 | 表达式*表达式 | | % | 余数（取模） | 整型表达式%整型表达式 | | 4 | + | 加 | 表达式+表达式 | 左到右 | 双目运算符 | | - | 减 | 表达式-表达式 | | 5 | <<? | 左移 | 变量<<表达式 | 左到右 | 双目运算符 | | >>? | 右移 | 变量>>表达式 | | 6 | >? | 大于 | 表达式>表达式 | 左到右 | 双目运算符 | | >= | 大于等于 | 表达式>=表达式 | | <? | 小于 | 表达式<表达式 | | <= | 小于等于 | 表达式<=表达式 | | 7 | == | 等于 | 表达式==表达式 | 左到右 | 双目运算符 | | ！= | 不等于 | 表达式!= 表达式 | | 8 | & | 按位与 | 表达式&表达式 | 左到右 | 双目运算符 | | 9 | ^ | 按位异或 | 表达式^表达式 | 左到右 | 双目运算符 | | 10 | | | 按位或 | 表达式|表达式 | 左到右 | 双目运算符 | | 11 | && | 逻辑与 | 表达式&&表达式 | 左到右 | 双目运算符 | | 12 | || | 逻辑或 | 表达式||表达式 | 左到右 | 双目运算符 | | 13 | ?: | 条件运算符 | 表达式1? 表达式2: 表达式3 | 右到左 | 三目运算符 | | 14 | = | 赋值运算符 | 变量=表达式 | 右到左 | -- | | /= | 除后赋值 | 变量/=表达式 | -- | | *= | 乘后赋值 | 变量*=表达式 | -- | | %= | 取模后赋值 | 变量%=表达式 | -- | | += | 加后赋值 | 变量+=表达式 | -- | | -= | 减后赋值 | 变量-=表达式 | -- | | <<= | 左移后赋值 | 变量<<=表达式 | -- | | >>= | 右移后赋值 | 变量>>=表达式 | -- | | &= | 按位与后赋值 | 变量&=表达式 | -- | | ^= | 按位异或后赋值 | 变量^=表达式 | -- | | |= | 按位或后赋值 | 变量|=表达式 | -- | | 15 | ， | 逗号运算符 | 表达式,表达式,… | 左到右 | -- |
第七题：
以下程序的运行结果是什么，你知道怎么判断两个浮点数是否相同吗？
#include<stdio.h>
int main()
{
double a=3.14;
float b=a;
if((float)a==b){
printf("Xiyou");
}
if(a!=b){
printf("LinuxGroup\n");
}
return 0;
}
该程序的运行结果是XiyouLinuxGroup；
将double类型的a赋给b时有精度缺失因此a！=b但是在第一个if语句里面将a暂时转化成了float类型，因此此时b与同样有精度缺失的a相比较，二者的大小是相等的。
第八题：
运行下面的代码，解释运行结果并谈谈自己的理解。
#include<stdio.h>
int main(int argc,char*argv[])
{
int a[6]={0x6f796958,0x694c2075,0x2078756e,0x756f7247,0x30322070,0};
printf("%d\n",printf("%s",(char*)a));
return 0;
}
该程序中数组a中存储的数以小端模式存储，就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。
什么是大端和小端
大端模式，就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。
小端模式，就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。
举个例子，比如数字 0x12 34 56 78（4个字节）在内存中的表示形式为：
1)大端模式：
低地址 -----------------> 高地址（数字高位存于低地址）
0x12 | 0x34 | 0x56 | 0x78
可见，大端模式和字符串的存储模式类似。
2)小端模式：
低地址 ------------------> 高地址（数字高位存于低地址）
0x78 | 0x56 | 0x34 | 0x12
printf("\n%d \n\n",printf("%s",(char*)a));语句里面嵌套的那一个printf语句将a数组中的每一个元素按照小端模式表示出来以ASCII码的形式输出，最后一位ASCII码为0其表示的字符是NULL，停止输出，并返回打印的字符数20；外层的printf语句打印20；
因此该程序的输出为Xiyou Linux Group 2020
第九题：
分析下列程序的输出，解释其原因。
#include<stdio.h>
int main()
{
int a[2][3]={{5,7},{5,2}};
int b[2][3]={5,7,5,2};
int c[2][2]={{5,7},{5,2}};
int d[2][2]={5,7,5};
printf("%d %d\n",a[1][1],b[1][1]);
printf("%d %d\n",c[1][1],d[1][1]);
return 0;
}
该程序的输出为：
2 0
2 0
原因：
数组a和c的赋值就是按照格式，只给前两行的每一行的前两个赋值，而数组b和d就是按照顺序给第一行赋值完转到第二行（按顺序赋值）
数组赋值时，如果赋值的个数小于数组分配的个数，会给该数组未赋值的部分自动赋值为0
第十题：
执行下面的程序段，其输出结果是什么，请依据相关知识，解析其原因。
#include<stdio.h>
int main(int argc,char*argv[])
{
int a=1;
printf("%d\n",*(char*)&a);
return 0;
}
该程序的输出结果时是1；
&a得到了a的地址，(char*)强制转换为指针类型，之后又对其进行解引用，得到该地址上的对象的值，即a的值1
第十一题：
下面程序段的输出结果是什么，若取消第4行的const注释，a数组还能被修改吗？如果取消第7,8行的注释，程序还能正常运行吗，试着解释其原因。
#include<stdio.h>
int main(int argc,char*argv[])
{
/*const*/char a[]="XiyouLinux\0";
char *b="XiyouLinux\0";
a[5]='\0';
//b[5]='\0';
printf("%s\n",a);
//printf("%s\n",b);
return 0;
}
该程序的运行结果是：Xiyou
如果取消第3行的注释，a会被声明为只读常量，程序不能正常运行；
b是一个字符串指针，而字符串指针类似于const 类型的数组,字符串指针指向的内容是不可修改的，用字符串指针定义的是存放在静态存储区，是常量，不可更改。
第十二题：
一个c源文件到一个可执行文件的过程中经历了一系列步骤，你了解这个过程吗，谈谈你对gcc的认识。
C编程的基本策略是，用程序把源代码文件转换成可执行文件。典型的C实现通过编译和链接两个步骤来完成这一过程。编译器把源代码转换成中间代码，连接器把中间代码和其他代码合并，生成可执行文件 。
在使用gcc编译程序时，编译过程可以细分为４个阶段：
●?????? 预处理(Pre-Processing)
●?????? 编译(Compiling)
●?????? 汇编(Assembling)
●?????? 链接(Linking)
Linux程序员可以根据自己的需要让gcc在编译的任何阶段结束，检查或使用编译器在该阶段的输出信息，或者对最后生成的二进制文件进行控制，以便通过加入不同数量和种类的调试代码来为今后的调试做好准备。与其他常用的编译器一样，gcc也提供了灵活而强大的代码优化功能，利用它可以生成执行效率更高的代码。
gcc提供了30多条警告信息和3个警告级别，使用它们有助于增强程序的稳定性和可移植性。此外，gcc还对标准的C和C++语言进行了大量的扩展，提高了程序的执行效率，有助于编译器进行代码优化，能够减轻编程的工作量。
第十三题：
仔细阅读下面这个函数，你可以看出这个函数的功能吗？试着理解算法原理，并尝试优化它。
void sort(int arr[],int size)
{
int i,j,tmp;
for(i=0;i<size-1;i++){
for(j=0;j<size-i-1;j++){
if(arr[j]>arr[j+1]){
tmp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=tmp;
}
}
}
}
这段代码写的是冒泡排序；
冒泡排序是比较基础的排序算法之一，其思想是相邻的元素两两比较，较大的数下沉，较小的数冒起来，这样一趟比较下来，最大(小)值就会排列在一端
冒泡排序的思路：
1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2、每趟从第一对相邻元素开始，对每一对相邻元素作同样的工作，直到最后一对。
3、针对所有的元素重复以上的步骤，除了已排序过的元素(每趟排序后的最后一个元素)，直到没有任何一对数字需要比较。
//改进后的冒泡排序
void sort(int arr[],int size)
{
int i,j,tmp;
for(i=0;i<size-1;i++){
int count=0;
for(j=0;j<size-i-1;j++){
if(arr[j]>arr[j+1]){
tmp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=tmp;
count++;
}
}
if(count==0){
break;//如果一小轮完成之后没有数字的交换，则证明数组已经变得有序，可直接跳出循环，增加效率
}
}
}
|