c++测试题

1.

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

在全局域定义enum，输出x是0，但是在局部域定义enum,输出x是随机数。x1=0,x2=1,x3=10,x4=11,x5=12.x=0;
2.

unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;
请问p1+5= 什么？
p2+5= 什么？

一个unsigned long占4个字节，指针是跳类型不是跳字节的，所以跳5就是偏移4*5=20个字节，16进制为0x14，加上段地址0x810000就是0x810014。
unsigned char是1个字节。1*5=5， 0x05
3.

在32位机器中，如下代码：

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

将数组名作为函数的参数传递给函数的时候，此时的函数名退化为了指针，在32位的机器上指针位4个字节
无论是整型数组还是字符数组，数组名作为右值的时候都代表数组首元素的首地址。数组发生降级（数组名退化为数组首元素的地址）的情况：数组传参、数组名参与运算.数组名不会发生降级的情况：sizeof(数组名)、取地址数组名（取到的是整个数组的地址而不是首元素的地址）

int型数组
int a[] = { 1, 2, 3, 4 };
printf("%d\n", sizeof(*a));     //4    对首元素的地址进行解引用取到首元素的值，为int型
printf("%d\n", sizeof(a + 1));  //4    sizeof(&a[1])
printf("%d\n", sizeof(a[1]));   //4    数组的每个元素都是整型
printf("%d\n", sizeof(&a));     //4 取到整个数组的地址（地址为四个字节存储）
printf("%d\n", sizeof(&a + 1));         //4    地址的大小为四个字节
printf("%d\n", sizeof(&a[0]));          //4    地址的大小为四个字节
printf("%d\n", sizeof(&a[0] + 1));      //4    地址的大小为四个字节
printf("%d\n", sizeof(*&a));          //16   &a取到整个数组的地址，再解引用取到整个数组

--------------------------------------------------------------------------------------

char型数组
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char name1[10];         //定义全局性数组 系统默认初始化为'\0'
int main()
{
           char name[10];
           printf("%d\n" , sizeof(name));    // 10
           printf("%d\n" , strlen(name));     // 随机值

           printf("%d\n" , sizeof(name1));    // 10
           printf("%d\n" , strlen(name1));     // 0        
           system("pause" );
           return 0;
}

定义在全局的数组，及时你没有初始化，系统也会默认初始化为0，而name1在这里是char类型，所以编译器会自动把它初始化为”\0”.sizeof(name)依旧算的是数组的大小，而strlen是遇到”\0”就结束由于name没有初始化，strlen(name)的结果是个随机值，什么时候遇到”\0”,就什么时候停下来。

char name[] = "abcdef" ;             // 6个字符还有一个"\0"
printf("%d\n" , sizeof(name[0]));    // 1  name[0]='a'  char一个字节存储
printf("%d\n" , sizeof(&name));      // 4  取到整个数组的地址  地址为四字节存储
printf("%d\n" , sizeof(*name));      // 1   
printf("%d\n" , sizeof(&name + 1));  // 4  地址！ （把整个数组都跳过去了）
printf("%d\n" , sizeof(name + 1));   // 4  数组名参与运算降级为地址 ==> sizeof(&a[1])
printf("%d\n" , sizeof(name));       // 10    数组的大小
printf("%d\n" , strlen(name));       // 6     遇到'\0'就结束
printf("%d\n" , strlen(&name));      // 6   
//printf("%d\n", strlen(*name));     // 无效，不能strlen字符
printf("%d\n" , strlen(&name + 1));  // 随机值 
printf("%d\n" , strlen(name + 1));   // 5  为跳过首元素后的"bcdef"的长度

strlen(&name) ：strlen函数一个字符一个字符跳转，直到遇到’\0’才结束。 这里编译器进行隐式的强制类型转换成char*，相当于在求strlen(name)

strlen(&name + 1)：这是一个随机值，因为&name + 1把整个数组都跳过去了，传给strlen的参数是name数组后面未可知的地址，strlen会一直走下去，直到遇到”\0”

sizeof(*name)：name发生降级，变为首元素的首地址，再解引用取到字符’a’（*name=’a’），输出1
3.
下面关于虚函数和函数重载的叙述不正确的是
虚函数不是类的成员函数
虚函数实现了C++的多态性
函数重载允许非成员函数，而虚函数则不行
函数重载的调用根据参数的个数、序列来确定，而虚函数依据对象确定
虚函数可以在子类中进行重载，也可以不重载而沿用父类中的方法。但纯虚函数必须重载，因为在其声明类中没有函数实现。vritual void func（）=0；包含纯虚函数的类为抽象类，抽象类不能声明对象，只能作为基类
4.

下面程序运行后的结果为：
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);

开始p指向“ glad to test something”中的g，然后p++，指向l
int *p1 = static_cast(p); 把p赋值给int型了
p1++,即加了4个字节位置。即p1指向“glad to test something”中的t
p = static_cast(p1); 把p1的转回了p，p指向了“ glad to test something”中的t
输出从t开始
to test something

5.设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？

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

首先一个个的分析:
对于类A, 是建立在堆上的对象指针pa, 手动释放
对于类B, 是建立在栈上的对象b,main函数结束就释放
对类C ,在静态存储区创建了一个对象c ,程序结束时候释放
对类D,也是在静态存储区建立对象d,但是局部变量,程序结束时候释放.
析构函数调用顺序:
先调用A的析构,因为delete pa . A
再释放栈上的对象b, B
关键看CD的顺序.
c是全局对象,对它的初始化是在main函数之前,所以析构时候要放在最后.
也就是先析构d ,然后再析构c
6.若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)的值是多少？
请选择正确的答案。
若按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成员变量的大小
7.关于方法重载和方法重写
方法重载（overload）：
1.必须是同一个类
2方法名（也可以叫函数）一样
3参数类型不一样或参数数量不一样

方法的重写（override）两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。