题目集合2

1、10、10、4、4四个数，怎么算出24点？
(10*10-4)/4=24
2、下列表达式在32位机器编译环境下的值（）

class A  
{  
};  

class B  
{  
public:  
    B();  
    virtual ~B();  
};  

class C  
{  
private:  
#pragma pack(4)  
    int i;  
    short j;  
    float k;  
    char l[64];  
    long m;  
    char *p;  
#pragma pack()  
};  

class D  
{  
private:  
#pragma pack(1)  
    int i;  
    short j;  
    float k;  
    char l[64];  
    long m;  
    char *p;  
#pragma pack()  
};  

int main(void)  
{  
    printf("%d\n",sizeof(A));  
    printf("%d\n",sizeof(B));  
    printf("%d\n",sizeof(C));  
    printf("%d\n",sizeof(D));  
    return 0;  
}  

A、1、4、84、82 B、4、4、82、84 C、4、4、84、82 D、1、4、82、82
A类是空类，实例化类会在内存中地址唯一，占一个字节。B类由于有虚函数，虚函数指针占4个字节。C类是4字节对齐，D类是1个字节对齐。
3、以下程序在32位机器下运行的结果是（）

#pragma pack(4)  
struct info_t  
{  
    unsigned char version;  
    unsigned char padding;  
    unsigned char extension;  
    unsigned char count;  
    unsigned char marker;  
    unsigned char payload;  
    unsigned short sequence;  
    unsigned int timestamp;  
    unsigned int ssrc;  
};  

union info_u  
{  
    unsigned char version;  
    unsigned char padding;  
    unsigned char extension;  
    unsigned char count;  
    unsigned char marker;  
    unsigned char payload;  
    unsigned short sequence;  
    unsigned int timestamp;  
    unsigned int ssrc;  
};  
#pragma pack()  

int main(void)  
{  
    printf("%d\n",sizeof(info_t));  
    printf("%d\n",sizeof(info_u));  
    return 0;  
}  

A、12 12 B、12 4 C、16 4 D、16 12 E、16 1
考察字节对齐，union是复用地址的，取所占字节最大的类型。
4、以下表达式result的值是（）

#define VAL1(a,b) a*b  
#define VAL2(a,b) a/b--  
#define VAL3(a,b) ++a%b  

int a = 1;  
int b = 2;  
int c = 3;  
int d = 3;  
int e = 5;  

int result = VAL2(a,b)/VAL1(e,b)+VAL3(c,d);  

A、-2 B、1 C、0 D、2
宏仅进行简单的字符替换。

5、请写出以下程序的输出（5分）

void swap_1(int a , int b)  
{  
    int c;  
    c = a;  
    a = b;  
    b = c;  
    return ;  
}  
void swap_2(int &a , int &b)  
{  
    int c;  
    c = a;  
    a = b;  
    b = c;  
    return ;  
}  
void swap_3(int *a , int *b)  
{  
    int c;  
    c = *a;  
    *a = *b;  
    *b = c;  
    return ;  
}  

int main(void)  
{  
    int a = 100;  
    int b = 200;  
    swap_1(a , b);  
    printf("a = %d , b = %d\n",a , b);  
    swap_2(a , b);  
    printf("a = %d , b = %d\n",a , b);  
    swap_3(&a , &b);  
    printf("a = %d , b = %d\n",a , b);  
    return 0;  
}  

输出结果：
a = 100 , b = 200 //由于在函数类，传递的是a，b的副本，在栈区进行了交互，程序调用完就结束了。
a = 200 , b = 100
a = 200 , b = 100
6、下面的程序是否有问题，如有问题，请重构代码（5分）

void test_type(bool b , const char *p , float f)  
{  
    if(!b)  
    {  
        return ;  
    }  
    else if(!p)  
    {  
        return ;  
    }  
    else if(!f)  
    {  
        return ;  
    }  
}  

修改如下：

void test_type(bool b , const char *p , float f)  
{  
    if(!b)  
    {  
        return ;  
    }  
    else if(!p)  
    {  
        return ;  
    }  
    else if(!（f > -1e-5 && f < 1e-5）)  
    {  
        return ;  
    }  
}  

考察不同类型等于零
7、请指出以下程序有什么问题（5分）

void test_mem()  
{  
    char *p = new char[64];  
    delete p;  
    p = NULL;  
    return ;  
}  

由于指针p指向字符数组，释放需要用delete p[ ]
8、以下程序有什么问题，请指出。

char* GetMem()  
{  
    char p[] = "hello";  // p是内存分配在栈区，函数执行完就释放了，p是野指针。
    return p;  
}  

void test_get_mem()  
{  
    char *p = GetMem();  
    printf(p);  
    return ;  
}  

9、请写出strcpy 和 memcpy 的区别（5分）
strcpy拷贝的是字符串，是以‘\0’结尾 ，而memcpy是按照size_t的大小进行拷贝。memcpy可以拷贝不同类型的内存。memcpy进行内存拷贝时进行内存重叠检测等等。
10、请写出以下程序的输出结果

class Base  
{  
public:  
    Base()  
    {  
        printf("I am Base()\n");  
    }  
    virtual ~Base()  
    {  
        printf("I am ~Base()\n");  
    }  
public:  
    virtual void SayHello()  
    {  
        printf("Hello Base\n");  
    }  
    void SayWorld()  
    {  
        printf("World Base\n");  
    }  
};  
class Derived : public Base  
{  
public:  
    Derived()  
    {  
        printf("I am Derived()\n");  
    }  
    virtual ~Derived()  
    {  
        printf("I am ~Derived()\n");  
    }  
public:  
    void SayHello();  
    void SayWorld();  
};  

void Derived::SayHello()  
{  
    printf("Hello Derived\n");  
}  
void Derived::SayWorld()  
{  
    printf("World Derived\n");  
}  

int main(void)  
{  
    Base *b1 = new Base;  
    Base *b2 = new Derived;  //构造派生类，先构造父类，再析构子类
    Derived *d = new Derived;  

    b1->SayHello();  
    b1->SayWorld();  

    b2->SayHello();  
    b2->SayWorld();  

    d->SayHello();  
    d->SayWorld();  

    delete d;  
    delete b2;   //析构派生类，先析构子类，再析构父类
    delete b1;  

    d= NULL;  
    b2 = NULL;  
    b1 = NULL;  

    return 0;  
}  

主要考察多态性。
I am Base()
I am Base()
I am Derived()
I am Base()
I am Derived()
Hello Base
World Base
Hello Derived
World Base
Hello Derived
World Derived
I am ~Derived()
I am ~Base()
I am ~Derived()
I am ~Base()
I am ~Base()
11、阅读以下程序并给出执行结果

class Bclass  
{  
public:  
    Bclass(int i , int j)  
    {  
        x = i;  
        y = j;  
    }  
    virtual int fun()  
    {  
        return 0;  
    }  
protected:  
    int x , y;  
};  

class lclass : public Bclass  
{  
public:  
    lclass(int i , int j , int k) : Bclass(i , j)  
    {  
        z = k;  
    }  
    int fun()  
    {  
        return (x+y+z)/3;  
    }  
private:  
    int z;  
};  
int main(void)  
{  
    lclass obj(2,4,10);  
    Bclass p1 = obj;  
    cout<<p1.fun()<<endl;  

    Bclass &p2 = obj;  
    cout<<p2.fun()<<endl;  
    cout<<p2.Bclass::fun()<<endl;  

    Bclass *p3 = &obj;  
    cout<<p3->fun()<<endl;  

    return 0;  
}  

0
5
0
5
12、如何减少频繁分配内存（malloc或者new）造成的内存碎片？（10分）
使用内存池。我们习惯用操作系统为用户提供的API ，malloc，new函数对内存操作，这往往造成频繁进行不同内存大小的开辟，会造成内存碎片，而内存池，在真正使用内存之前，会开辟大小相等，数量不同的内存块，当需要内存块时，从内存池中取内存块，当内存块不够时，继续向内存申请新的内存，这样能够减少对内存的申请次数，能够尽量避免内存碎片，提高程序的执行效率等等。
13、请写出strchr的实现（10分）
函数功能：找出在字符串str中第一次出现字符ch的位置，找到就返回该字符位置的指针（也就是返回该字符在字符串中的地址的位置），找不到就返回空指针（就是NULL）

const char* strchr(const char* str , char ch)
{
if(str == NULL)
{
return NULL;
}
while(str != NULL)
{
if（*str == ch）
{
return str；
}
str++;
}
return NULL;

}

4、请写出冒泡排序法算法（20分）

void BubbleSort(int r[] , int n)
{
int temp;
for(int i=0;i< n;i++)
{
 for(int j=0;j< n-i-1;j++)
 {
if(r[j]>r[j+1])
 {
 temp =r[j];
r[j]=r[j+1];
r[j+1] = temp;
 }
 }
}
}