C++笔试（一）

下面描述正确的是

int *p1 = new int[10]; 
int *p2 = new int[10]();

答案：p1申请的空间里的值是随机值，p2申请的空间里的值已经初始化
解析：
1、new当个对象
new在自由空间分配内存，但其无法为其分配的对象命名，因次是无名的，分配之后返回一个指向该对象的指针。
1
int *pi = new int; // pi指向一个动态分配的，未初始化的无名对象
此new表达式在自由空间构造一个int类型对象，并返回指向该对象的指针。

默认情况下，动态分配的对象是默认初始化的，这意味着内置类型或组合类型的对象的值是无定义的，而类类型对象将用默认构造函数进行初始化。

2、new(多个对象)数组
new分配的对象，不管单个对象还是多个对象的分配，都是默认初始化。但可以对数组进行值初始化，方法就是：在大小之后添加一对空括号。

int *pia = new int[10];    // 10个未初始化int
int *pia2 = new int[10](); // 10个值初始化为0的int

2.下面的程序可以从0…n-1中随机等概率的输出m个不重复的数。这里我们假设n远大于m

knuth(int n, int m)
{ 
    srand((unsigned int)time(0)); 
    for (int i = 0; i < n; i++) { 
        if ( ) { 
            cout << i << endl;
            ( );
        }
     }
}

正确答案：rand()%(n-i)<m m–
解析：
由这个for循环循环n次，且在满足条件时才输出i,可知，输出m个不同值的要求已满足，因为每次输出的都是i值，而i值每次都是不一样的，m–保证了程序在输出了m个值后就停止循环。
在i=0时，rand()%(n-i)的取值范围为0到n-1，共n个数，此时要输出0只需要rand()%(n-i)小于m，故i=0被输出的概率为m/n;
在i=1时，rand()%(n-i)的取值范围为0到n-2，共n-1个数，若i=0没有被输出，则m–未被执行，此时i=1被输出的概率为m/(n-1)，若i=0已经被输出了，则m变为m-1，此时i=1被输出的概率为(m-1)/(n-1)；由概率论的知识，可知此时i=1被输出的概率为
P=(1-m/n)(m/(n-1))+m/n((m-1)/(n-1))=m/n；以此类推，可知每个数被输出的概率都为m/n
3.以下prim函数的功能是分解质因数。括号内的内容应该为？

void prim(int m, int n)
 {
     if (m >= n)
     {
         while (        ) n++;
         (     );
         prim(m, n);
         cout << n << endl;
     }
 }

正确答案：m%n m/=n

enum string{    
    x1,    
    x2,    
    x3=10,    
    x4,    
    x5,    
} x;

函数外部访问x等于什么？
正确答案：0；
解析：
如果是函数外定义那么是0
如果是函数内定义，那么是随机值，因为没有初始化

unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;

请问p1 + 5 = 什么？
p2 + 5 = 什么？
正确答案：
801005 810014
p1指向字符型，一次移动一个字符型，1个字节；p1+5后移5个字节，16进制表示为5；
p2指向长整型，一次移动一个长整型，4个字节，p2+5后移20字节，16进制表示为14。
{ char每次移动1个字节；short移动2个字节 ；int , long ,float移动4个字节 ；double移动8个字节}
6.在32位机器中，如下代码：

void example(char acWelcome[]){
    printf("%d",sizeof(acWelcome));
    return;
}
void main(){
    char acWelcome[]="Welcome to Huawei Test";
    example(acWelcome);
    return;
}

的输出是？
正确答案：4
char的指针32位，4字节

7.下面关于虚函数和函数重载的叙述不正确的是
A.虚函数不是类的成员函数
B.虚函数实现了C++的多态性
C.函数重载允许非成员函数，而虚函数则不行
D.函数重载的调用根据参数的个数、序列来确定，而虚函数依据对象确定
解析：
虚函数也是类的成员函数，A说法是不正确的；
虚函数和函数重载都实现了C+=的多态性，但表现形式不一样，函数重载调用根据参数个数、参数类型等进行区分，而虚函数则是根据动态联编来确定调用什么，故BD说法正确

void Func(char str_arg[100])
{
       printf("%d\n",sizeof(str_arg));
}
int main(void)
{
     char str[]="Hello";
     printf("%d\n",sizeof(str));
    printf("%d\n",strlen(str));
    char*p=str;
    printf("%d\n",sizeof(p));
    Func(str);
}

32位系统下下面程序的输出结果为多少？

6 5 4 4

10.下面程序运行后的结果为：

char str[] = "glad to test something";
char *p = str;
p++;
int *p1 = reinterpret_cast<int *>(p);
p1++;
p = reinterpret_cast<char *>(p1); 
printf("result is %s\n", p);

正确答案：
result is to test something
解析：
reinterpret_cast运算符是用来处理无关类型之间的转换；它会产生一个新的值，这个值会有与原始参数（expression）有完全相同的比特位
该题的关键是要认清楚强制类型转换后指针的类型。
p的类型为char *，p++后p指向str数组的第2个元素即字母“l”的位置。
p1的类型为int *，p1++后p1指向的位置增加4个字节，指向str数组中的第6个元素即字母“t”的位置。
因此最后p的内容为“to test something”。
11.设已经有A,B,C,D 4个类的定义，程序中A,B,C,D析构函数调用顺序为？

C c;
void main()
{
    A*pa=new A();
    B b;
    static D d;
    delete pa;
}

正确答案：
A B D C
解析：
这道题主要考察的知识点是 ：全局变量，静态局部变量，局部变量空间的堆分配和栈分配
其中全局变量和静态局部变量时从 静态存储区中划分的空间，
二者的区别在于作用域的不同，全局变量作用域大于静态局部变量（只用于声明它的函数中），而之所以是先释放 D 在释放 C的原因是， 程序中首先调用的是 C的构造函数，然后调用的是 D 的构造函数，析构函数的调用与构造函数的调用顺序刚好相反。
局部变量A 是通过 new 从系统的堆空间中分配的，程序运行结束之后，系统是不会自动回收分配给它的空间的，需要程序员手动调用 delete 来释放。
局部变量 B 对象的空间来自于系统的栈空间，在该方法执行结束就会由系统自动通过调用析构方法将其空间释放。
之所以是 先 A 后 B 是因为，B 是在函数执行到 结尾 “}” 的时候才调用析构函数， 而语句 delete a ; 位于函数结尾 “}” 之前。
12.若char是一字节，int是4字节，指针类型是4字节，代码如下：

class CTest
{
    public:
        CTest():m_chData(‘\0’),m_nData(0)
        {
        }
        virtual void mem_fun(){}
    private:
        char m_chData;
        int m_nData;
        static char s_chData;
};
char CTest::s_chData=’\0’;

问：
(1)若按4字节对齐sizeof(CTest)的值是多少？
(2)若按1字节对齐sizeof(CTest)的值是多少？
正确答案：
12 9
答案 ：
若按4字节对齐sizeof(CTest)的值是12；
若按1字节对齐sizeof(CTest)的值是9
解释：
在类中，如果什么都没有，则类占用1个字节，一旦类中有其他的占用空间成员，则这1个字节就不在计算之内，如一个类只有一个int则占用4字节而不是5字节。

如果只有成员函数，则还是只占用1个字节，因为类函数不占用空间
虚函数因为存在一个虚函数表，需要4个字节，数据成员对象如果为指针则为4字节，注意有字节对齐，如果为13字节，则进位到16字节空间。
sizeof的本质是得到某个类型的大小，确切的来说就是当创建这个类型的一个对象(或变量)的时候，需要为它分配的空间的大小。而类也可以理解为类似于int、float这样的一种类型，当类中出现static成员变量的时候，static成员变量是存储在静态区当中的，它是一个共享的量，因此，在为这个类创建一个实例对象的时候，是无需再为static成员变量分配空间的，所以，这个类的实例对象所需要分配的空间是要排除static成员变量的，于是，当sizeof计算类的大小的时候会忽略static成员变量的大小
13.在Java中，以下关于方法重载和方法重写描述正确的是？
正确答案：方法重写的返回值类型必须相同或相容。（或是其子类）
方法重载的返回值的类型可以不同，因为判断方法重载的方法主要是根据方法的参数不同来判定；方法重写的返回值类型需要相同，重写就是子类继承了父类的方法，并在此方法上重写属于自己的特征，既然是继承过来的，那么它的返回值类型就必须要相同
14.下列给定程序中，函数fun的功能是:求ss所指字符串数组中长度最短的字符串所在的行下标，作为函数值返回，并把其串长放在形参n所指的变量中。ss所指字符串数数组中共有M个字符串，且串长小于N。
请在程序的下画线处填入正确的内容并将下画线删除，使程序得出正确的结果。
试题程序。

#define M 5
 #define N 20
 int fun(char(* ss)[N], int *n)
 {
     int i, k = 0, len = N;
     for (i = 0; i < ______; i++)
     {
         len = strlen(ss[i]);
         if (i == 0)
             *n = len;
         if (len ____ * n)
         {
             *n = len;
             k = i;
         }
     }
     return ( _____ );
 }
 main( )
 {
     char ss[M][N] = {"shanghai", "guangzhou", "beijing", "tianjing", "chongqing"};
     int n, k, i;
     printf("\nThe originalb stringsare:\n");
     for (i = 0; i < M; i++)
         puts(ss[i]);
     k = fun(ss, &n);
     printf("\nThe length of shortest string is: % d\n", n);
     printf("\nThe shortest string is: % s\n", ss[k]);
 }

正确答案：M，>，K

15.写出下面程序的输出结果

class A
{
public:
 void FuncA()
 {
     printf( "FuncA called\n" );
 }
 virtual void FuncB()
 {
     printf( "FuncB called\n" );
 }
};
class B : public A
{
public:
 void FuncA()
 {
     A::FuncA();
     printf( "FuncAB called\n" );
 }
 virtual void FuncB()
 {
     printf( "FuncBB called\n" );
 }
};
void main( void )
{
 B  b;
 A  *pa;
 pa = &b;
 A *pa2 = new A;
 pa->FuncA(); （ 3）
 pa->FuncB(); （ 4）
 pa2->FuncA(); （ 5）
 pa2->FuncB();
 delete pa2;
}

正确答案：
FuncA called
FuncBB called
FuncA called
FuncB called
解析：

B  b; 
 A  *pa;
 pa = &b;
 A *pa2 = newA;
 pa->FuncA(); （ 3）//pa=&b动态绑定但是FuncA不是虚函数，所以FuncA called
 pa->FuncB(); （ 4）//FuncB是虚函数所以调用B中FuncB，FuncBB called  
 pa2->FuncA(); （ 5）//pa2是A类指针，不涉及虚函数，调用的都是A中函数，所以FuncA called FuncB called
 pa2->FuncB()

16.In the main() function, after ModifyString(text) is called, what’s the value of ‘text’?

int FindSubString( char* pch )
{
    int   count  = 0;
    char  * p1   = pch;
    while ( *p1 != '\0' )
    {   
        if ( *p1 == p1[1] - 1 )
        {
            p1++;
            count++;
        }else  {
            break;
        }
    }
    int count2 = count;
    while ( *p1 != '\0' )
    {
        if ( *p1 == p1[1] + 1 )
        {
            p1++;
            count2--;
        }else  {
            break;
        }
    }
    if ( count2 == 0 )
        return(count);
    return(0);
}
void ModifyString( char* pText )
{
    char  * p1   = pText;
    char  * p2   = p1;
    while ( *p1 != '\0' )
    {
        int count = FindSubString( p1 );
        if ( count > 0 )
        {
            *p2++ = *p1;
            sprintf( p2, "%i", count );
            while ( *p2 != '\0' )
            {
                p2++;
            }
            p1 += count + count + 1;
        }else  {
            *p2++ = *p1++;
        }
    }
}
void main( void )
{
    char text[32] = "XYBCDCBABABA";
    ModifyString( text );
    printf( text );
}  

正确答案：
XYBCDCBA1BAA
解析：
这要从仔细读源码开始了。
FindSubString的功能，上面已经解释很清楚了，寻找一个先连续递增，在连续递减的字符串，终止条件是递减结束。但是他很严格的要求，递增的长度和递减的长度是相等的。看看CDC前后是什么：XYBCDCBABABA。XY明显不满足，所以跳过了。BCD满足递增，DCBA满足递减，但是二者长度不相等，所以也要跳过。到了CD递增，DCBA递减，同样跳过。
17.下面程序的功能是输出数组的全排列。请填空。

void perm(int list[], int k, int m)
{
    if (    )
    {
        copy(list,list+m,ostream_iterator<int>(cout," "));
        cout<<endl;
        return;
    }
    for (int i=k; i<=m; i++)
    {
        swap(&list[k],&list[i]);
        (    );
        swap(&list[k],&list[i]);
    }
}

正确答案：
k==m 和 perm（list，k+1，m）