本文共 4771 字，大约阅读时间需要 15 分钟。

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
   
    #include
    
     #include
     
      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
   
    (p);p1++;p = reinterpret_cast
    
     (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）两同两小一大原则：

方法名相同，参数类型相同 子类返回类型小于等于父类方法返回类型， 子类抛出异常小于等于父类方法抛出异常， 子类访问权限大于等于父类方法访问权限。

转载地址：http://qtomb.baihongyu.com/