几道c/c++练习题

1.以下三条输出语句分别输出什么？[C易]   

　　char    str1[] = "abc";   
   char    str2[] = "abc";   
   const    char    str3[]    =    "abc";     
   const    char    str4[]    =    "abc";     
   const    char*    str5      =    "abc";   
   const    char*    str6      =    "abc";   
   cout    <<    boolalpha    <<    (    str1==str2    )    <<   endl;     
   cout    <<    boolalpha    <<    (    str3==str4    )    <<   endl;       
   cout    <<    boolalpha    <<    (    str5==str6    )    <<   endl;   

   答：分别输出false,false,true。str1和str2都是字符数组，每个都有其自己的存储区，它们的值则是各存储区首地址，不等；str3 和str4同上，只是按const语义，它们所指向的数据区不能修改。str5和str6并非数组而是字符指针，并不分配存储区，其后的“abc”以常量形式存于静态数据区，而它们自己仅是指向该区首地址的指针，相等。   
    
    
2. 以下代码中的两个sizeof用法有问题吗？[C易]   

   void UpperCase(char str[]) //将str中的小写字母转换成大写字母   
 　{   
           for(size_t i=0; i < sizeof(str)/sizeof(str[0]); ++i)   
                   if('a'<=str[i] && str[i]<='z')   
                           str[i] -= ('a'-'A');   
   }   
   char str[] = "aBcDe";   
   cout << "str字符长度为:    " << sizeof(str)/sizeof(str[0]) << endl;   
   UpperCase(str);   
   cout << str << endl; 

   答：函数内的sizeof有问题。根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。函数外的str是一个 静态定义的数组，因此其大小为6，函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此sizeof作用于上只将其当指针看，一个指针为4个字节，因此返回4。   
    
    
3. 非C++内建型别    A    和    B，在哪几种情况下B能隐式转化为A？[C++中等]   

   a.    class    B : public A {    ……}    //  B公有继承自A，可以是间接继承的   
   b.    class    B { operator A(); }      //  B实现了隐式转化为A的转化   
   c.    class    A { A(const B& ); }      //  A实现了non-explicit的参数为B（可以有其他带默认值的参数）构造函数   
   d.    A& operator= (const A& );         //  赋值操作，虽不是正宗的隐式类型转换，但也可以勉强算一个   
    

4. 以下代码有什么问题？[C++易]   

   struct    Test   
   {   
           Test(int)  {}   
           Test()    {}   
           void fun() {}   
   };   
   int    main()   
   {   
           Test a(1);   
           a.fun();   
           Test b();   
           b.fun(); 
　　　　　　 return 0;  
   }   
    

答：变量b定义出错。按默认构造函数定义对象，不需要加括号。   
    
    
5.以下代码有什么问题？[C++易]   
   

cout    <<    (true?1:"1")    <<    endl;   

:两侧值类型应相同   
    
6.以下代码能够编译通过吗，为什么？[C++易]   
   

   unsigned    int    const    size1    =    2;   
   char    str1[    size1    ];   
   unsigned    int    temp    =    0;   
   cin    >>    temp;   
   unsigned    int    const    size2    =    temp;   
   char    str2[    size2    ];   

答：str2定义出错，size2非编译器期间常量，而数组定义要求长度必须为编译期常量。   
    
7.以下反向遍历array数组的方法有什么错误？[STL易]   

   vector    array;   
   array.push_back(    1    );   
   array.push_back(    2    );   
   array.push_back(    3    );   
   for(    vector::size_type    i=array.size()-1;    i>=0;    --i    )    //    反向遍历array数组   
   {   
           cout    <<    array[i]    <<    endl;   
   }   

答：首先数组定义有误，应加上类型参数：vector<int>    array。其次vector::size_type被定义为unsigned    int，即无符号数，这样做为循环变量的i为0时再减1就会变成最大的整数，导致循环失去控制。   
    
8.以下代码中的输出语句输出0吗，为什么？[C++易]   

   struct    CLS   
   {   
           int    m_i;   
           CLS(    int    i    )    :    m_i(i)    {}   
           CLS()   
           {   
                   CLS(0);   
           }   
   };   
   CLS    obj;   
   cout    <<    obj.m_i    <<    endl; 

答：不能。在默认构造函数内部再调用带参的构造函数属用户行为而非编译器行为，亦即仅执行函数调用，而不会执行其后的初始化表达式。只有在生成对象时，初始化表达式才会随相应的构造函数一起调用。   
    
9.C++中的空类，默认产生哪些类成员函数？[C++易]   

   class    Empty   
   {   
   public:   
           Empty();                                                      //    缺省构造函数   
           Empty(    const    Empty&    );                          //    拷贝构造函数   
           ~Empty();                                                    //    析构函数   
           Empty&    operator=(    const    Empty&    );    //    赋值运算符   
           Empty*    operator&();                                //    取址运算符   
           const    Empty*    operator&()    const;        //    取址运算符    const   
   };   

      
10.以下两条输出语句分别输出什么？[C++难]   

   float    a    =    1.0f;   
   cout    <<    (int)a    <<    endl;   
   cout    <<    (int&)a    <<    endl;   
   cout    <<    boolalpha    <<    (    (int)a    ==    (int&)a    )    <<    endl;    //    输出什么？   
   float    b    =    0.0f;   
   cout    <<    (int)b    <<    endl;   
   cout    <<    (int&)b    <<    endl;   
   cout    <<    boolalpha    <<    (    (int)b    ==    (int&)b    )    <<    endl;    //    输出什么？

   
   答：分别输出false和true。注意转换的应用。(int)a实际上是以浮点数a为参数构造了一个整型数，该整数的值是1，(int&)a则 是告诉编译器将a当作整数看（并没有做任何实质上的转换）。因为1以整数形式存放和以浮点形式存放其内存数据是不一样的，因此两者不等。对b的两种转换意 义同上，但是0的整数形式和浮点形式其内存数据是一样的，因此在这种特殊情形下，两者相等（仅仅在数值意义上）。   
   注意，程序的输出会显示(int&)a=1065353216，这个值是怎么来的呢？前面已经说了，1以浮点数形式存放在内存中，按 ieee754规定，其内容为0x0000803F（已考虑字节反序）。这也就是a这个变量所占据的内存单元的值。当(int&)a出现时，它相 当于告诉它的上下文：“把这块地址当做整数看待！不要管它原来是什么。”这样，内容0x0000803F按整数解释，其值正好就是1065353216 （十进制数）。   
   通过查看汇编代码可以证实“(int)a相当于重新构造了一个值等于a的整型数”之说，而(int&)的作用则仅仅是表达了一个类型信息，意义在于为cout<<及==选择正确的重载版本。   
看代码

[root@ba face]# cat 03.cpp 
#include <iostream>
#include <stdio.h>

int main()
{
	float a = 1.0f;   
	std::cout << (int)a << std::endl;   
	std::cout << (int&)a << std::endl;   
	std::cout << std::boolalpha << ((int)a == (int&)a) << std::endl;

	float b = 0.0f;   
	std::cout << (int)b << std::endl;   
	std::cout << (int&)b << std::endl;   
	std::cout << std::boolalpha << ((int)b == (int&)b) << std::endl;  

	int* pa = (int*)&a;
     	printf("%#x
", *pa);

	int* pb = (int*)&b;
     	printf("%#x
", *pb);

	return 0;
}
[root@ba face]# g++ 03.cpp 
[root@ba face]# ./a.out 
1
1065353216
false
0
0
true
0x3f800000
0
[root@ba face]# printf %d 0x3f800000
1065353216[root@ba face]# 
[root@ba face]# 

　　

   

11.以下代码有什么问题？[STL易]   

   typedef    vector    IntArray;   
   IntArray    array;   
   array.push_back(    1    );   
   array.push_back(    2    );   
   array.push_back(    2    );   
   array.push_back(    3    );   
   //    删除array数组中所有的2   
   for(    IntArray::iterator    itor=array.begin();    itor!=array.end();   ++itor    )   
   {   
           if(    2    ==    *itor    )    array.erase(    itor   );   
   }   

    
答：同样有缺少类型参数的问题。另外，每次调用“array.erase(    itor    );”，被删除元素之后的内容会自动往前移，导致迭代漏项，应在删除一项后使itor--，使之从已经前移的下一个元素起继续遍历。   
      
12. 写一个函数，完成内存之间的拷贝。[考虑问题是否全面]   

   void*    mymemcpy(    void    *dest,    const    void    *src,   size_t    count    )   
   {   
           char*    pdest    =    static_cast<char*>(    dest    );   
           const    char*    psrc    =    static_cast<const    char*>(    src    );   
           if(    pdest>psrc    &&    pdest<psrc+cout    )      
           {   
                   for(    size_t    i=count-1;    i!=-1;    --i    )   
                                   pdest[i]    =   psrc[i];   
           }   
           else   
           {   
                   for(    size_t    i=0;    i<count;    ++i   )   
                           pdest[i]    =    psrc[i];   
           }   
           return    dest;   
   } 

　　

 13.解码题

#include <stdio.h>

int encode(const void* raw_in, void* raw_out, unsigned int password, size_t len)
{
        const unsigned char* in = (const unsigned char*)raw_in;
        unsigned char* out = (unsigned char*)raw_out;

        unsigned int seed = password ^ 0xe9f929f1u;
        for(size_t i = 0 ; i < len; ++i)
        {
                unsigned char a = (in[i] ^ seed) >> 5;
                unsigned char b = ((((unsigned int)in[i]) << 16) ^ seed) >> (16-3);
                a &= 7;
                b &= 248;
                a = 7 & (a ^ (b << 3));
                out[i] = a | b;
                seed = ((seed ^ in[i]) * 5393887 + in[i]);
        }

        return 0;
}

int decode(const void* raw_in, void* raw_out, unsigned int password, size_t len)
{
        const unsigned char* in = (const unsigned char*)raw_in;
        unsigned char* out = (unsigned char*)raw_out;

        unsigned int seed = password ^ 0xe9f929f1u;
        for  (size_t  i  =  0  ;  i  < len; ++i)
        { //  请在此处补全代码 
                unsigned char a = in[i] & 7;
                unsigned char b = in[i] & 248;
                a = (a << 5) ^ seed & 224;
                b = (((unsigned int)b) << 13 ^ seed) >> 16 & 31;
                out[i] = a | b;
                seed = ((seed ^ out[i]) * 5393887 + out[i]);
        }
        return 0;
}
int main()
{
        const unsigned char buf1[] = {
        0xd0, 0xd8, 0x7d, 0x96, 0x55, 0x27, 0xfc, 0x1c, 0x96, 0x97,
        0xa5, 0x08, 0x1b, 0xd0, 0x06, 0xf7, 0x36, 0xac, 0x57, 0x3b,
        0x41, 0xad, 0x46, 0x71, 0xf4, 0x59, 0xda, 0xe3, 0xf7, 0xed,
        0x06, 0xb7, 0xee, 0x80, 0xe9, 0x8f, 0x9c, 0x01, 0x02, 0xe5,
        0xe4, 0x51, 0xed, 0x8e, 0xd6, 0xec, 0xbd, 0x68, 0x2f, 0x41,
        0xcd, 0x0d, 0x15, 0x4f, 0x93, 0xd1, 0x61, 0xc3, 0x5f, 0x8d,
        0x65, };
        unsigned char buf2[100] = {};
        const unsigned int password = 0x31484625u;
        const size_t len = sizeof(buf1);
        decode(buf1, buf2, password, len);
        printf("%s
", buf2);
        return 1;
}