C/C++面试题-1

1. C语言中的 sizeof 问题
(1)类型转换的问题

    #include <stdio.h>  
    #define NUM (sizeof(arr) / sizeof(arr[0]))        
    int arr[] = { 1， 2， 3， 4， 5， 6， 7 };        
    int main()  
    {  
        int i;         
        for( i = -1; i <= ( NUM - 2 ); i++)  
        {       
        printf("%d\n",arr[i+1]);  
        }            
        return 0;  
    } 

输出的结果是空的！
解释：我们要知道的是：sizeof 返回的是一个unsinged int的值！那么在for循环的时候，i = -1就会向后面转型，将其值转化为sizeof的值，那么我们很清楚，-1转化的sizeof的值是很大的一个正整数！那么很显然就直接不符合i <= ( NUM - 2 )的条件了，所以就不会输出！！！
（2）sizeof是操作符

    #include <stdio.h>  
    int main()  
    {  
        int i;  
        i = 10;        
        printf("i : %d\n",i);  
        printf("sizeof(i++) is: %d\n",sizeof(i++));  
        printf("i : %d\n",i);  
          return 0;  
    } 

结果是
 i : 10
 sizeof(i++) is: 4
 i : 10
为什么第三个还是输出10呢？！
解释：解决这个问题就是要理解编译器编译原理。 我们要知道sizeof仅仅是一个操作符而已并不是函数，sizeof要做的仅仅是获得i++的字节数，那么所以在编译的时候就直接用4代替了i++了，反正编译器知道结果都是一样，所以最终i++并没有执行！

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

 

3. C++对象声明的陷阱

struct Test
{
    Test( int ) {}
    Test() {}
    void fun() {}
};
void main( void )
{
    Test a(1);
    a.fun();
    Test b();//这儿的问题，C++中默认构造函数生成实例不用加括号，如果加上括号这儿就像定义了一个函数
    b.fun();
}

4. 以下代码有什么问题？[C++易]
cout << (true?1:"1") << endl;
这儿条件操作符中的前后的类型要一致
一个条件操作符是下面这样的形式:
exp1 ? exp2 : exp3
表达式exp1总是会被求值。exp2和exp3是否被执行依赖于exp1的值，如果exp1为真则exp2会被求值，否则exp3被求值。
Side Effect:
在执行exp2或者exp3之前，exp1的所有side effect必须全部求值或者更新完成，因为条件操作符的第一个操作数求值之后就是一个sequence point。如果exp2和exp3都有side effect，那么只有一个会被求值。
返回类型：
条件操作符的返回类型取决于exp2和exp3类型，编译器会检查exp2（可能是一个class type）能否转换为exp3或者exp3能否转换为exp2，如果两个都不满足，编译器就会抛出一个错误。

5. C++中的空类，默认产生哪些类成员函数？[C++易]
答：

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

 

6. 转换为引用类型:浮点数内存表示

   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;

问：上述代码的输出结果是什么？
这种转换为引用类型的情况的确比较少见，但有些时候必须用它！(EC++ 3rd)中讲解copy assignment operator时就提到过一种必须用它的情形。大概需要记住的就是，转向普通类型，则返回的其实是一个为你新创建的临时对象；而转换为引用类型，则返回的其实是你要转换的那个对象本身，只是reinterpret了一下而已，原来的对象内容也没改变。
"转换为引用类型"操作的本质: "(int&)a 等价于 *(int*)(&a); 就是把原始a 的内存里面数据按照整形输出。因此不等价于(int)a;"
另外的解释:(int&)a 不经过转换， 直接得到a在内存单元的值，并将其转换成整数输出。

 

7. C语言字符串与字符数组

以下输出语句分别输出什么？[C易]

char str1[] = "abc";
char str2[] = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char* str5 = "abc";
const char* str6 = "abc";
char* str7 = "abc";
char* str8 = "abc";
char* str9 = "efg";
char* str0 = "efg";
cout<<"str1="<<(void*)str1<<" "<<"str2="<<(void*)str2<<" ";
cout << boolalpha << ( str1==str2 ) << endl; // 输出什么？
cout<<"str3="<<(void*)str3<<" "<<"str4="<<(void*)str4<<" ";
cout << boolalpha << ( str3==str4 ) << endl; // 输出什么？
cout<<"str5="<<(void*)str5<<" "<<"str6="<<(void*)str6<<" ";
cout << boolalpha << ( str5==str6 ) << endl; // 输出什
cout<<"str7="<<(void*)str7<<" "<<"str8="<<(void*)str8<<" ";
cout << boolalpha << ( str7==str8 ) << endl; // 输出什
cout<<"str9="<<(void*)str9<<" "<<"str0="<<(void*)str0<<" ";
cout << boolalpha << ( str9==str0 ) << endl; // 输出什 

在linux平台下的结果是：

这个应该比较好理解，数组是要分配空间的，因为它的内容是可以改变的，所以地址是不同的。而字符串是不允许改变的，相同的字符串应该是统一存放的。

 

8. 其他类型到bool的隐式转换

下面的代码输出是什么？

#include <iostream>
#include <string>
using namespace std ;
void a(bool input) {
cout << "I amd first" <<endl;
cout <<input <<endl ;
}
void a(const string &input) {
cout<< "I amd second" <<endl ;
cout<<input <<endl ;
}
int main( int argc, char **argv)
{
a("str") ; // 是调用第二个a函数吗?
a(string("str")) ;
return 0 ;
}

 

输出结果竟然是：

char*类型的"str"居然被隐式转化成了bool类型

然后做实验验证一下：

#include <string>
using namespace std;
int main(int argc, const char *argv [])
{
int a =1;
char *b= "wo";
float c = 1.1;
bool x ;
x = a;
x = b;
x = c;
return 0;
}

 

int,char*,float确实都可以隐式转化成bool而不会有任何警告，导致出现问题很不容易发现，这里在重载函数的时候确实需要万分注意。

 

9. 堆排序在大数据中的应用

堆排序的时间复杂度为O(nlogn)，最坏的情况也是这个时间复杂度，空间复杂度是O(1)。但是堆排序是不稳定的！

在面试过程中，很多时候都会用到堆排序，比如下面的题目都是堆排序的典型题目：

1.给你100w个数据求最大的10个元素。这个时候我们可以使用小顶堆！这个是为什么呢！

2.给你100w个数据求最小的10个元素。这个时候我们可以使用大顶堆！这个是为什么呢！

相信会有很多同学会问出上面的两个疑问，答案其实很简单，在求最大的元素的时候，我们建立一个有10个元素的小顶堆，那么堆顶元素肯定是最小的，然后拿剩余的元素和堆顶进行比较，如果比堆顶大，就替换这个元素，然后调整堆，调整完之后堆顶依然是10个元素中最小的，依次比较剩余的元素。

堆排序与直接插入排序的区别

直接选择排序中，为了从R[1..n]中选出关键字最小的记录，必须进行n-1次比较，然后在R[2..n]中选出关键字最小的记录，又需要做n-2次比 较。事实上，后面的n-2次比较中，有许多比较可能在前面的n-1次比较中已经做过，但由于前一趟排序时未保留这些比较结果，所以后一趟排序时又重复执行 了这些比较操作。 堆排序可通过树形结构保存部分比较结果，可减少比较次数。