*****面试笔试总结

最新推荐文章于 2019-09-24 23:38:20 发布

javaadu

最新推荐文章于 2019-09-24 23:38:20 发布

阅读量992

点赞数

分类专栏：程序猿笔试/面试 C/C++

本文链接：https://blog.csdn.net/duqi_2009/article/details/38083573

版权

C/C++ 同时被 2 个专栏收录

35 篇文章 0 订阅

订阅专栏

程序猿笔试/面试

20 篇文章 0 订阅

订阅专栏

1、如何实现malloc()？请说明malloc()和free()的原理？

答：

参考《C程序设计》第8.7；

malloc的实现与思考

关键点：

（1）使用联合实现空闲块，以实现地址对齐: 使用union而不是直接使用struct的原因是为了地址对齐。这里是long对齐，union的x永远不会使用

typedef long Align;/*for alignment to long boundary*/
union header { 
    struct {
        union header *ptr; /*next block if on free list*/
        unsigned size; /*size of this block*/
    } s;
    Align x;
};

typedef union header Header;</span>

（2）内存分配算法(malloc的原理)

循环首次适应算法，当有申请请求时，malloc将扫描空闲块链表，直到找到第一个足够大的块为止，每次扫描的起点是上次找到空闲块的地方开始；与之相对的算法是“最佳适应算法”，它寻找满足条件的最小块。
如果该块恰好与请求的大小相符合，则将它从链表中移走并返回给用户；
如果该块太大，则将它分成两部分：大小合适的块返回给用户，剩下的部分留在空闲块链表中
如果找不到一个足够大的块，则调用morecore()，进而调用sbrk(n)向OS申请一个大块并加入到空闲链表中

malloc()

static Header base;
static Header *freep = NULL;

void *malloc(unsigned nbytes)
{
    Header *p, *prevp;
    unsigned nunits;
    nunits = (nbytes+sizeof(Header)-1)/sizeof(Header) + 1;
    if((prevp = freep) == NULL) { /* no free list */
        base.s.ptr = freep = prevp = &base;
        base.s.size = 0;
    }
    for(p = prevp->s.ptr; ;prevp = p, p= p->s.ptr) {
        if(p->s.size >= nunits) { /* big enough */
            if (p->s.size == nunits)  /* exactly */
                prevp->s.ptr = p->s.ptr;
            else {
                p->s.size -= nunits;  // 计算出应该对p调整的Offset 
                p += p->s.size;       // 将p移动到合适的位置，p代表要返回给用户的地址
                p->s.size = nunits;   // 调整p指向内存区的大小
            }
            freep = prevp;  //freep记录上次查找的位置，所以这个算法是循环优先使用算法
            return (void*)(p+1);
        }
        if (p== freep) /* wrapped around free list */
            if ((p = morecore(nunits)) == NULL)
                return NULL; /* none left */
    }
}

（3） morecore()的原理

morecore()

#define NALLOC 1024    /* minimum #units to request */
static Header *morecore(unsigned nu)
{
    char *cp;
    Header *up;
    if(nu < NALLOC)
        nu = NALLOC;
    cp = sbrk(nu * sizeof(Header));
    if(cp == (char *)-1)    /* no space at all*/
        return NULL;
    up = (Header *)cp;
    up->s.size = nu;
    free((void *)(up+1));    return freep;
}

在这里，发现malloc()->morecore()->free()的调用链，free()是把空闲链表进行扩充，而malloc()在空闲链表不足时，从系统申请到更多内存空间后，也要先把它们转化成空闲链表的一部分，再进行利用。这样，malloc()调用free()完成后面的工作也是顺理成章了.

（4）内存释放算法（free的原理）

搜索空闲链表，找到可以插入被释放块的合适位置
将被释放块插入到空闲链表中，要处理下面三种情况：一、bp需要同时与高/低位合并；二、bp需要跟高/低位之间的一个合并；三、没有发生合并，bp简单加入到链表中
修改freep=p，指向空闲区的首地址

free()

void free(void *ap)
{
    Header *bp,*p;
    bp = (Header *)ap -1; /* point to block header */
    for(p=freep;!(bp>p && bp< p->s.ptr);p=p->s.ptr)
        if(p>=p->s.ptr && (bp>p || bp<p->s.ptr))
            break;    /* freed block at start or end of arena*/
    if (bp+bp->s.size==p->s.ptr) {    /* join to upper nbr */
        bp->s.size += p->s.ptr->s.size;
        bp->s.ptr = p->s.ptr->s.ptr;
    } else
        bp->s.ptr = p->s.ptr;
    if (p+p->s.size == bp) {     /* join to lower nbr */
        p->s.size += bp->s.size;
        p->s.ptr = bp->s.ptr;
    } else
        p->s.ptr = bp;
    freep = p;
}

free()首先定位要释放的ap对应的bp与空闲链表的相对位置，找到它的的最近的上一个和下一个空闲空间，或是当它在整个空闲空间的前面或后面时找到空闲链表的首尾元素。注意，由于malloc()的分配方式和free()的回收时的合并方式（下文马上要提到），可以保证整个空闲空间的链表总是从低地址逐个升高，在最高地址的空闲空间回指向低地址第一个空闲空间。定位后，根据要释放的空间与附近空间的相邻性，进行合并，也即修改对应空间的Header。两个if并列可以使得bp可以同时与高地址和低地址空闲空间结合（如果都相邻），或者进行二者之一的合并，或者不合并。

2、使用一行C语言代码判断某个数是否可被2整除？

(n&1 == 0)，判断地位是否为0即可，是0则能被2整除，否则不能

相似题目：((n & (n-1)) == 0)的含义是：判断n的值是否为2的某次方

3、按位翻转一个unsigned int 数

（1）朴实的算法，循环位移：结果左移-->设置c的最低位到结果中-->c右移，然后循环

unsigned int f(unsigned int c)
{
        unsigned int s = 0;
        int i;
        for (i = 0; i < 32; ++i) {
                s <<= 1;  
                s |= c & 1;
                c >>= 1;
        }
        return s;
}

（2）最佳算法？？？？

原理说明：

unsigned int
reverse(register unsigned int x)
{
    x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
    x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
    x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
    x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
    return((x >> 16) | (x << 16));
 
}

（3）查表法

static const unsigned char BitReverseTable256[] =
{
  0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
  0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
  0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
  0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
  0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
  0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
  0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
  0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
  0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
  0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
  0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
  0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
  0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
  0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
  0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
  0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
};
 
unsigned int v; // reverse 32-bit value, 8 bits at time
unsigned int c; // c will get v reversed
 
// Option 1:
c = (BitReverseTable256[v & 0xff] << 24) |
    (BitReverseTable256[(v >> 8) & 0xff] << 16) |
    (BitReverseTable256[(v >> 16) & 0xff] << 8) |
    (BitReverseTable256[(v >> 24) & 0xff]);
 
// Option 2:
unsigned char * p = (unsigned char *) &v;
unsigned char * q = (unsigned char *) &c;
q[3] = BitReverseTable256[p[0]];
q[2] = BitReverseTable256[p[1]];
q[1] = BitReverseTable256[p[2]];
q[0] = BitReverseTable256[p[3]];

4、多进程和多线程的区别？哪些资源由多线程共享，但是多进程不能共享？

答：

进程可以看作是程序执行时的实例，是一个分配了系统资源(CPU时间和内存)的独立实体。每个进程都在各自独立的地址空间里执行，一个进程无法直接访问另一个进程的私有变量和数据结构。如果一个进程想要访问其他进程的资源，就必须使用进程间通信机制，包括管道、文件、套接字以及其他形式。
线程存在于进程中，多线程共享进程的地址空间和打开的文件等资源。每个线程仍然会有自己私有的寄存器和堆栈
线程是进程的某条执行路径
在现代操作系统中，认为进程是系统资源的最小分配单位；线程是系统的最小调度单位。

5、数据结构：实现在一个数组里有两个栈的数据结构，当两个栈顶指针相遇，则栈满，考察push(int num,int stack)的写法，注意思维的全面性；

6、数据结构：在一个单调非递减的单链表中，插入新的一个节点，让其仍然保持单调非递增，考察insert(LNode *head, int num)函数的写法；

7、定义一个二维数组a[2][2]，那么a+1只的是第二行的地址，即*(*(a+1)) 等同于a[1][0]

参考：

数组与指针的艺术

二维数组作为函数参数传递

8、不用sizeof操作符，计算一个整型变量所占的字节数

定义一个两个整型元素的数组，然后两个元素的地址差，就是一个整型元素所占的字节数；

#include <stdio.h>

int main(int argc, char *argv[])
{

        int a[2];
        printf("%x %x\n", &a[0], &a[1]);

        int nbytes;
        nbytes = int(&a[1]) - int(&a[0]);
        printf("%d\n", nbytes);

        int nbytes2;
        nbytes2 = &a[1] - &a[0]; 
        printf("%d\n", nbytes2);

        return 0;
}

输出如下：

13ff5c 13ff60

解释：数组中两个元素的地址直接相减，含义是这两个地址之间的元素的个数，所以必须给他们做(int)&a[0]的强制类型转换。

9、僵尸进程和孤儿进程有什么区别？

答：

僵尸进程：一个进程使用fork创建子进程，如果子进程退出。而父进程并没有调用wait或者waitpid获取子进程的状态信息，那么子进程的进程描述符仍然被保存在系统中，这种进程称之为僵尸进程。

孤儿进程：一个父进程退出，而它的一个或者多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程（进程号为1）所收养，并由init进程完成对它们的状态收集工作。

孤儿进程没什么危害；僵尸进程会占用系统的进程号，如果产生大量的僵尸进程，就可能因为没有可用的进程号而导致系统不能产生新的进程，因此僵尸进程应当避免。

参考：僵尸进程和孤儿进程的总结

看这篇博文的时候，发现最后这个信号处理函数里，waitpid的用法不太懂：

static void sig_handler(int signo)
{
      pid_t          pid;
      int          stat;

      while((pid = waitpid(-1, &stat, WNOHANG)) > 0){
            printf("child %ld terminated......\n", (long)pid);
      }
}

UNIX对信号是不排队的，当5个子进程同时结束，产生5个SIGCHLD信号，提交到父进程，父进程只看成是一个SIGCHLD信号，为何用while就可以捕获到所有发出SIGCHLD信号的子进程？不是只有一个SIGCHLD信号了吗？