错题本本-20180919

1. new

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

解析：

　　对于内置类型而言，new仅仅是分配内存，除非后面显示加()，相当于调用它的构造函数；

　　对于自定义类型而言，只要一调用new，那么编译器不仅仅给它分配内存，还调用它的默认构造函数初始化，即使后面没有加()

2. enum

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

解析：

　　如果是函数外定义那么是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个字节}

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

在32位机器中，输出是?

解析：4

　　此处为一个指针变量。32位系统的指针变量是一个int，也就是4个字节

　　c++中不允许隐式的数组拷贝，所以example的参数会被隐式地转为char*，故为4

　　若在函数体内，char a[5]="oo";

　　则sizeof代表数组大小，注意是声明范围的大小

5. 重载

　　多态性分为编译时多态性和运行时多态性，

　　编译时多态性通过静态编联完成，例如函数重载，运算符重载；

　　运行时多态性则是动态编联完成，主要通过虚函数来实现；

　　函数重载不需要是成员函数，在类外声明或定义的函数同样可以对其进行重载

　　重载的调用主要根据参数个数，参数类型，参数顺序来确定，函数重载是忽略返回值的

　　方法重载（overload）：

　　1.必须是同一个类

　　2方法名（也可以叫函数）一样

　　3参数类型不一样或参数数量不一样

　　方法的重写（override）两同两小一大原则：

　　方法名相同，参数类型相同

　　子类返回类型小于等于父类方法返回类型，

　　子类抛出异常小于等于父类方法抛出异常，

　　子类访问权限大于等于父类方法访问权限。

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
", p);

运行结果？

解析：

  result is to test something

　　charstr[] = "glad to test something"; //定义字符串

　　char*p = str; //p指向字符串首地址，即字符'g'

　　p++; //p是char*类型，每次移动sizeof(char)字节，故此时p指向 'g'的下一个字符 'l'

　　int*p1 = reinterpret_cast<int*>(p); //指针p被重新解释为整型指针并被赋值给p1

　　p1++; //p1是int*类型，每次移动sizeof(int)字节，故此时p1 指向 'l'后的第四个字符 't'

　　p = reinterpret_cast<char*>(p1); //指针p1被重新解释为字符型指针并被赋值给p

printf("result is %s ", p); //从't'开始输出字符串，即得到 "to test something"

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

　　1 先找有没有virtual 有的话就要建立虚函数表，+4
　　2 static的成员变量属于类域，不算入对象中 +0
　　3 神马成员都没有的类，或者只有成员函数(一旦类中有其他的占用空间成员，则这1个字节就不在计算之内，如一个类只有一个int则占用4字节而不是5字节) +1
　　4 对齐法则，对大家都没有问题

class A
{
public:
 void FuncA()
 {
     printf( "FuncA called
" );
 }
 virtual void FuncB()
 {
     printf( "FuncB called
" );
 }
};
class B : public A
{
public:
 void FuncA()
 {
     A::FuncA();
     printf( "FuncAB called
" );
 }
 virtual void FuncB()
 {
     printf( "FuncBB called
" );
 }
};
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

　　父类指针指向子类实例对象，调用普通重写方法时，会调用父类中的方法。而调用被子类重写虚函数时，会调用子类中的方法。

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

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

解析：

XYBCDCBA1BAA

FindSubString函数查找对称的回文子串（例如CDC），返回count，若不是回文子串或者不对称则返回0

字符串XYBCDCBABABA 之前的所有字符执行的都是 ModifyString函数中的else子段，即*p2++=*p1++;

字符串 XYBCDCBABABA 的第一个对称回文子串为ABA，此时sprintf语句会用count(此时为1)替换B，并自动添加串结尾符''在第二个A的位置，

则下边的while语句即将p2指针移动到第二个A的位置，p1 += count + count +1将p1移动到第二个A后面的B位置上，即p2的后一位

这之后没有对称回文子串，则执行*p2++=*p1++，直到p1到达串尾，即用倒数第二个字符替换倒数第三个，用倒数第一个字符替换倒数第二个

综上，结果是XYBCDCB A1 BA A

10.

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）

11.

#include<iostream>
using namespace std;
class MyClass
{
public:
    MyClass(int i = 0)
    {
        cout << i;
    }
    MyClass(const MyClass &x)
    {
        cout << 2;
    }
    MyClass &operator=(const MyClass &x)
    {
        cout << 3;
        return *this;
    }
    ~MyClass()
    {
        cout << 4;
    }
};
int main()
{
    MyClass obj1(1), obj2(2);
    MyClass obj3 = obj1;
    return 0;
}

运行时的输出结果是（）

解析：

C MyClass obj3 = obj1;

obj3还不存在，所以调用拷贝构造函数输出2，

如果obj3存在，obj3=obj，则调用复制运算符重载函数，输出3

12.

#include<stdio.h>
char *myString()
{
    char buffer[6] = {0};
    char *s = "Hello World!";
    for (int i = 0; i < sizeof(buffer) - 1; i++)
    {
        buffer[i] = *(s + i);
    }
    return buffer;
}
int main(int argc, char **argv)
{
    printf("%s
", myString());
    return 0;
}

如下代码输出结果是什么？

解析：

函数char *myString()中没有使用new或者malloc分配内存，所有buffer数组的内存区域在栈区

随着char *myString()的结束，栈区内存释放，字符数组也就不存在了，所以会产生野指针，输出结果未知

13.

函数模板的实例化是由编译程序处理函数调用时自动完成的；

类模板的实例化是由程序员在程序中显式的指定；

函数模板针对参数类型不同和返回值类型不同的函数；

类模板针对数据成员、成员函数和继承的基类类型不同的类。

14.

排序时，若不采用计数排序等空间换时间的方法，合并m个长度为n的已排序数组的时间复杂度最优为（）

解析：

O(nm)

15.

折半查找法在查找成功时进行的关键字比较次数最多为ëlog2nû +1，即判定树的高度；

折半查找法在查找不成功时进行的关键字比较次数最多为ëlog2nû +1

16.

C语言的文件操作标准库函数中关于定位的函数只有两个一个是rewind 反绕函数，另一个fseek 随机定位函数；

int fseek(FILE *stream, long offset, int fromwhere);函数设置文件指针stream的位置。

如果执行成功，stream将指向以fromwhere为基准，偏移offset（指针偏移量）个字节的位置，函数返回0；

如果执行失败(比如offset超过文件自身大小)，则不改变stream指向的位置，函数返回一个非0值。