题一：

unsigned char *p1;

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

请问p1+5= 什么？
p2+5= 什么？

  • 801005   810005

  • 801010   810014

  • 801005   810014

  • 801010  810015

回答：1代表的是一个单位量 
p1+5=p1+5*1=p1+5*sizeof(unsigned char)=p1+5*1=0x801000+ox5=0x801005 

p2+5=p2+5*1=p2+5*sizeof(unsigned long)=p1+5*4=0x810000+20=0x810000+0x14=0x810014 

最后要转换成16进制  

或者回答：

注意是16进制，一个unsigned  long占4个字节，指针是跳类型不是跳字节的，所以跳5就是偏移4*5=20个字节，8进制14，加上段地址0x810000就是0x810014


题二：

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

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

正确答案:    D    你的答案:       B   (错误)            

glad to test something

ad to test something

test something

to test something

回答：该题的关键是要认清楚强制类型转换后指针的类型。

p的类型为char *，p++后p指向str数组的第2个元素即字母“l”的位置。

p1的类型为int *，p1++后p1指向的位置增加4个字节，指向str数组中的第6个元素即字母“t”的位置。

因此最后p的内容为“to test something”。


题三：

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

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

正确答案:  B   你的答案:   C   (错误)            

A B C D

A B D C

A C D B

A C B D

回答：因为类A、B都是局部变量，类D是静态局部变量，所以先释放类A、B，当主函数执行往再释放D，最后释放全局变量类C，所以顺序为 A B  D C


题四：

若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)的值是多少？

请选择正确的答案。

正确答案: C    你的答案: A    (错误)            

16 4

16 10

12 9

10 10

回答：

1 先找有没有virtual 有的话就要建立虚函数表，+4
2  static的成员变量属于类域，不算入对象中      +0
3 神马成员都没有的类，或者只有成员函数        +1
 4 对齐法则，对大家都没有问题

在类中，如果什么都没有，则类占用1个字节，一旦类中有其他的占用空间成员，则这1个字节就不在计算之内，如一个类只有一个int则占用4字节而不是5字节。      

如果只有成员函数，则还是只占用1个字节，因为类函数不占用空间      

虚函数因为存在一个虚函数表，需要4个字节，数据成员对象如果为指针则为4字节，注意有字节对齐，如果为13字节，则进位到16字节空间。


题五：

在Java中，以下关于方法重载和方法重写描述正确的是？

方法重写的返回值类型必须相同。（或是其子类）


题六：

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 );
}

正确答案:    C    你的答案:A   (错误)            

XYBCDCBABABA

XYBCBCDAIBAA

XYBCDCBAIBAA

XYBCDDBAIBAB

回答：

FindSubString()中

用到了“回文段落跳过” 

*p1 == p1[1] - 1，即看该字符串是不是递增的，即x后面是y，y后面是z，然后用count记录

*p1 == p1[1] + 1，即看该字符串是不是递减的，即z后面是y，y后面是x，然后用count2递减

若回文则返回 回文子串长度，若不回文则返回0


ModifyString()中

过滤XY，找到第一个回文字段的开始，即BCDCB 中的B，然后跨过回文段

到ABABA，进入FindSubString() 得 ABA，即count=1；

sprintf( p2, "%i", count );把B换成1，即A1，然后 *p2++=*p1++     A1BAA


题七：

#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 你的答案:    D       (错误)            

11214444

11314444

122444

123444

回答：

首先程序中存在三个MyClass对象。
前两个对象构造时分别输出1,2
第三个对象是这样构造的MyClass obj3 = obj1;这里会调用拷贝构造函数，输出2
然后三个对象依次析构，输出444
所以最终输出122444


题八：

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

#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\n", myString());
    return 0;
}

正确答案:   D   你的答案:    A    (错误)            

Hello

Hello World!

Well

以上全部不正确

回答：

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

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