【转载】C语言深度解剖最后测试题

1.下面的代码输出是什么?为什么?
void foo(void)
{
    unsigned int a = 6; int b = -20;
    (a + b>6)? puts(“>6”):puts(“<=6”);
}
2.下面的代码有什么问题?为什么?
void foo(void)
{
    char string[10],str1[10]; 
    int i;
    for(i=0; i<10; i++) 
    str1[i] = ’a’;
    strcpy(string , str1); 
    printf(“%s”,string);
}
3.下面的代码,i 和 j 的值分别是什么?为什么?
static int j; 
int k=0;

void fun1(void)
{
    static int i=0;
    i++;
}

void fun2(void)
{
    j=0;
    j++;
}

int main()
{
    for(k=0;k<10;k++){
        fun1();
        fun2();
    }
    return 0;
}
4.下面代码里,假设在 32 位系统下,各 sizeof 计算的结果分别是多少?
int *p=NULL;
sizeof(p)的值是        
sizeof(*p)的值是          
int a[100]; 
sizeof(a)的值是         
sizeof(a[100])的值是 //*(a+100)             
sizeof(&a)的值是           
sizeof(&a[0])的值是       

int b[100];
void fun(int b[100])
{
    sizeof(b);
}
sizeof(b)的值是      
5.下面代码的结果是多少?为什么?
int main()
{
    char a[1000]; 
    int i;
    for(i=0; i<1000; i++) 
    a[i] = -1-i;
    printf(“%d”,strlen(a)); 
    return 0;
}
6.下面的代码里,哪些内容可被改写,哪些不可被改写?
const int *p;
int const *p;
int *const p;
const int * const p;
7.下面的两段代码有什么区别?什么时候需要使用代码(2)
代码(1):
int i = 10;
int j = i;
int k = i;

代码(2):
volatile int i=10;
int j = i;
int k = i;
8.在 32 位的 x86 系统下,输出的值为多少?
#include<stdio.h> 
int main()
{
    int a[5] = {1,2,3,4,5};
    int *ptr1 = (int *)(&a + 1); 
    int *ptr2 = (int *)((int )a + 1);
    printf(“%x,%x”,ptr1[-1], *ptr2); 
    return 0;
}
9.0x01<<2+3 的值为多少?为什么?
10.定义一个函数宏,求x的平方。
11.下面的两段代码有什么区别?
代码(1): 
struct TestStruct1{
    char c1; 
    short s; 
    char c2; 
    int i;
};

代码(2): 
struct TestStruct2{
    char c1; 
    char c2; 
    short s; 
    int i;
};
12.写代码向内存 0x12ff7c 地址上存入一个整形数 0x100。
13.下面的代码输出是多少?
main()
{
    int a[5]={1,2,3,4,5};
    int *ptr = (int *) (&a + 1); 
    printf(“%d,%d”,*(a+1), *(ptr-1));

}
14.假设 p 的值为 0x100000,如下表达式的值分别为多少?
struct Test
{
    int Num;
    char *pcName; 
    short sDate; 
    char cha[2]; 
    short sBa[4];
}*p; 

p+0x1 = 
(unsigned long)p+0x1 = 
(unsigned int *)p+0x1 = 
15.下面代码输出地结果是多少?
#include<stdio.h>

int main(int argc,char * argv[])
{
    int a[3][2]={(0,1),(2,3),(4,5)}; 
    int *p;
    p=a[0]; 
    printf(“%d”,p[0]);
}
16.下面的代码有什么问题?为什么?
void fun(char a[10])
{
    char c = a[3];
}

int main()
{
    char b[10] = “abcdefg”; 
    fun(b[10]);
    return 0;
}
17.下面的代码有什么问题?为什么?
struct student
{
    char *name; 
    int score;
}*pstu; 

int main()
{
    pstu = (struct student *)malloc(sizeof(struct student)); 
    strcpy(pstu->name, “Jimy”);

    pstu->score = 99;
    free(pstu);
    return 0;
}
18.下面的代码输出结果是多少?
void fun(int i)
{
    if( i > 0 ) fun(i/2);
    printf(“%d\n”,i);
}

int main()
{
    fun(10);
    return 0;
}
19.下面的代码有什么问题?为什么?
char c;
c = getchar();
if(EOF == c)
{
    ...
}
20.请写一个C函数,若当前系统是Big_endian的,则返回0;若是little_endian的,则返回1。
  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第一章关键字..................................................................................................................................9 1.1,最宽恒大量的关键字----auto..........................................................................................11 1.2,最快的关键字---- register............................................................................................... 11 1.2.1,皇帝身边的小太监----寄存器............................................................................. 11 1.2.2,使用register 修饰符的注意点.............................................................................11 1.3,最名不符实的关键字----static........................................................................................12 1.3.1,修饰变量...............................................................................................................12 1.3.2,修饰函数...............................................................................................................13 1.4,基本数据类型----short、int、long、char、float、double........................................... 13 1.4.1,数据类型与“模子”............................................................................................... 14 1.4.2,变量的命名规则...................................................................................................14 1.5,最冤枉的关键字----sizeof...............................................................................................18 1.5.1,常年被人误认为函数...........................................................................................18 1.5.2,sizeofint)*p 表示什么意思?........................................................................18 1.4,signed、unsigned 关键字................................................................................................19 1.6,if、else 组合.................................................................................................................... 20 1.6.1,bool 变量与“零”进行比较...............................................................................20 1.6.2, float 变量与“零”进行比较.................................................................................21 1.6.3,指针变量与“零”进行比较...............................................................................21 1.6.4,else 到底与哪个if 配对呢?...............................................................................22 1.6.5,if 语句后面的分号............................................................................................... 23 1.6.6,使用if 语句的其他注意事项.............................................................................. 24 1.7,switch、case 组合........................................................................................................... 24 1.7.1,不要拿青龙偃月刀去削苹果.............................................................................. 24 1.7.2,case 关键字后面的有什么要求吗?.............................................................. 25 1.7.3,case 语句的排列顺序...........................................................................................25 1.7.4,使用case 语句的其他注意事项..........................................................................27 1.8,do、while、for 关键字................................................................................................... 28 1.8.1,break 与continue 的区别.....................................................................................28 1.8.2,循环语句的注意点...............................................................................................29 1.9,goto 关键字......................................................................................................................30 1.10,void 关键字....................................................................................................................31 1.10.1,void a?............................................................................................................31 1.10,return 关键字................................................................................................................. 34 1.11,const 关键字也许该被替换为readolny....................................................................... 34 1.11.2,节省空间,避免不必要的内存分配,同时提高效率.................................... 35 1.12,最易变的关键字----volatile.......................................................................................... 36 1.13,最会带帽子的关键字----extern.................................................................................... 37 1.14,struct 关键字..................................................................................................................38 1.14.1,空结构体多大?.................................................................................................38 1.14.2,柔性数组.............................................................................................................39 1.14.3,struct 与class 的区别.........................................................................................40 1.15,union 关键字..................................................................................................................40 1.15.1,大小端模式对union 类型数据的影响............................................................. 40 1.15.2,如何用程序确认当前系统的存储模式?........................................................ 41 1.16,enum 关键字..................................................................................................................42 1.16.1, 枚举类型的使用方法..........................................................................................43 1.16.2,枚举与#define 宏的区别....................................................................................43 1.17,伟大的缝纫师----typedef 关键字................................................................................. 44 1.17.1,关于马甲的笑话.................................................................................................44 1.17.2,历史的误会----也许应该是typerename........................................................... 44 1.17.3,typedef 与#define 的区别...................................................................................45 1.17.4,#define a int[10]与typedef int a[10];.............................................................. 46 第二章符号....................................................................................................................................49 2.1,注释符号..........................................................................................................................50 2.1.1,几个似非而是的注释问题...................................................................................50 2.1.2,y = x/*p................................................................................................................. 51 2.1.3,怎样才能写出出色的注释...................................................................................51 2.1.3.1,安息吧,路德维希.凡.贝多芬................................................................. 51 2.1.3.2,windows 大师们用注释讨论天气问题....................................................51 2.1.3.3,出色注释的基本要求............................................................................... 52 2.2,接续符和转义符..............................................................................................................53 2.3,单引号、双引号..............................................................................................................54 2.4,逻辑运算符......................................................................................................................54 2.5,位运算符..........................................................................................................................55 2.5.1,左移和右移...........................................................................................................55 2.5.2,0x01<<2+3 的为多少?...................................................................................55 2.6,花括号..............................................................................................................................56 2.7,++、--操作符...................................................................................................................56 2.7.1,++i+++i+++i......................................................................................................... 57 2.7.2,贪心法...................................................................................................................57 2.8,2/(-2)的是多少?.........................................................................................................58 2.9,运算符的优先级..............................................................................................................58 2.9.1, 运算符的优先级表................................................................................................58 2.9.2,一些容易出错的优先级问题.............................................................................. 60 第三章预处理................................................................................................................................61 3.1,宏定义..............................................................................................................................62 3.1.1,数宏常量...........................................................................................................62 3.1.2,字符串宏常量.......................................................................................................62 3.1.3,用define 宏定义注释符号?.............................................................................. 63 3.1.4,用define 宏定义表达式.......................................................................................63 3.1.5,宏定义中的空格...................................................................................................64 3.1.6,#undef....................................................................................................................64 3.2,条件编译..........................................................................................................................65 3.3,文件包含..........................................................................................................................66 3.4,#error 预处理................................................................................................................... 66 3.5,#line 预处理.....................................................................................................................67 3.6,#pragma 预处理...............................................................................................................67 3.6.8,#pragma pack........................................................................................................ 69 3.6.8.1,为什么会有内存对齐?........................................................................... 70 3.6.8.2,如何避免内存对齐的影响....................................................................... 70 3.7, #运算符..............................................................................................................................72 3.8,##预算符..........................................................................................................................72 第四章指针和数组.........................................................................................................................74 4.1,指针.................................................................................................................................74 4.1.1,指针的内存布局...................................................................................................74 4.1.2,“*”与防盗门的钥匙............................................................................................. 75 4.1.3,int *p = NULL 和*p = NULL 有什么区别?.................................................... 75 4.1.4,如何将数存储到指定的内存地址.................................................................. 76 4.1.5,编译器的bug?....................................................................................................77 4.1.6,如何达到手中无剑、胸中也无剑的地步.......................................................... 78 4.2,数组.................................................................................................................................78 4.2.1,数组的内存布局...................................................................................................78 4.2.3,数组名a 作为左和右的区别.......................................................................79 4.3,指针与数组之间的恩恩怨怨..........................................................................................80 4.3.1,以指针的形式访问和以下标的形式访问.......................................................... 80 4.3.1.1,以指针的形式访问和以下标的形式访问指针....................................... 81 4.3.1.2,以指针的形式访问和以下标的形式访问数组....................................... 81 4.3.2,a 和&a 的区别...................................................................................................... 81 4.3.3,指针和数组的定义与声明...................................................................................83 4.3.3.1,定义为数组,声明为指针....................................................................... 83 4.3.3.2,定义为指针,声明为数组....................................................................... 85 4.3.4,指针和数组的对比...............................................................................................85 4.4,指针数组和数组指针......................................................................................................86 4.4.1,指针数组和数组指针的内存布局...................................................................... 86 4.4.3,再论a 和&a 之间的区别.....................................................................................87 4.4.4,地址的强制转换...................................................................................................88 4.5,多维数组与多级指针......................................................................................................90 4.5.1,二维数组...............................................................................................................91 4.5.1.1,假想中的二维数组布局........................................................................... 91 4.5.1.2,内存与尺子的对比....................................................................................91 4.5.1.3,&p[4][2] - &a[4][2]的为多少?........................................................... 92 4.5.2,二级指针...............................................................................................................93 4.5.2.1,二级指针的内存布局............................................................................... 93 4.6,数组参数与指针参数......................................................................................................94 4.6.1,一维数组参数.......................................................................................................94 4.6.1.1,能否向函数传递一个数组?................................................................... 94 4.6.1.2,无法向函数传递一个数组....................................................................... 96 4.6.2,一级指针参数.......................................................................................................97 4.6.2.1,能否把指针变量本身传递给一个函数................................................... 97 4.6.2.2,无法把指针变量本身传递给一个函数................................................... 98 4.6.3,二维数组参数与二维指针参数.......................................................................... 99 4.7,函数指针........................................................................................................................100 4.7.1,函数指针的定义.................................................................................................100 4.7.2,函数指针的使用.................................................................................................101 4.7.2.1,函数指针使用的例子............................................................................. 101 4.2.7.2,*(int*)&p ----这是什么?....................................................................... 102 4.7.3,(*(void(*) ())0)()------这是什么?.....................................................................102 4.7.4,函数指针数组.....................................................................................................103 4.7.5,函数指针数组的指针.........................................................................................104 第五章内存管理...........................................................................................................................107 5.1,什么是野指针................................................................................................................107 5.2,栈、堆和静态区............................................................................................................107 5.3,常见的内存错误及对策................................................................................................108 5.3.1,指针没有指向一块合法的内存........................................................................ 108 5.3.1.1,结构体成员指针未初始化..................................................................... 108 5.3.1.2,没有为结构体指针分配足够的内存..................................................... 109 5.3.1.3,函数的入口校验......................................................................................109 5.3.2,为指针分配的内存太小.....................................................................................110 5.3.3,内存分配成功,但并未初始化.........................................................................110 5.3.4,内存越界............................................................................................................. 111 5.3.5,内存泄漏............................................................................................................. 111 5.3.5.1,告老还乡求良田......................................................................................112 5.3.5.2,如何使用malloc 函数.............................................................................112 5.3.5.3,用malloc 函数申请0 字节内存.............................................................113 5.3.5.4,内存释放..................................................................................................113 5.3.5.5,内存释放之后..........................................................................................114 5.3.6,内存已经被释放了,但是继续通过指针来使用............................................ 114 第六章函数.................................................................................................................................. 115 6.1,函数的由来与好处........................................................................................................116 6.2,编码风格........................................................................................................................ 116 6.2,函数设计的一般原则和技巧...........................................................................................121 6.4,函数递归........................................................................................................................123 6.4.1,一个简单但易出错的递归例子........................................................................ 123 6.4.2,不使用任何变量编写strlen 函数......................................................................124 第七章文件结构.........................................................................................................................127 7.1,文件内容的一般规则....................................................................................................127 7.2,文件名命名的规则........................................................................................................130
"C语言深度解剖"是一本PDF电子书,它在内容上对C语言进行了全面而深入的剖析和解析。该电子书以书签的形式提供,这使得读者可以方便地浏览和导航书中的各个章节。 书中的内容涵盖了C语言的各个方面,包括基本语法、数据类型、运算符、控制语句、函数、指针等。每个章节都提供了详细的解释和示例,以帮助读者更好地理解和掌握C语言的各个概念和特性。 书签功能使得读者可以迅速定位到感兴趣的章节或部分。通过点击书签,读者可以跳转到所选章节的开头或指定的页面,从而节省时间并提高阅读效率。 对于初学者来说,"C语言深度解剖"提供了一个系统而详细的学习资源。读者可以按照自己的学习进度,逐步阅读不同章节,并通过书签功能进行快速导航。这种结构化的学习方式有助于初学者建立起对C语言的整体认识和理解。 对于有一定C语言基础的读者来说,"C语言深度解剖"也是一个很好的参考书籍。书中对于一些较为复杂或深奥的知识点进行了深入分析和讲解,可以帮助读者更深入地理解C语言的工作原理和内部机制。 总之,"C语言深度解剖"是一本内容详尽、结构清晰、带有书签功能的PDF电子书,适合不同层次的读者学习和参考。无论是初学者还是有经验的C语言开发者,都可以从中获取到有益的知识和信息。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值