深信服08年笔试题

填空选择类

2
12
1112
3112
132112
311322或1113122112下一行是什么？有什么规律？ ///已解决

意思是上面一行有1个1，1个3，1个2，2个1，1个2，即132112

（M）？（a++）：（ a--），A，M==O，B，M==1，C，M！=O，D，M！=1
(条件表达式) ? (条件为真时的表达式)条件为假时的表达式)  ///已解决

4以下哪些通信方式是可靠的通讯方式  
1信号2管道3消息4tcp 5udp 6串口I/O

可靠：信号 管道 tcp
可以在不同主机之间的：

Unix的启动顺序排序。
(A)        Rc.X  (B) Rc.sysinit (C) login (D) init

DBAC

进程的几个基本状态：就绪、执行、阻塞

程序：

现有1000个球，10个盒子，问各个盒子内应该分别放入多少个球，才能达到需要1至1000
之间任何数量的球，你都可以用若干盒子组合出来（用C/C++编写程序）

1、2、4、8、16、32、64、128、256、489

用一个程序示意常见的错误能够导致栈破坏，如何检查？

#include "iostream.h"
#include "string.h"
void main()
{
        char str[5];
        cout<<"input: ";
        cin>>str;
        while(strlen(str)>5)
        {
                cout<<"too long!"<<endl;
                cin>>str;
        }
        cout<<str<<endl;
}

如果系统堆栈很小,不能处理超过4级的函数调用,如何解决八皇后问题
#include<iostream.h>
void main()
{
        int A[8];
        int flag;//标记
        int m=0;//总共有几种答案
        int t,tt;
        for(int a=1;a<=8;a++)
                for(int b=1;b<=8;b++)
                        for(int c=1;c<=8;c++)
                                for(int d=1;d<=8;d++)
                                        for(int e=1;e<=8;e++)
                                                for(int f=1;f<=8;f++)
                                                        for(int g=1;g<=8;g++)
                                                                for(int h=1;h<=8;h++)
                                                                {
                                                                        // 为了便于运算数组里
                                                                        A[0]=a;  //A=k  指第i行的在第k列已经有放置
                                                                        A[1]=b;
                                                                        A[2]=c;
                                                                        A[3]=d;
                                                                        A[4]=e;
                                                                        A[5]=f;
                                                                        A[6]=g;
                                                                        A[7]=h;
                                                                        //比较是否在同一列
                                                                        flag=0;
                                                                        for(int i=7;i>0;i--)
                                                                        {
                                                                                for(int j=0;j<i;j++)
                                                                                {
                                                                                        if(A==A[j])
                                                                                        {
                                                                                                flag=1;
                                                                                                break;
                                                                                        }

                                                                                }
                                                                                if(flag)
                                                                                        break;
                                                                        }
                                                                        if(!flag)//比较是否在对角线上
                                                                                for( i=7;i>0;i--)
                                                                                {
                                                                                        for(int j=0;j<i;j++)
                                                                                        {
                                                                                                t=A;
                                                                                                tt=A[j];
                                                                                                if(tt>t)
                                                                                                {
                                                                                                        tt=9-tt;
                                                                                                        t=9-t;
                                                                                                }
                                                                                                if(t-i==tt-j)
                                                                                                {
                                                                                                        flag=1;
                                                                                                        break;
                                                                                                }

                                                                                        }
                                                                                        if(flag) break;
                                                                                }
                                                                                if(!flag)
                                                                                {
                                                                                        //cout<<endl<<endl;
                                                                                        for(i=0;i<=7;i++)
                                                                                                cout<<A<<" ";
                                                                                        m++;
                                                                                        cout<<"************************"<<m<<endl;
                                                                                }
                                                                }
}

要求在s1中删除所有s2的字符，要用最快的算法
引入 char tempstr[256]={0}; char* p1=s1 ; char* p2=s2;
1、        第一次遍历S2，while(*p2) tempstr[*p2++]=1;
2、        第二次遍历S1，
while(*p1)
{
                If(tempstr[*p1==’1’])
{
                        *p1=0;
}
P1++;
}
3、        再次遍历S1
P1=s1;
While(*p1)
{
                If(*p1==’0’)
{
                        P2=p1+1;
                        While(*p2==’0’)
                                P2++;
                        *p1=*p2;
                        *p2=’0’
                        P1=p2;
}
}

写一个函数判断系统是大端还是小端。若处理器是Big_endian的，则返回0；若是Little_endian的，则返回1.
大端格式：在这种格式中，字数据的高字节存储在低地?span href="tag.php?name=%B7%D6%D0%A3" onclick="tagshow(event)" class="t_tag">分校??质?莸牡妥纸谠虼娣旁诟叩刂分?br /> 小端格式：与大端存储格式相反，在小端存储格式中，低地址中存放的是字数据的低字节，高地址存放的是字数据的高字节
联合体union的存放顺序是所有成员都从低地址开始存放。
Int checkCPU ()
{
        Union w
{
        Int a;
        Char b;
}c;
c.a=1;
return (c.b==1);
}




给出两个链表的头指针pHead1 和 pHead2 ，写一个函数判断两条链表有没交叉点
Node* checkLink(Node* pHead1,Node* pHead2)
{
        Node* p1=pHead1,p2=pHead2;
        int i=1,j=1;
        if(p1==NULL || p2==NULL)
                return NULL;
        if(p1==p2)
                return p1;
        while(p1->pNext!=NULL)
        {
                p1=p1->pNext;
                i++;
        }
        while(p2->pNext!=NULL)
        {
                p2=p2->pNext;
                j++;
        }
        if(p1==p2)
                return NULL;
        else
        {
                for(int k=0;k<fabs(a-b);k++)
                {
                        if(i>j)
                                p1=p1->pNext;
                        else
                                p2=p2->pNext;
                }
                while(p1!=p2)
                {
                        p1=p1->pNext;
                        p2=p2->pNext;
                }
                return p1;
        }
}

用C/C++编程，从1到100中取出10个不同的数，要求打印出所有可能的组合；
#include <iostream.h>
int source[100];
int dest[10]={0};
int index_source=0;
int index_dest=0;
int k=10;
int i=0;
int j=0;
void composition(int source[], int index_source, int dest[], int index_dest, int k)
{
        if(100-index_source==k)
        {
                for(i=0; i<index_dest; i++)
                {
                        cout<<dest<<" ";
                }
                for(i=index_source; i<100; i++)
                {
                        cout<<source<<" ";
                }
                cout<<endl;
                return;
        }
        if(index_source<100 && k==1)
        {
                for(i=index_source; i<100; i++)
                {
                        for(j=0; j<index_dest; j++)
                        {
                                cout<<dest[j]<<" ";
                        }
                        cout<<source<<endl;
                }
                return;
        }
        composition(source, index_source+1, dest, index_dest, k);
        dest[index_dest++]=source[index_source];
        composition(source, index_source+1, dest, index_dest, k-1);
}

void main()
{
        for(int i=0;i<100;i++)
                source=i;
        composition(source,0, dest, 0, 10);
}


问答

const 有什么用途？（请至少说明两种）
1、        用在变量前面的时候可以避免变量被修改
2、        用在函数声明部分允许const 的类对象成员访问const 成员函数，如果类的成员函数不会对数据成员进行修改的话最好把该函数定义为const类型，这样无论是const的类对象还是非const 的类对象都可以访问该函数
3、        可以用来代替define ，define 只是简单的代替，但是const 还会进行类型检查。

怎么避免头文件重复包含

#ifndef  H_HEADFILENAME
#define  H_HEADFILENAME
文件内容….
#endif

拷贝构造函数和赋值号的异同

同：都可以对对象的成员进行赋值
异：
拷贝构造函数首先是一个构造函数，它调用的时候产生一个对象，是通过参数传进来的那个对象来初始化，产生的对象。
赋值是把一个对象赋值给一个原有的对象，而且还要检查一下两个对象是不是同一个对象，如果是的话就不做任何操作。

哈希表和平衡二叉树的适用场合

哈希表：哈希表查找速度比较快，但是要耗比较多的内存。所以比较适用于对查找速度要求比较高、且内存空间足够的时候
平衡二叉树：如果想在以后用二分法查找的时候查找速度比较快的话用建立平衡二叉树的方法（）

recv函数如何在阻塞模式下没有收到数据就返回

检查window （release）下的内存泄漏

1、        放置关键字 assert（）
2、        生成map 文件。它并不往可执行文件exe 中添加任何东西，只是在编译的时候将各个函数入口地址记录在后缀为.map的文件中，程序崩溃的时候可以得到一个EIP地址，通过地址知道崩溃所在函数
3、        可以设置断点，在希望设置断点的地方加入 _ASM int 3
4、        可以通过编译时的汇编程序看出
5、        采用第三方工具
在C++中extern c的作用
1、        extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用
2、        被extern "C"修饰的变量和函数是按照C语言方式编译和连接的；

临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）、事件（Event）的区别
1、临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。在任意时刻只允许一个线程对共享资源进行访问，如果有多个线程试图访问公共资源，那么在有一个线程进入后，其他试图访问公共资源的线程将被挂起，并一直等到进入临界区的线程离开，临界区在被释放后，其他线程才可以抢占。
2、互斥量：采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享
3、信号量：它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目
4、事 件： 通过通知操作的方式来保持线程的同步，还可以方便实现对多个线程的优先级比较的操作

Main函数中两个参数的作用
第一个形参argc是一个整型变量，第二个形参argv是一个指针数组，其元素指向字符型
数据。
用带参数的main函数可以直接从命令行得到参数值（这些值是字符串），在程序运行
时，可以根据输入的命令行中的不同情况进行相应的处理。利用main函数中的参数可以使
程序从系统得到所需的数据，增加了处理问题的灵活性。