浙江大华2011.10.10校园招聘会笔试题

请写出下面程序的输出结果：（答案在下面）
1、

[cpp]
view plaincopy

int count = 3;  
int main(void)  
{  
    int i, sum, count = 2;  
    for(i=0,sum=0; i<count; i+=2,count++)  
    {  
        static int count = 4;  
        count++;  
        if(i%2 == 0)  
        {  
            extern int count;  
            count++;  
            sum += count;  
        }  
        sum += count;  
    }  
    printf("%d %d\n",count, sum);  
    return 0;  
}  

2、

[cpp]
view plaincopy

void func(char str[50])  
{  
    printf("A %d B %d ",sizeof(str), strlen(str));  
}  
int main(void)  
{  
    char stra[] = "HelloWorld";  
    char *strb = stra;  
    printf("C %d D %d ",sizeof(stra), sizeof(strb++));  
    func(++strb);  
    printf("E %d F %d\n",strlen(stra), strlen(strb++));  
    return 0;  
}  

printf("C %d D %d ",sizeof(stra),sizeof(strb++)); 中的sizeof(strb++)并不对sizeof函数中strb进行自增运算，只是简单的求这个指针的大小，此时的strb指针还是指向stra。

3、

[cpp]
view plaincopy

#include <vector>  
int func(std::vector<int>vec)  
{  
    static int k = 2;  
    std::vector<int>::reverse_iterator it;  
    for(it = vec.rbegin(); it!=vec.rend(); ++it)  
    {  
        k += *it%2==0? ++*it: (*it)++;  
    }  
    return k;  
}  
int main(void)  
{  
    std::vector<int>vec;  
    for(int i = 0; i<4; i++)  
    {  
        vec.push_back(i);  
        printf("%d ",func(vec));  
    }  
    return 0;  
}  

 4、

[cpp]
view plaincopy

class Base  
{  
public:  
    int m_a;  
    Base(int a=2):m_a(a)  
    {  
        printf("A %d ",m_a);  
    }  
    virtual ~Base()  
    {  
        printf("B %d ",m_a);  
    }  
};  
class Derived:public Base  
{  
public:  
    Derived(int a=4):Base
4000
(a)  
    {  
        printf("C %d ",m_a);  
    }  
    ~Derived()  
    {  
        printf("D %d ",m_a);  
    }  
};  
int main(void)  
{  
    Base *aa,bb;  
    aa = new Derived;  
    delete aa;  
    return 0;  
}  

5、

[cpp]
view plaincopy

class Base  
{  
public:  
    int m_a,m_b;  
    Base(int a = 2,int b = 5):m_a(a),m_b(b)  {  }  
    int func_a()  
    {  
        return m_a - m_b;  
    }  
    virtual int func_b()  
    {  
        return m_a + m_b;  
    }  
};  
class Derived:public Base  
{  
public:  
    Derived(int a = 4, int b = 7):Base(a, b)  {  }  
    virtual int func_a()  
    {  
        return m_b + m_a;  
    }  
    int func_b()  
    {  
        return m_b - m_a;  
    }  
};  
int main(void)  
{  
    Base *aa, *bb;  
    aa = new Base(4, 7);  
    bb = new Derived(3, 5);  
    printf("%d %d %d %d\n",aa->func_a(), aa->func_b(), bb->func_a(), bb->func_b());  
    delete aa;  
    delete bb;  
    return 0;  
}  

6、

[cpp]
view plaincopy

struct SC  
{  
    int a;  
    int b;  
    int c;  
};  
struct SD  
{  
    int a;  
    int b;  
    int c;  
    int d;  
};  
int main(void)  
{  
    struct SC c1[] = {{3},{4},{5},{6}};  
    struct SD *c2 = (struct SD*)c1 + 1;  
    printf("%d %d %d %d\n",c2->a,c2->b,c2->c,c2->d);  
    return 0;  
}  

7、

[cpp]
view plaincopy

int func(int n)  
{  
    int k = 1;  
    if(n > 0)  
    {  
        k += func(--n);  
        printf("%d ", n);  
        k += func(--n);  
    }  
    return k;  
}  
  
int main(void)  
{  
    int a = 3;  
    printf("%d\n",func(a));  
    return 0;  
}  

答案：

1、  4   20

2、 C 11 D 4 A 4 B 9 E 10 F 9

3、 3  5  10  18

4、 A 2 A 4 C 4 D 4 B 4 
B 2

5、 -3 11 -2 2

6、 0  0  5  0

7、  0  1  2  0  9

编程题：
1、函数checkstr判断一字符串是不是对称的。其中msg为输入的字符串，对称返回0，不对称返回-1，实现该函数。

int checkstr(const char *msg);

[cpp]
view plaincopy

int checkstr(const char *msg)  
{  
    int len = strlen(msg);  
    int i, j;  
    for(i = 0,j = len-1; i <= j; i++,j--)  
    {  
        if(msg[i] != msg[j])  
            break;  
    }  
    if(i>j)  
        return 0;  
    else  
        return -1;  
}  

2、给出一个单向链表的头指针，输出该链表中倒数第K个节点的指针，链表的倒数第0个节点为链表的尾节点（尾节点的next成员为NULL）

typedef struct Node

{

         struct Node *next;

}NODE;
NODE* findnode(NODE *head,unsigned int k);

思路：在遍历时维持两个指针，第一个指针从链表的头指针开始遍历，在第k-1步之前，第二个指针p保持不动；

在第k-1步开始，第二个指针p也开始从链表的头指针开始遍历。由于两个指针的距离保持在k-1，当第一个（走在前面的）指针pcur到达链表的尾结点时，第二个指针指针p正好是倒数第k个结点。

这种思路只需要遍历链表一次。对于很长的链表，只需要把每个结点从硬盘导入到内存一次。因此这一方法的时间效率比较高。

[cpp]
view plaincopy

typedef struct Node  
{  
    struct Node *next;  
}NODE;  
  
NODE* findnode(NODE *head, unsigned int k)  
{  
    if(head==NULL)  
        return NULL;  
    NODE *p, *pcur;  
    pcur = head;  
    for(unsigned int i = 0; i < k; i++)  
    {  
        if(pcur->next != NULL)     //在第k-1步之前，第二个指针p保持不动  
            pcur = pcur->next;  
        else  
            return NULL;      //k比链表中节点的数目要大，找不到倒数第k个节点，直接返回空  
    }  
    p = head;  
    while(pcur->next)  
    {  
        pcur = pcur->next;  
        p = p->next;  
    }  
    return p;  
}  

简答题：

1、简述动态链接库DLL和静态链接库lib的差别。

静态链接库lib会在生成EXE文件后，全部被包含在exe文件中，而动态链接库Dll则不会，它会在exe可执行文件启动后动态加载和引用；另一个区别是：静态链接库lib不可以加载和引用其他的链接库，而Dll动态链接库则可以引用和加载其他链接库；

2、请简述MFC中的窗口收到WM_PAINT消息是如何处理的，什么情况下会产生WM_PAINT消息。

BeginPaint开始画，去掉原窗口；

GetClientPaint获得窗口显示区域和尺寸等信息并绘制

释放绘图句柄；

什么情况下会产生WM_PAINT消息？

第一次创建一个窗口时；

改变窗口大小时；

最大化和最小化窗口时；

把窗口从另一个窗口背后移出时 ；

3、请简述Critical Section 、Mutex、Semaphore的功能和差别

4、简述多线程程序对比单线程程序的优点
aa4f
和缺点。