迅雷C++笔试卷B-2013年

一、单项选择题

1、下列for循环的循环体执行次数为（）

for(int i=10, j=1; i=j=0; i++, j--) 

A、0         B、1         C、无限         D、以上都不对
2、下⾯程序的输出结果是（）

char *p1= “123”, *p2 = “ABC”, str［50］= "xyz";
strcpy（str+2,strcat（p1,p2））;
cout << str;

A、xyz123ABC        B、z123ABC        C、xy123ABC        D、出错
3、下面函数的执行结果是输出（）

char str[ ] = “xunlei”;
char *p = str;
int n = 10;
printf(“%d, %d, %d/n”, sizeof(str), sizeof(p), sizeof(n));

A、4, 4, 4         B、7, 4, 4         C、6, 4, 4         D、6, 6, 4
4、如下程序，若从键盘输⼊：abc def， 则输出结果是（）

char *p, *q;
p = (char*) malloc(sizeof(char) * 20);
q = p;
scanf(“%s %s”, p, q);
printf(“%s %s\n”, p, q);

A、def def         B、abc def         C、abc d         D、d d
5、现在有以下语句：

struct _THUNDER{
       int iVersion;
       char cTag;
       char cAdv;
       int iUser;
       char cEnd;
}Thunder;
int sz = sizeof(Thunder);

则执行后，变量sz的值将得到

A、11         B、12         C、13         D、16
6、有如下程序段：

void GetMemeory(char* p)
{
    p = (char*) malloc (100);
｝
void test()
{
    char *str=NULL;
    GetMemory(str);
    strcpy(str,”Thunder”);
    strcat(str+2, “Downloader”);
    printf(str);
}

请问运⾏test函数结果是（）

A、Thunder Downloader           B、under Downloader           C、Thunderownloader           D、程序崩溃

7、空格处应填写（）

#include <iostream>
using namespace std; 
class A
{
    public:
        int m;
        int* p;
}; 
int main()
{
    A s;
    s.m = 10;
    cout<<s.m<<endl; //10
    s.p = &s.m;
    () = 5;
    cout<<s.m<<endl; //5
    return 0;
}

A、s.p = 5         B、s->p = 5         C、s.*p = 5         D、*s.p = 5
8、函数的返回值是（）

fun（char* p） { 
    return p;
}

A、无确切值         B、行参p中存放的地址值         C、⼀个临时存储单元的地址         D、行参p自身的地址值
9、a,b均为不等于0的整形变量，以下关系式恒成立的是：

A、a*b/a*b == 1         B、a/b*b/a == 1         C、a/b*b + a%b == a         D、a/b*b == a
10、设有如下说明：

typedef struct ST{ 
    long a; int b; char c[2]; 
} NEW;

则下面叙述中正确的是（）

A、以上的说明形式非法         B、ST是⼀个结构体类型         C、NEW是⼀个结构体类型         D、NEW是⼀个结构体变量

二、不定项选择题

11、下列表达式中，不合法的是（）
       已知：double d = 3.2; int n = 3;
A、d<<2;         B、d/n         C、!d && (n-3)         D、(d-0.2)|n
12、下面描述正确的是（）

A、while循环语句的循环体⾄少执行1         B、do-while循环可以写成while循环的格式
C、continue语句可以出现在各种循环体中        D、break语句不可以出现在循环体内
13、关于内联函数正确的是（）

A、类的私有成员函数不能作为内联函数         B、在所有类说明中内部定义的成员函数都是内联函数
C、类的保护成员函数不能作为内联函数         D、使用内联函数的地方会在运行阶段用内联函数体替换掉
14、下面模板声明中，哪些是非法的（）

A、template<class Type>class C1;         B、template<class T, U, class V>class C2;
C、template<class C1, typename C2>class C3{};         D、template<typename myT, class myT>class C4{};
15、在使用浏览器打开一个网页的过程中，浏览器会使用的网络协议包括（）

A、DNS         B、TCP         C、HTTP         D、Telnet

三、问答题

16、有n个文件的长度记载在一个无符号64位整数数组中unsigned__int64 file_length[n]，把这n 个文件从逻辑上按序首尾拼接在一起形成一个逻辑上的大文件，然后以每块长度为unsigned block_length把这个逻辑上的大文件划分成大小相等的数据块（当然，最后一块有可能比block_length小），请定义和实现一个函数，把边界块的序号集合返回给函数的调用者（第一个数据块序号为0）。
注：边界块指的是跨多个文件的数据块。
17、请实现一个函数，把两个从大到小的有序链表合并成一个链表，新的链表是一个从小到大的有序链表。

struct list
{
    int value;
    list* next;
};
list * merge (list *list1_head, list*list2_head);

18、如果两个英文单词，组成它们的字符集合相同，而且相同字符出现的次数也相同，则称这两个词匹配：比如说：同”abbc”与词 ”babc”是匹配的。有一个词典，存储在字符串数组const char* dictionary[n]中，数组的每一个元素是一个词。对于任意给出的句子。句子中的单词使用空格分割。请实现以下函数，判断句子中是否有词和词典中的词匹配。
bool is_matching( const char* dictionary[],int n, const char* sentence);

参考答案

1、A    2、D    3、B    4、A   5、D    6、D    7、D   8、B    9、C    10、C

11、AD

12、ACD

13、B

14、BD

15、ABC

16、参考代码：

#include <iostream> 
#include <vector>
using namespace std;
 
#define N 10  
unsigned __int64 file_length[N]={15,120,250,600,5,5,30,65,70,100};
unsigned block_length=30;
 
vector<int> getIndex(unsigned __int64 *file_length,int n,unsigned block_size)
{
    vector<int> res;
    int index=0; //block序号
    int i=0; //file_length序号
    while(i<n)
    {
        if(file_length[i]==0) //特殊情况，某个文件长度为0则跳过
        {
            i++;          
            continue;
        }
        if(file_length[i]<block_size) //某个文件长度小于块
        {
            res.push_back(index);
            int j=i+1;
            int sum=file_length[i];
            //一个block可能跨很多文件，将后面的文件长度累加起来，只到超过一个block
            while(j<n)
            {
                sum+=file_length[j];
                if(sum>block_size)
                    break;
                j++;
            }
            file_length[j]=sum-block_size;
            i=j;
        }
        else if(file_length[i]==block_size) //如果刚好相等就不算跨文件
            i++;
        else
            file_length[i]-=block_size; //如果文件大于一个块，则分割为剩下的 
        index++; //块序号自增
    }
    return res;
}
 
int main(int argc,char *argv[])
{     
    vector<int> res=getIndex(file_length,N,block_length);
    getchar(); 
    return 0;
}

17、参考代码：

structlist1
{   
    int alue;
    list1* next; 
};
 
list1 * merge (list1 *list1_head, list1 *list2_head)
{ 
    list1* head=NULL,*p=NULL; 
    if(list1_head->value<list2_head->value) 
    {   head=list1_head;list1_head=list1_head->next;} 
    else 
    {  head=list2_head;list2_head=list2_head->next;} 
    p=head;
    while(list1_head&&list2_head) 
    {
        if(list1_head->value<list2_head->value) 
        {   head->next=list1_head;head=list1_head;list1_head=list1_head->next;} 
        else 
        {  head->next=list2_head;head=list2_head;list2_head=list2_head->next;} 
    } 
    if(list2_head==NULL&&list1_head==NULL) 
        return p;
    if(!list2_head)
        head->next=list1_head; 
    if(!list1_head) 
        head->next=list2_head; 
    return p; 
}

18、参考代码：

#include <iostream>
#include <cstdlib>
#include <vector> 
using namespace std; 
bool isMatch(const char*str1, const char *str2)
{
    int len1 = 0, len2 = 0;
    const char *p = str1, *q = str2;
    /*求两个字符串长度*/
    while (*p++ != '\0')
        ++len1;
    while (*q++ != '\0')
        ++len2;
    if (len1 != len2)
        return false;
    vector<char> vMap(256, 0);
    p = str1;
    while (*p != '\0')
    {
        ++vMap[*p];
        ++p;
    }//while
 
    /*验证匹配性*/
    q = str2;
    while (*q != '\0')
    {
        if (--vMap[*q] < 0)
            return false;
        ++q;
    }//while
    return true;
}
 
bool is_matching(const char* dictionary[], int n, const char* sentence)
{
    if (!sentence)
        return false;
    int len = 0;
    const char *p = sentence;
    while (*p++ != '\0')
        ++len;
    char *word = new char[len + 1];
    word[0] = '\0';
 
    /*单词长度计数sz*/
    int sz = 0;
    p = sentence;
    while (*p != '\0')
    {
        if (*p == ' ')
        {
            word[sz] = '\0';
            for (int i = 0; i < n; ++i)
            {
                if (isMatch(word,dictionary[i]))
                    return true;
            }//for
            sz = 0;
            word[sz] = '\0';
        }
        else{
            word[sz++] = *p;
        }//else
        ++p;
    }//while
    /*查找最后一个单词在不在词典中*/
    word[sz] = '\0';
    for (int i = 0; i < n; ++i)
    {
        if (isMatch(word, dictionary[i]))
            return true;
    }//for 
    return false;
}
 
int main()
{
    const char *dictionary[] = { "I", "am", "a", "good", "student." };
    const char *s = "very good ";
    cout << is_matching(dictionary, 5, s) << endl;
    system("pause");
    return 0; 
}