迅雷C++笔试卷A-2014年

一、单项选择题

1、下列表达式正确的是（）

 A、9++        B、（x+y）++        C、c+++c+++c++        D、++（a-b--）

2、在int b[ ][3] = {{1},{3,2},{4,5,6},{0}};中，sizeof(b) =（）

 A、4        B、12        C、28        D、48

3、以下程序的输出结果是（）

#define M(x,y,z) x*y+z
main()
{
    int a=1, b=2, c=3;
    printf("%d\n",M(a+b,b+c,c+a));
}

 A、19        B、17        C、15        D、12

4、若有以下定义和语句：

int u=010, v= 0x10, w=10;
printf(“%d，%d,%d/n”,u,v,w);

则输出结果是（）

 A、8,16,10        B、10,10,10        C、8,8,10        D、8,10,10

5、下面程序段的输出结果是（）

int a = 5, b = 4, c = 3, d = 2;
    if (a>b>c)
        printf("%d\n", d);
    else if ((c - 1 >= d) == 1)
        printf("%d\n", d + 1);
    else
        printf("%d\n", d + 1);

 A、2        B、3        C、4        D、编译错误

6、有如下程序段，请问k的值是（）

enum {
    a, b=5, c, d=4, e
} k; 
k =c;

 A、3        B、4        C、5        D、6

7、有如下程序段：

int i, n = 0;
float x = 1, y1 = 2.1 / 1.9, y2 = 1.9 / 2.1;
for ( i = 1; i < 22; i++ )
    x = x * y1;
    while ( x != 1.0 )
    {
        x = x * y2; n++;
    }
    printf( “ %d / n ”, n );

请问执行结果是（）

 A、21        B、22        C、无限循环        D、程序崩溃

8、用树形结构表示实体之间联系的模型是（）

 A、关系模型        B、网状模型        C、层次模型        D、以上三个都是

9、有如下程序段：

int c = 23;
printf(“%d\n”, c&c);

 A、0        B、46        C、23        D、以上都不对

二、不定项选择题

10、下面属于构造散列函数的方法是（）

 A、直接定址法        B、数字分析法        C、乘余取整法        D、平方取中法

11、拷贝构造函数的特点是（）

 A、该函数名同类名，也是一种构造函数，该函数返回自身引用        B、该函数只有一个参数，是对某个对象的引用 

 C、每个类都必须有一个拷贝初始化构造函数，如果类中没有说明拷贝构造函数，则编译器系统会自动生成一个缺省拷贝构造函数，作为该类的保护成员

 D、拷贝初始化构造函数的作用是将一个已知对象的数据成员值拷贝给正在创建的另一个同类的对象

12、下列关于虚函数的说法正确的是（）

 A、在构造函数中调用类自己的虚函数，虚函数的动态绑定机制还会生效

 B、在析构函数中调用类自己的虚函数，虚函数的动态绑定机制还会生效

 C、静态函数不可以是虚函数

 D、虚函数可以声明为inline

13、下列对函数double add(int a , int b)进行重载，正确的是（）

 A、int add(int a ,int b ,int c)        B、int add(double a , double b)

 C、double add(double a , double b)        D、int add(int a , int b)

14、下面关于数组的描述错误的是（）

 A、在C++语言中一维数组的名字就是指向该数组第一个元素的指针        B、长度为n的数组，下标的范围是0－n-1

 C、数组的大小必须在编译是确定        D、数组只能通过值参数和引用参数两种方式传递给函数

15、有如下程序段有如下程序段：

char fun(char *);
main()
{
    char *s = “one”, a[5] = {0}, (*f1)(char *) = fun, ch;
}

则对函数fun的调用语句正确的是（）

 A、*f1(&a);        B、 f1（*s）;       C、f1(&ch)        D、ch = *f1(s);要改成（*f1）(s)才正确

三、问答题

16、实现strtol函数，其原型如为int strtol(const char *num_str, char **endptr, int base)，num_str存放待转换的字符串，可以是负数也可以是正数；endptr指向第一个非法字符的地址，如果endptr为null则不指向第一个非法字符的地址；base用于指示进制，若base为0，则根据num_str的指示来转换。函数必须检查溢出，如果正数溢出，返回int_max；若负数溢出，返回int_min。

17、一亿个数找最大的1000个数，要求效率高占用内存少。函数原型为：find_max_data(int* source_data, int* max_data)，其中source_data是存放一亿个数的数组，max_data用于存放其中最大的1000个数。

18、将一个集合拆分成两个不相交的子集，两个子集元素之和相等，如{1, 2, 3, 4, 5, 6, 7}，拆分成： {2, 5, 7}, {1, 3, 4, 6} 给出一个集合，求所有符合上面要求的拆分，效率最高分越高，函数原型为int cal_num(int n);

参考答案

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

10、ABCD

11、D

12、CD

13、ABC

14、CD

15、CD

16、参考代码：

#include<iostream>
using namespace std; 
const int int_max = 2147483647;
const int int_min = -2147483648; 
bool isAlph(char num)
{
    if ((num >= 'A'&& num <= 'Z') || (num >= 'a'&& num <= 'z'))
        return true;
    else
        return false;
}
 
bool isDigit(char num)
{
    if ((num >= '0'&& num <= '9'))
        return true;
    else
        return false;
}
 
char toLower(char num)
{
    char result = num;
    if (num >= 'A' && num <= 'Z')
        result += 32;
    return result;
}
int strtoLL(const char *num_str, char **endptr, int base)
{
    long long result = 0;
    long long value;
    if (!base)
    {
        if (*num_str == '0')
        {
            num_str++;
            if (*num_str == 'x' || *num_str == 'X')
            {
                base = 16;
                num_str++;
            }
            else
                base = 8;
        }
        else
            base = 10;
    }
    while (true)
    {
        if (isAlph(*num_str) || isDigit(*num_str))
        {
            value = isAlph(*num_str) ? toLower(*num_str) - 'a' + 10 : *num_str - '0';
            if (value >= base)
                break;
            result = result*base + value;
            if (result > int_max)
                result = int_max;   
            if (result < int_min)
                result = int_min;
            num_str++;
        }
        else
            break;
    }
    if (endptr)
        *endptr = const_cast<char*> (num_str);
    return result;
}
 
int Mystrtol(const char *num_str, char **endptr, int base)
{
    if (*num_str == '-')
    {
         long result = strtoLL(num_str + 1, endptr, base);
         if (result == int_max)
             return int_min;
         else
             return -result;
    } 
    return strtoLL(num_str, endptr, base);
}
 
int main()
{
    char *str = "0123456789ABCDEFGHItest";
    char *temp;
    cout << "******Mystrtol********" << endl;
    int result = Mystrtol(str, &temp,0);
    cout << result << endl;
    cout << temp << endl;
    cout << "******strtol**********" << endl;
    result = strtol(str, &temp,0);
    cout << result << endl;
    cout << temp << endl;
    system("pause");
    return 0;
}

17、参考代码：

/* 基数排序  */
#include <iostream>
#include <stdlib.h>
#include <ctime>
#include <algorithm>
#include <cassert>
#include "windows.h"
using namespace std;
#define MAXN 100000000 #define MAXM 1000
void find_max_data0( int dest[], int m, int src[], int n )
{
    fill( dest, dest + n, -INT_MAX );
    for ( int i = 0; i < n; i++ )
    {
        for ( int j = 0; j < m; j++ )
        {
            if ( src[i] > dest[j] )
            {
                dest[j] = src[i];
                break;
            }
        }
    }
}
void find_max_data1( int dest[], int m, int src[], int n )
{
    make_heap( src, src + n );
    for( int i = 0; i < m; i++ )
    {
        dest[i] = src[0];
        pop_heap( src, src + n-- );
    }
}
void radix_sort( int *src, int n )
{
    int *tmp = new int[MAXN];  int cnt[256];
    for( int i = 0; i < 4; i++ ) {
        memset( cnt, 0, sizeof(cnt) );
        for( int j = 0; j < MAXN; j++ )
        {
            cnt[ ( src[j] >> (8 * i) ) & 0xff ]++;
        }
        for ( int j = 1; j < 256; j++ )
        {
            cnt[j] = cnt[j - 1] + cnt[j];
        }
        for( int j = MAXN - 1; j >= 0; j-- )
        {
            tmp[ -- cnt[ ( src[j] >> (8 * i) ) & 0xff ] ] = src[j]; swap( src, tmp );
        }
    }
    delete [] tmp;
}
void find_max_data2( int dest[], int m, int src[], int n )
{
    radix_sort( src, n );
    int j = 0;
    for( int i = n - 1; i >= n - m; i-- )
    {
        dest[j++] = src[i];
    }
}
int src[MAXN];
int main()
{
    ( (unsigned int) time( NULL ) );
    src[i] = abs( i * 6516187 );
    DWORD t1, t2;
    t1  = GetTickCount();
    find_max_data2( dest2, MAXM, src, MAXN );  
    t2 = GetTickCount();
    printf( "find_max_data2 time cost:%dn", t2 - t1 ); 
    for( int i = 0; i < MAXM; i++ )
    {
        printf( "n" );  return 0;
    }
}

18、参考代码：

#include <iostream>
using namespace std;
#define MAXN 100
  
void dfs(int pi,int curSum,bool res[],int n,int half,int &num,int left[])
{
    for(int i=pi+1;i<=n;i++) { 
        res[i]=true; 
        if(curSum+left[i]=1;i--)
            left[i]=i+left[i+1]; 
    dfs(0,0,res,n,half,cnt,left);
    return cnt;
}
int main()
{
    int n=20;
    int num=cal_num(n);
    printf("num=%d\n",num);
    return 0;
}