C语言惠通面试题

liyuanxi

[color="#02368d"]C语言惠通面试题
什么是预编译，何时需要预编译：
　　总是使用不经常改动的大型代码体。
程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。
　　char * const p;
　　char const * p
　　const char *p
　　上述三个有什么区别？
　　char * const p; //常量指针，p的值不可以修改
　　char const * p；//指向常量的指针，指向的常量值不可以改
　　const char *p； //和char const *p
　　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
　　cout

　　请问以下代码有什么问题：
　　int  main()
　　{
　　　char a;
　　　char *str=&a;
　　　strcpy(str,"hello");
　　　printf(str);
　　　return 0;
　　}
　　没有为str分配内存空间，将会发生异常。问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。
　　char* s="AAA";
　　printf("%s",s);
　　s[0]='B';
　　printf("%s",s);
　　有什么错？
　　"AAA"是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。
　　cosnt char* s="AAA";
　　然后又因为是常量，所以对是s[0]的赋值操作是不合法的。
　　写一个“标准”宏，这个宏输入两个参数并返回较小的一个。
　　.#define Min(X, Y) ((X)>(Y)?(Y):(X))//结尾没有;
　　嵌入式系统中经常要用到无限循环，你怎么用C编写死循环。
　　while(1){}或者for(;;)
[color="#ffffff"]软件开发网 www.mscto.cn
　　关键字static的作用是什么？
　　定义静态变量
　　关键字const有什么含意？
　　表示常量不可以修改的变量。
　　关键字volatile有什么含意？并举出三个不同的例子？
　　提示编译器对象的值可能在编译器未监测到的情况下改变。
　　int (*s[10])(int) 表示的是什么？
　　int (*s[10])(int) 函数指针数组，每个指针指向一个int func(int param)的函数。
　　有以下表达式：
　　int a=248; b=4;
　　int const c=21;
　　const int *d=&a;
　　int *const e=&b;
　　int const *f const =&a;
　　请问下列表达式哪些会被编译器禁止？为什么？
　　*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;
　　*c 这是个什么东东，禁止
　　*d 说了是const， 禁止
　　e = &a 说了是const 禁止
　　const *f const =&a; 禁止
　　交换两个变量的值，不使用第三个变量。即a=3,b=5,交换之后a=5,b=3;
　　有两种解法, 一种用算术算法, 一种用^(异或)
　　a = a + b;
　　b = a - b;
　　a = a - b;
　　or
　　a = a^b;// 只能对int,char..
　　b = a^b;
　　a = a^b;
　　or
　　a ^= b ^= a;
　　c和c++中的struct有什么不同？
　　c和c++中struct的主要区别是c中的struct不可以含有成员函数，而c++中的struct可以。c++中struct和class的主要区别在于默认的存取权限不同，struct默认为public，而class默认为private。
　　#include
　　#include
　　void getmemory(char *p)
　　{　
　　　p=(char *) malloc(100);
　　　strcpy(p,"hello world");
　　}　
　　int main( )
　　{
　　　char *str=NULL;
　　　getmemory(str);
　　　printf("%s/n",str);
　　　free(str);
　　　return 0;
　　}
　　程序崩溃，getmemory中的malloc 不能返回动态内存， free（）对str操作很危险
　　char szstr[10];
  　　strcpy(szstr,"0123456789");
  　　产生什么结果？为什么？

　　长度不一样，会造成非法的OS
软件开发网 www.mscto.cn
　　列举几种进程的同步机制，并比较其优缺点。
　　
　　原子操作
　　信号量机制
　　自旋锁
　　管程，会合，分布式系统
　　进程之间通信的途径
　　共享存储系统
　　消息传递系统
　　管道：以文件系统为基础
　　进程死锁的原因
　　资源竞争及进程推进顺序非法
　　死锁的4个必要条件
　　互斥、请求保持、不可剥夺、环路
　　死锁的处理
　　鸵鸟策略、预防策略、避免策略、检测与解除死锁
　　操作系统中进程调度策略有哪几种？
　　FCFS(先来先服务)，优先级，时间片轮转，多级反馈
　　类的静态成员和非静态成员有何区别？
　　类的静态成员每个类只有一个，非静态成员每个对象一个
　　纯虚函数如何定义？使用时应注意什么？
　　virtual void f()=0;
　　是接口，子类必须要实现
　　数组和链表的区别
　　数组：数据顺序存储，固定大小
　　连表：数据可以随机存储，大小可动态改变
　　ISO的七层模型是什么？tcp/udp是属于哪一层？tcp/udp有何优缺点？
软件开发网 www.mscto.cn
　　应用层
　　表示层
　　会话层
　　运输层
　　网络层
　　物理链路层
　　物理层
　　tcp /udp属于运输层
　　TCP 服务提供了数据流传输、可靠性、有效流控制、全双工操作和多路复用技术等。
　　与 TCP 不同， UDP 并不提供对 IP 协议的可靠机制、流控制以及错误恢复功能等。由于 UDP 比较简单， UDP 头包含很少的字节，比 TCP 负载消耗少。
　　tcp: 提供稳定的传输服务，有流量控制，缺点是包头大，冗余性不好
　　udp: 不提供稳定的服务，包头小，开销小  
　　1：(void *)ptr 和 (*(void**))ptr的结果是否相同？其中ptr为同一个指针(void *)ptr 和 (*(void**))ptr值是相同的
　　2：
　　int main()
　　{
　　　int x=3;
　　　printf("%d",x);
　　　return 1;
　　}
　　问函数既然不会被其它函数调用，为什么要返回1？
　　mian中，c标准认为0表示成功，非0表示错误。具体的值是某中具体出错信息
　　要对绝对地址0x100000赋值，我们可以用(unsigned int*)0x100000 = 1234;那么要是想让程序跳转到绝对地址是0x100000去执行，应该怎么做？
　　*((void (*)( ))0x100000 ) ( );
　　首先要将0x100000强制转换成函数指针,即:
　　(void (*)())0x100000
　　然后再调用它:
　　*((void (*)())0x100000)();
　　用typedef可以看得更直观些:
　　typedef void(*)() voidFuncPtr;
　　*((voidFuncPtr)0x100000)();
　　已知一个数组table，用一个宏定义，求出数据的元素个数
　　#define NTBL
　　#define NTBL (sizeof(table)/sizeof(table[0]))
　　面试题: 线程与进程的区别和联系? 线程是否具有相同的堆栈? dll是否有独立的堆栈?
　　进程是死的，只是一些资源的集合，真正的程序执行都是线程来完成的，程序启动的时候操作系统就帮你创建了一个主线程。
　　每个线程有自己的堆栈。DLL中有没有独立的堆栈？
　
　这个问题不好回答，或者说这个问题本身是否有问题。因为DLL中的代码是被某些线程所执行，只有线程拥有堆栈，如果DLL中的代码是EXE中的线程所调
用，那么这个时候是不是说这个DLL没有自己独立的堆栈？如果DLL中的代码是由DLL自己创建的线程所执行，那么是不是说DLL有独立的堆栈？
　　以上讲的是堆栈，如果对于堆来说，每个DLL有自己的堆，所以如果是从DLL中动态分配的内存，最好是从DLL中删除，如果你从DLL中分配内存，然后在EXE中，或者另外一个DLL中删除，很有可能导致程序崩溃。

　　unsigned short A = 10;
　　printf("~A = %u\n", ~A);
　　char c=128;
　　printf("c=%d\n",c);
输出多少？并分析过程
　　第一题，～A ＝0xfffffff5,int值 为－11，但输出的是uint。所以输出4294967285
　　第二题，c＝0x10,输出的是int，最高位为1，是负数，所以它的值就是0x00的补码就是128，所以输出－128。
这两道题都是在考察二进制向int或uint转换时的最高位处理。
分析下面的程序：
　　void GetMemory(char **p,int num)
　　{
　　　*p=(char *)malloc(num);
　　}      
　　int main()
　　{
    　　char *str=NULL;
　　　GetMemory(&str,100);
　　　strcpy(str,"hello");
　　　free(str);
    　　if(str!=NULL)
    　　{
        　　strcpy(str,"world");
    　　}   
        　printf("\n str is %s",str); 软件开发网 www.mscto.com
    　　getchar();
　　}   
　　问输出结果是什么？
　　输出str is world。
　　free 只是释放的str指向的内存空间,它本身的值还是存在的.所以free之后，有一个好的习惯就是将str=NULL.
此时str指向空间的内存已被回收,如果输出语句之前还存在分配空间的操作的话,这段存储空间是可能被重新分配给其他变量的,
尽管这段程序确实是存在大大的问题（上面各位已经说得很清楚了），但是通常会打印出world来。
这是因为，进程中的内存管理一般不是由操作系统完成的，而是由库函数自己完成的。
　
　当你malloc一块内存的时候，管理库向操作系统申请一块空间（可能会比你申请的大一些），然后在这块空间中记录一些管理信息（一般是在你申请的内存
前面一点），并将可用内存的地址返回。但是释放内存的时候，管理库通常都不会将内存还给操作系统，因此你是可以继续访问这块地址的。
　　char a[10],strlen(a)为什么等于15？运行的结果
　　#include "stdio.h"
　　#include "string.h"
　　void main()
　　{
　　　char aa[10];
　　　printf("%d",strlen(aa));
软件开发网 www.mscto.com
　　}
　　sizeof()和初不初始化，没有关系；
　　strlen()和初始化有关。
　　char (*str)[20];/*str是一个数组指针，即指向数组的指针．*/
　　char *str[20];/*str是一个指针数组，其元素为指针型数据．*/
　　long a=0x801010;
　　a+5=?
　　0x801010用二进制表示为：“1000 0000 0001 0000 0001 0000”，十进制的值为8392720，再加上5就是8392725罗
　　1)给定结构
　　struct A
　　{
       　char t:4;
       　char k:4;
       　unsigned short i:8;
       　unsigned long m;
　　};
　　问sizeof(A) = ?
　　
　　给定结构
　　struct A
　　{
       　char t:4; 4位
       　char k:4; 4位
       　unsigned short i:8; 8位     
      　 unsigned long m; // 偏移2字节保证4字节对齐
　　}; // 共8字节
　　2)下面的函数实现在一个数上加一个数，有什么错误？请改正。
　　int add_n ( int n )
　　{
    　　static int i = 100;
    　　i += n;
    　　return i;
　　}
　　当你第二次调用时得不到正确的结果，难道你写个函数就是为了调用一次？问题就出在 static上？
　　// 帮忙分析一下
　　#include
　　#include
　　#include
　　#include
　　#include
　　#include
　　typedef struct  AA
　　{
        　int b1:5;
       　 int b2:2;
　　}AA;
　　void main()
　　{
　　　AA aa;
　　　char cc[100];
　　　strcpy(cc,"0123456789abcdefghijklmnopqrstuvwxyz");
　　　memcpy(&aa,cc,sizeof(AA));
　　　cout
软件开发网 www.mscto.cn
　　　cout 软件开发网 www.mscto.com
　　故共有1的个数为8，结果为8。
　　1000 - 1 = 0111，正好是原数取反。这就是原理。
　　用这种方法来求1的个数是很效率很高的。
　　不必去一个一个地移位。循环次数最少。
　　int a,b,c 请写函数实现C=a+b ,不可以改变数据类型,如将c改为long int,关键是如何处理溢出问题
　　bool add (int a, int b,int *c)
　　{
　　　*c=a+b;
　
　　return (a>0 && b>0 &&(*ca || *c>b)));
　　}
　　分析：
　　struct bit
　　{  
　　　int a:3;
   　　int  b:2;
    　　int c:3;
　　};
　　int main()
　　{
　　 bit s;
  　　char *c=(char*)&s;
   　　cout
软件开发网 www.mscto.com
　　
　　例如：   
　　struct bs   
　　{   
　　　int a:8;   
　　　int b:2;   
　　　int c:6;   
　　};   
　　位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明，同时定义说明或者直接说明这三种方式。例如：   
　　struct bs   
　　{   
　　　int a:8;   
　　　int b:2;   
　　　int c:6;   
　　}data;   
　　说明data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明：   
　　一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：   
　　
　　struct bs   
　　{   
　　　unsigned a:4   
　　　unsigned :0 /*空域*/   
　　　unsigned b:4 /*从下一单元开始存放*/   
软件开发网 www.mscto.cn
　　　unsigned c:4   
　　}   
　　在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。   
　　由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。   
　　位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：   
　　struct k   
　　{   
　　　int a:1   
　　　int :2 /*该2位不能使用*/   
　　　int b:3   
　　　int c:2   
　　};   
　　从以上分析可以看出，位域在本质上就是一种结构类型， 不过其成员是按二进位分配的。   
　　位域的使用位域的使用和结构成员的使用相同，其一般形式为： 位域变量名•位域名 位域允许用各种格式输出。   
　　main()
　　{   
　　　struct bs   
　　　{   
　　　　unsigned a:1;   
软件开发网 www.mscto.com
　　　　unsigned b:3;   
　　　　unsigned c:4;   
　　　}
　　　bit,*pbit;   
　　　bit.a=1;   
　　　bit.b=7;   
　　　bit.c=15;   
　　　pri
　　改错：
　　#include
　　int main(void)
　　{
　　　int **p;
   　　int arr[100];
　　　p = &arr;
　　　return 0;
　　}
　　解答：搞错了,是指针类型不同,int **p; //二级指针&arr; //得到的是指向第一维为100的数组的指针
　　
　　#include
　　int main(void)
　　{
　　　int **p, *q;
　　　int arr[100];
　　　q = arr;
　　　p = &q;
　　　return 0;
　　}
下面这个程序执行后会有什么错误或者效果:
　　#define MAX 255
　　int main()
　　{
   　　unsigned char A[MAX],i;//i被定义为unsigned char
   　　for (i=0;i

　　}
　　解答：死循环加数组越界访问（C/C++不进行数组越界检查）MAX=255 数组A的下标范围为:0..MAX-1,这是其一..
其二.当i循环到255时,循环内执行:A[255]=255;这句本身没有问题..但是返回for (i=0;i
　　struct s1
　　{
  　　　int i: 8;
　　　 int j: 4;
　　　 int a: 3;
  　　　double b;
　　};
　　struct s2
　　{
　　　 int i: 8;
　　　 int j: 4;
　　　 double b;
　　　 int a:3;
　　};
　　printf("sizeof(s1)= %d\n", sizeof(s1));
　　printf("sizeof(s2)= %d\n", sizeof(s2));
　　result: 16, 24
　　第一个struct s1
　　{
　　　  int i: 8;
　　　 int j: 4;
　　　 int a: 3;
　　　 double b;
　　};
　
　理论上是这样的，首先是i在相对0的位置，占8位一个字节，然后，j就在相对一个字节的位置，由于一个位置的字节数是4位的倍数，因此不用对齐，就放在
那里了，然后是a，要在3位的倍数关系的位置上，因此要移一位，在15位的位置上放下，目前总共是18位，折算过来是2字节2位的样子，由于double
是8字节的，因此要在相对0要是8个字节的位置上放下，因此从18位开始到8个字节之间的位置被忽略，直接放在8字节的位置了，因此，总共是16字节。
软件开发网 www.mscto.com
　　第二个最后会对照是不是结构体内最大数据的倍数，不是的话，会补成是最大数据的倍数。




[color="#295200"]发表于： 2008-06-29，修改于： 2008-06-29 18:06，已浏览854次，有评论5条
推荐
投诉







网友评论



网友：
本站网友 时间：2008-07-03 16:06:55    IP地址：222.210.192.★
慧通现在还在招人吗？
不是全都转成华为了？





网友：
本站网友 时间：2008-07-04 00:12:08    IP地址：121.15.138.★
　　char a[10],strlen(a)为什么等于15？运行的结果
　　#include "stdio.h"
　　#include "string.h"
　　void main()
　　{
　　　char aa[10];
　　　printf("%d",strlen(aa));
　}
　　sizeof()和初不初始化，没有关系；
　　strlen()和初始化有关。
这个感觉有问题。我跑了一下是3。 应该是和编译器或者机器有关吧？





网友：
zxg623
时间：2008-07-04 08:53:01    IP地址：219.134.139.★
　　sizeof()和初不初始化，没有关系；
　　strlen()和初始化有关。
和编译器没有关系，和分配的那一段内存有关，strlen()是遇到0结束的，所以这个值是随机的。





网友：
baicj
时间：2008-07-04 21:37:03    IP地址：222.129.39.★
刚看了最后一题，有问题吧？在32编译器上是12,16。64位编译器上是16,24
就算楼主选答案(16,24),可是对答案的解释也是错的。。





网友：
本站网友 时间：2008-07-05 21:40:00    IP地址：207.46.92.★
32位机器上是16，只是解释的稍微有点不对，我想应该是说，先分8bit，再4bit，现在还没有超过32，所以接下来直接分3bit，不用移位。
struct ER
{
    int b:8;
    int b1:4;
    int a:3;
    double t;
};
int _tmain(int argc, _TCHAR* argv[])
{
   
    ER s;
    strcpy((char*)&s,"1111");
    cout


               
               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u/16290/showart_1080457.html