面试题——太（上）

笔试···

#include <setjmp.h>
#include <stdlib.h>
#include <stdio.h>
static jmp_buf buf;
void main()
{
    volatile int b;
    b=3;
    if(setjmp(buf)!=0)
    {
        printf("%d ",b);
        exit(0);
    }
    b=5;
    longjmp(buf,1);
}

　　答案：5

#include <stdlib.h>
#include <stdio.h>
void foo(int [][3]);
void main()
{
    int a[3][3]={{1,2,3},{4,5,6},{7,8,9}};
    foo(a);
    printf("%d ",a[2][1]);
}
void foo(int b[][3])
{
    ++b;
    b[1][1]=9;
}

　　答案：9

#include <stdlib.h>
#include <stdio.h>
void e(int);
void main()
{
    int a;
    a=3;
    e(a);
}
void e(int n)
{
    if(n>0)
    {
        e(--n);
        printf("%d ",n);
        e(--n);
    }
}

　　答案：0 1 2 0

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
int ripple(int , ...);
void main()
{
    int num;
    num = ripple(3,5,7);
    printf("%d ", num);
}
int ripple(int n, ...)
{
    int i,j;
    int k;
    va_list p;
    k=0;
    j=1;
    va_start(p,n);
    
    for(;j<n;++j)
    {
    i=va_arg(p,int);
    for(;i;i&=i-1)
        ++k;
    }
    return k;
}

　　答案：5 　　省略号：表示你还可以添加诸如此类的一些参数，同时也说明这个函数对参数个数没有限制

二（1）ifndef/define/endif 　　

　　主要目的是防止头文件的重复包含和编译

二（2）memcpy 、memmove 、memccpy之间的区别

　　这三个函数的功能均是将某个内存块复制到另一个内存块。前两个函数的区别在于它们处理内存区域重叠(overlapping)的方式不同。第三个函数的功能也是复制内存，但是如果遇到某个特定值时立即停止复制。

　　memcpy只是memmove的一个子集；当内存发生局部重叠的时候，memmove保证拷贝的结果是正确的，memcpy不保证拷贝的结果的正确；

　　而void *memccpy(void *dest, void *src, unsigned char ch, unsigned int count)

　　功能：由src所指内存区域复制不多于count个字节到dest所指内存区域，如果遇到字符ch则停止复制。
　　说明：返回指向字符ch后的第一个字符的指针，如果src前n个字节中不存在ch则返回NULL。ch被复制。

二（3）C语言代码将无符号变量unsigned intval 进行字节序倒换　

　　unsigned i;
　　i = ((i<<24) & 0xff00000000) | ((i<<8) & 0x00ff0000) | ((i>>8) & 0x0000ff00) | ((i>>24) & 0x00000000ff);

二（4）说出一种Linux 系统常用代码管理器，并列举几个简单的使用命令

　　最流行的开源版本控制工具要数Subvision（SVN）、Git以及Mercurial（hg）了，其中SVN是集中式版本控制工具，Git和Mercurial则是分布式的。

　　Git 是 Linus Torvalds 最近实现的源代码管理软件。正如所提供的文档中说的一样，“Git 是一个快速、可扩展的分布式版本控制系统，它具有极为丰富的命令集，对内部系统提供了高级操作和完全访问。

　　Git 目前主要由寻找 CVS 或专有代码管理解决方案替代物的软件开发人员所使用。Git 与 CVS 有很多区别：1）分支更快、更容易。2）支持离线工作；本地提交可以稍后提交到服务器上。3）Git 提交都是原子的，且是整个项目范围的，而不像 CVS 中一样是对每个文件的。4）Git 中的每个工作树都包含一个具有完整项目历史的仓库。5）没有哪一个 Git 仓库会天生比其他仓库更重要。

导出文件
$ git clone admin@192.168.0.1:~/0xdroid/packages/apps/Settings
提交代码至服务器
$ git push admin@192.168.0.1:~/0xdroid/packages/apps/Settings
发布patch
为了得到带commit信息的patch文件，我们在获得patch时可按以下步骤：
-1. 进入到当前目录，改变你的用户名和邮件
   $ git config user.name“your name”
   $ git config user.email “your email”
-2. 添加并提交你的修改，这个跟上次git简单使用方法一样
   $ git add xxx.java
   $ git commit -m “what you want to describe”
-3. 获得patch
   $ git log  (此处是为了获得你提交修改的上一级commit信息，如2xxxxxx)
   $ git format-patch 2xxxxxxx  (获得带有commit信息的patch文件)
-4. patch文件默认在你当前目录下，可以自行查找并修改文件名。
-5. 将上述patch文件打到自己的目录下
   $ git am xxx.patch (这样你的目录下就有了commit信息)
-6. 另：原来打patch使用patch -p1 < xx.patch 较为复杂，其实，在git下有
   $ git apply xx.patch  (可以打patch，不带commit信息)
   再另：上次写的git whatchanged可以直接用git log代替，获得修改信息。

　　collabnet SVN 　　Visual SVN　　

sudo apt-get install subversion subversion-tools 安装subversion 

svnadmin create /svn/repository 创建新的存储库
数据储存方式默认采用Berkeley DB。

svn import /svn/repository file:///data/ldap 导入源码
把/data/ldap整个目录导入到储存库中的repository目录中，储存库的repository目录会自动创建。
 
svnserve -d -r /home/declan/svnproject --listen-port 21  启动subversion（可以设定端口）

二（5）big endian little endian 是有什么含义？对网络编程有何影响？

　　表示计算机字节顺序的两种格式,所谓的字节顺序指的是长度跨越多个字节的数据的存放形式。

　　Little Endian: 将字节的逻辑顺序与物理顺序一致，即将逻辑上较低的字节放置在物理上较低的字节上，比如Intel x86系列；

　　Big Endian：字节的逻辑顺序与物理顺序相反，即将逻辑上较低的字节放置在物理上较高的字节上，比如Motorola的powerpC以及Sun Sparc。

Big-Endian	一个Word中的高位的Byte放在内存中这个Word区域的低地址处。
Little-Endian	一个Word中的低位的Byte放在内存中这个Word区域的低地址处。

　　判断一个机器用的bigendian or little endian只用如下代码即可: 
int machine_uses_big_endian = 1 ; (byte *) &machine_uses_big_endian)[0] = 0;

　　或者：利用union体：#include "stdio.h"　　typedef union endian_test{int a;char b;} e_t;

int main()　　{e_t c; c.a = 1;　　 if (c.b)  printf("little endian\\n"); else  printf("big endian\\n");　　return (int)c.b;}

　　由于Little Endian提供了逻辑顺序与物理顺序的一致性，让编程者摆脱了不一致性所带来的困扰，C语言开发者可以无所顾忌的按照自己的意愿进行强制类型转换；但Big Endian也有其优点，尤其对于汇编程序员：他们对于任意长度的整数，总是可以通过判断Byte 0的bit-7来查看一个整数的正负（补码的首位标识正负）；对于Little Endian则不得不首先知道当前整数的长度，然后查看最高byte的bit-7来判断其正负。对于这种情况，big endian的开发者可以写出非常高效的代码。

　　TCp/Ip协议指定其数据格式为Big endian，因此Big Endian的CpU处理起来更方面；对于Little-Endian的CpU, 如x86，应用中需要首先转换TCp/Ip的数据为little endian格式。实际上，pOSIX提供相应的操作函数，这些函数是htonl(), ntohl(), htons()和ntohs()。

　　假设little endian方式的CPU要传给big endian方式CPU一个字节的话，其本身在传输之前会在本地就读出这个8比特的数，然后再按照网络字节序的顺序来传输这8个比特，这样的话到了接收端不会出现任何问题。而假如要传输一个32比特的数的话，由于这个数在littel endian方存储时占了4个字节，而网络传输是以字节为单位进行的，little endian方的CPU读出第一个字节后发送，实际上这个字节是原数的LSB，到了接收方反倒成了MSB从而发生混乱。

　　little-endian的优势在于unsigned char/short/int/long类型转换时，存储位置无需改变

　　在网络传输中，采用big-endian序，对于0x0A0B0C0D，传输顺序就是0A 0B 0C 0D，因此big-endian作为network byte order，little-endian作为host byte order。网络字节序（network byte order）和主机字节序（host byte order）。

三（1）编写一个程序，要求输入任意两个32位无符号整数，该函数在控制台打印两个数字相加的结果，要求过程禁用64位变量。

 

三（2）输入参数为一个字符串指针，要求完成大小写转换

 char c;
   c ^= 0x20;

 

面试···

1. 无符号变量unsigned intval 进行字节序倒换（怎么想的）

2. 安装软件

Redhat Linux提供的一种包封装格式——RedHat  Packge  Manager
rpm –ivh software-1.2.3-1.i386.rpm
rpm 参 数 说 明 
-i  安装软件 
-t  测试安装，不是真的安装 
-p 显示安装进度 
-f  忽略任何错误 
-U 升级安装 
-v 检测套件是否正确安装
卸载：rpm –e software

Debian Linux提供的一个包管理器
安装 dpkg –i software-1.2.3-1.deb
卸载 dpkg –e software

tar包 执行：“tar –xvzf 软件包名”，就可以一步完成解压与解包工作。如果不是，则先用解压软件，再执行“tar –xvf 解压后的tar包”进行解包； 
执行“./configure”命令为编译做好准备； 
执行“make”命令进行软件编译； 
执行“make install”完成安装； 
执行“make clean”删除安装时产生的临时文件。 

apt-get install packagename——安装一个新软件包（参见下文的aptitude）
apt-get remove packagename——卸载一个已安装的软件包（保留配置文件）
apt-get --purge remove packagename——卸载一个已安装的软件包（删除配置文件）
dpkg --force-all --purge packagename ——有些软件很难卸载，而且还阻止了别的软件的应用，就可以用这个，不过有点冒险。

3. 建立数据库实现对指定字段的搜索快

4. 向头结点后插入新节点

5. 做过的项目构架（如：聊天视频广播中，server端如何实现的？画出来）三次握手

　　网络聊天室结构图：

程序流程图——客户端注册登陆

客户端程序流程图

服务器程序流程图

6. TCP抢占服务器 如何处理（锁？）

7. gdb

　　http://blog.csdn.net/liigo/article/details/582231GDB十分钟教程

8. 看待堆与栈

1、栈区（stack）―   由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 
2、堆区（heap） ―   一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。 
3、全局区（静态区）（static）―，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 
4、文字常量区  ―常量字符串就是放在这里的。 程序结束后由系统释放 
5、程序代码区―存放函数体的二进制代码。

二、例子程序 
这是一个前辈写的，非常详细 
//main.cpp 
int a = 0; 全局初始化区 
char *p1; 全局未初始化区 
main() 
{ 
int b; 栈 
char s[] = "abc"; 栈 
char *p2; 栈 
char *p3 = "123456"; 123456\0在常量区，p3在栈上。 
static int c =0； 全局（静态）初始化区 
p1 = (char *)malloc(10); 
p2 = (char *)malloc(20); 
分配得来得10和20字节的区域就在堆区。 
strcpy(p1, "123456"); 123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。 
} 
二、堆和栈的理论知识 
2.1申请方式 
stack: 
由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间 
heap: 
需要程序员自己申请，并指明大小，在c中malloc函数 
如p1 = (char *)malloc(10); 
在C++中用new运算符 
如p2 = (char *)malloc(10); 
但是注意p1、p2本身是在栈中的。 
2.2 
申请后系统的响应 
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。 
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时， 
会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。 
2.3申请大小的限制 
栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。 
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。 
2.4申请效率的比较： 
栈由系统自动分配，速度较快。但程序员是无法控制的。 
堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便. 
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。 
2.5堆和栈中的存储内容 
栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。 
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。 
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。 
2.6存取效率的比较 
char s1[] = "aaaaaaaaaaaaaaa"; 
char *s2 = "bbbbbbbbbbbbbbbbb"; 
aaaaaaaaaaa是在运行时刻赋值的； 
而bbbbbbbbbbb是在编译时就确定的； 
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。 
比如： 
#include 
void main() 
{ 
char a = 1;
char c[] = "1234567890";
char *p ="1234567890";
a = c[1];
a = p[1];
return;
} 

9. 说说数组和指针的区别

　　指针的本质是一个与地址相关的复合类型，它的值是数据存放的位置（地址）；数组的本质则是一系列的变量。

　　数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。

　　当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。数组名可以当作一个指针来用，数组名可以用*取其中的值，指针也可以用[]解引用，但它们还是有一些区别指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。指针远比数组灵活，但也更危险。