zoukankan      html  css  js  c++  java

  • C++经典面试题

    1、int a=5，则 ++(a++)的值是（）
    A、5      B、   6          C、7       D、逻辑错误
    a++返回的是一个临时变量，这里是右值，不能再前面++了
    2、下面的代码输出什么？（取地址运算符比+运算符的优先级要高）

    [cpp] view plaincopy
    1. int main(void)  
    2. {  
    3.     int  a[5] = {1, 2, 3, 4, 5};  
    4.     int  *ptr = (int *)(&a+1);  
    5.     printf("%d %d",*(a+1),*(ptr-1));  
    6.     return 0;  
    7. }  
    A、1  6     B、2   4   C、2   5    D、1   5
    &a是一个指向数组的指针（行指针），a的步长就是数组的长度。也就是说执行a+1时，a要跨过n个整型数据的长度，输出*ptr就会发现越界了，是一个随机值，那么ptr-1的值就是数组的最后一个值了。
    &a+1不是首地址+1， 系统会认为加一个a数组的偏移， 是偏移了一个数组的大小（本例是5个int ）
    int *ptr = (int *)(&a+1);
    则ptr实际上是&(a[5]),也就是a+5
    原因如下：
    &a 是数组指针， 其类型为int (*)[5];
    而指针加1要根据指针类型加上一定的值， 不同类型的指针+1之后增加的大小不同。
    a 是长度为5的int数组指针，所以要加5*sizeof(int)
    所以，ptr实际是ptr[5]
    但是ptr与（&a+1）类型时不一样的（这点很重要）
    所以ptr-1只会减去sizeof(int *)
    a, &a的地址是一样的，但是意思不一样
    a是数组首地址，也就是a[0]的地址，&a是对象（数组）首地址
    a+1是数组下一元素的地址，即a[1], &a+1是下一个对象的地址，即a[5].
    3、以下三条输出语句分别输出什么？

    [cpp] view plaincopy
    1.  char str1[] = "abc";  
    2. char str2[] = "abc";  
    3.   
    4. const char str3[] = "abc";  
    5. const char str4[] = "abc";  
    6.   
    7. const char* str5 = "abc";  
    8. const char* str6 = "abc";  
    9.   
    10. cout << boolalpha << ( str1==str2 ) << endl; // 输出什么？  
    11. cout << boolalpha << ( str3==str4 ) << endl; // 输出什么？  
    12. cout << boolalpha << ( str5==str6 ) << endl; // 输出什么？  

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

    4、下面代码的输出是什么？

    [cpp] view plaincopy
    1. float a = 1.0f;  
    2.     cout<< (int)a <<endl;  
    3.     cout<< (int&)a <<endl;  
    4.     cout << boolalpha << ( (int)a==(int&)a ) << endl; // 输出什么？  
    5.   
    6.     float b = 0.0f;  
    7.     cout<< (int)b <<endl;  
    8.     cout<< (int&)b <<endl;  
    9.     cout << boolalpha << ( (int)b==(int&)b ) << endl; // 输出什么？  

    浮点数的 1.0f 在内存里是这样表示的： 
    0011 1111 1000 0000 00000000 00000000 

    这个32位二进制数被当作整数输出就是： 
    1065353216 
    而整数的 1 在内存里是这样表示的： 
    0000 0000 0000 0000 00000000 00000001 
    所以 (int)a != (int&)a 

    浮点的0和整数的0 在内存里都是： 
    0000 0000 0000 0000 00000000 00000000 
    所以 (int)b == (int&)b 

    5、以下代码中的两个sizeof用法有问题吗？

    [cpp] view plaincopy
    1. void UpperCase( char str[] ) // 将str 中的小写字母转换成大写字母  
    2. {  
    3.      for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i )  
    4.      {  
    5.          if( 'a'<=str[i] && str[i]<='z' )  
    6.          {  
    7.               str[i] -= ('a'-'A' );  
    8.          }  
    9.      }  
    10. }  
    11. int main(void)  
    12. {  
    13.     char str[] = "aBcDe";  
    14.   
    15.     cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;  
    16.   
    17.     UpperCase( str );  
    18.     cout << str << endl;  
    19.     return 0;  
    20. }  
    6、非C++内建型别A和B，在哪几种情况下B能隐式转化为A？
    7、以下代码有什么问题？

    [cpp] view plaincopy
    1. struct Test  
    2. {  
    3.     Test(int ) { }  
    4.     Test() { }  
    5.     void fun() { }  
    6. };  
    7.   
    8. int main(void)  
    9. {  
    10.     Test a(1);  
    11.     a.fun();  
    12.     Test b();  
    13.     b.fun();  
    14.     return 0;  
    15. }  
    8、以下代码有什么问题？

    [cpp] view plaincopy
    1. cout<< (true?1:"0") <<endl;  

    9、以下代码能够编译通过吗，为什么？

    [cpp] view plaincopy
    1. int main(void)  
    2. {  
    3.     unsigned int const size1 = 2;  
    4.     char str1[ size1 ];  
    5.     unsigned int temp = 0;  
    6.     cin >> temp;  
    7.     unsigned int const size2 = temp;  
    8.     char str2[ size2 ];  
    9.     return 0;  
    10. }  
    10、以下反向遍历array数组的方法有什么错误？
    [cpp] view plaincopy
    1. int main(void)  
    2. {  
    3.     vector array;  
    4.   
    5.     array.push_back( 1 );  
    6.     array.push_back( 2 );  
    7.     array.push_back( 3 );  
    8.     for( vector::size_type i=array.size()-1; i>=0; --i )    // 反向遍历array数组  
    9.     {  
    10.         cout << array[i] << endl;  
    11.     }  
    12.     return 0;  
    13. }  

    11、以下代码中的输出语句输出吗，为什么？

    [cpp] view plaincopy
    1. struct CLS  
    2. {  
    3.     int m_i;  
    4.     CLS(int i): m_i( i ) {   }  
    5.     CLS()  
    6.     {  
    7.         CLS( 0 );  
    8.     }  
    9. };  
    10.   
    11. int main(void)  
    12. {  
    13.     CLS obj;  
    14.     cout << obj.m_i << endl;  
    15.     return 0;  
    16. }  
    12、C++中的空类，默认产生哪些类成员函数？

    13、 以下代码有什么问题吗？

    [cpp] view plaincopy
    1. int main(void)  
    2. {  
    3.     typedef vector IntArray;  
    4.   
    5.     IntArray array;  
    6.     array.push_back( 1 );  
    7.     array.push_back( 2 );  
    8.     array.push_back( 2 );  
    9.     array.push_back( 3 );  
    10.   
    11.     // 删除array数组中所有的2  
    12.     for( IntArray::iterator itor=array.begin(); itor!=array.end(); ++itor )  
    13.     {  
    14.         if( 2 == *itor )  
    15.         {  
    16.             array.erase( itor );  
    17.         }  
    18.     }  
    19.     return 0;  
    20. }  
    14、 写一个函数，完成内存之间的拷贝。[考虑问题是否全面]


    答案：

    4、分别输出false和true。注意转换的应用。(int)a实际上是以浮点数a为参数构造了一个整型数，该整数的值是，(int&)a则是告诉编译器将a当作整数看（并没有做任何实质上的转换）。因为以整数形式存放和以浮点形式存放其内存数据是不一样的，因此两者不等。对b的两种转换意义同上，但是的整数形式和浮点形式其内存数据是一样的，因此在这种特殊情形下，两者相等（仅仅在数值意义上）。

      注意，程序的输出会显示(int&)a=1065353216，这个值是怎么来的呢？前面已经说了，以浮点数形式存放在内存中，按ieee754规定，其内容为x0000803F（已考虑字节反序）。这也就是a这个变量所占据的内存单元的值。当(int&)a出现时，它相当于告诉它的上下文：“把这块地址当做整数看待！不要管它原来是什么。”这样，内容x0000803F按整数解释，其值正好就是（十进制数）。

      通过查看汇编代码可以证实“(int)a相当于重新构造了一个值等于a的整型数”之说，而(int&)的作用则仅仅是表达了一个类型信息，意义在于为cout<<及==选择正确的重载版本。

    5、答：函数内的sizeof有问题。根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组，因此其大小为，函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此sizeof作用于上只将其当指针看，一个指针为个字节，因此返回。

    6、答：
    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& ); // 赋值操作，虽不是正宗的隐式类型转换，但也勉强算一个

    7、答：变量b定义出错。按默认构造函数定义对象，不需要加括号。

    8、答：三元表达式“?:”问号后面的两个操作数必须为同一类型。

    9、答：str2定义出错，size2非编译器期间常量，而数组定义要求长度必须为编译期常量。

    10、答：首先数组定义有误，应加上类型参数：vector<int> array。其次vector::size_type被定义为unsigned int，即无符号数，这样作为循环变量的i为0时再减就会变成最大的整数，导致循环失去控制。

    [cpp] view plaincopy
    1. int main(void)  
    2. {  
    3.     vector<int> array;  
    4.     array.push_back(1);  
    5.     array.push_back(2);  
    6.     array.push_back(3);  
    7.     for(int i = array.size() - 1 ; i >= 0 ; --i)  
    8.         cout<<array[i]<<endl;  
    9.     return 0;  
    10. }  
    11、答：不能。在默认构造函数内部再调用带参的构造函数属用户行为而非编译器行为，亦即仅执行函数调用，而不会执行其后的初始化表达式。只有在生成对象时，初始化表达式才会随相应的构造函数一起调用。
    12、

    [cpp] view plaincopy
    1. class Empty  
    2. {  
    3. public:  
    4.     Empty();   //缺省构造函数  
    5.     Empty(const Empty &);   //拷贝构造函数  
    6.     ~Empty();   //析构函数  
    7.     Empty & operator=(const Empty &);   //赋值运算符  
    8.     Empty* operator&();   //取址运算符  
    9.     const Empty* operator&() const;   //取址运算符const  
    10. };  
    13、答：同样有缺少类型参数的问题。另外，每次调用“array.erase(itor);”，被删除元素之后的内容会自动往前移，导致迭代漏项，应在删除一项后使itor--，使之从已经前移的下一个元素起继续遍历。
    [cpp] view plaincopy
    1. int main(void)  
    2. {  
    3.     typedef vector<int> IntArray;  
    4.   
    5.     IntArray array;  
    6.     array.push_back( 1 );  
    7.     array.push_back( 2 );  
    8.     array.push_back( 2 );  
    9.     array.push_back( 3 );  
    10.   
    11.     // 删除array数组中所有的2  
    12.     for( IntArray::iterator itor=array.begin(); itor!=array.end(); ++itor )  
    13.     {  
    14.         if( 2 == *itor )  
    15.         {  
    16.             itor = array.erase( itor );  
    17.             itor--;  
    18.         }  
    19.     }  
    20.     return 0;  
    21. }  

    14、

    [cpp] view plaincopy
    1. // 功能：由src所指内存区域复制count个字节到dest所指内存区域。  
    2. // 说明：src和dest所指内存区域可以重叠，但复制后dest内容会被更改。函数返回指向dest的指针  
    3. void *memmove(void *dest , const void *src , size_t count)  
    4. {  
    5.     assert( (dest != NULL) && (src != NULL));     //安全检查  
    6.     assert( count > 0 );  
    7.   
    8.     char *psrc = (char *) src;  
    9.     char *pdest = (char *) dest;  
    10.     //检查是否有重叠问题  
    11.     if( pdest < psrc )  
    12.     {  
    13.         //正向拷贝  
    14.         while( count-- )  
    15.             *pdest++ = *psrc++;  
    16.     }  
    17.     else if( psrc < pdest )  
    18.     {  
    19.         //反向拷贝  
    20.         psrc = psrc + count - 1;  
    21.         pdest = pdest + count - 1;  
    22.         while( count-- )  
    23.             *pdest-- = *psrc--;  
    24.     }  
    25.     return dest;  
    26. }  
    27.   
    28. // 功能：由src指向地址为起始地址的连续n个字节的数据复制到以dest指向地址为起始地址的空间内。  
    29. // 说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针  
    30. void *memmcpy(void *dest , const void *src , size_t count)  
    31. {  
    32.     assert( (dest != NULL) && (src != NULL));     //安全检查  
    33.     assert( count > 0 );  
    34.   
    35.     char *psrc = (char *) src;  
    36.     char *pdest = (char *) dest;  
    37.     while( count-- )  
    38.         *pdest++ = *psrc++;  
    39.   
    40.     return dest;  
    41. }  
  • 相关阅读:
    一些鲜为人知的编程真相
    一些鲜为人知的编程真相
    Ruby 1.9不会杀死Python
    Boost.Asio和ACE之间关于Socket编程的比较
    Effective C++第17条：要在单独的语句中使用智能指针来存储由new创建的对象
    Ruby 1.9不会杀死Python
    Boost智能指针——weak_ptr
    对象生死劫 － 构造函数和析构函数的异常
    Protocol Buffers：Google 的数据交换格式
    根据出生日期计算年龄
  • 原文地址：https://www.cnblogs.com/smileallen/p/3391596.html
Copyright © 2011-2022 走看看