C/C++面试题总结

39.构造函数能否为虚函数

构造函数不可以，析构函数可以。

因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。

如果它的构造函数是虚函数，那就要通过对象中的虚函数表指针来调用，而这个虚函数表是在构造函数初始化列表阶段才初始化的。

https://blog.csdn.net/qq_41830537/article/details/102626648

40.在C中用const 能定义真正意义上的常量吗？C++中的const呢？

const修饰的变量是只读的，本质上还是变量，与C语言不同，c++中的const不是只读变量。C++中的const是个真正意义上的常量。

C语言中的const还是可变的：

 int main()
 {
      const int c = 0;
     int* p = (int*)&c;  
      printf("Begin...\n"); 
      *p = 5;
     printf("c = %d\n", c);  //C语言编译：输出5，
                                       //说明c并不是真正意义上的常量 
      return 0;
 }

由于c++中const常量的值在编译期就已经决定，下面的做法是OK的，但是c中是编译通不过的。

int main(void)
 {
     const int a = 8;
     const int b = 2;
     int array[a+b] = {0};
     return 0;
}

41.宏和内联（inline）函数的比较？

(1)内联（inline）函数是C++中引用的一个新的关键字；C++中推荐使用内联函数来替代宏代码片段；

(2)内联函数将函数体直接扩展到调用内联函数的地方，这样减少了参数压栈，跳转，返回等过程；

(3)  由于内联发生在编译阶段，所以内联相较宏，是有参数检查和返回值检查的，因此使用起来更为安全；

(4)内联函数不能过于复杂，最初C++限定不能有任何形式的循环，不能有过多的条件判断，不能对函数进行取地址操作等，

但是现在的编译器几乎没有什么限制，基本都可以实现内联。

42.typedef和define由什么区别

用法不同：typedef用来定义一种数据类型的别名，增强程序的可读性。define主要用来定义常量，以及书写复杂使用频繁的宏。

执行时间不同：typedef是编译过程的一部分，有类型检查的功能。define是宏定义，是预编译的部分，其发生在编译之前，只是简单的进行字符串的替换，不进行类型的检查。

https://blog.csdn.net/qq_45607873/article/details/123746610

43.strcat、strncat、strcpy哪些函数会导致内存溢出？如何改进？

strcpy函数会导致内存溢出。

strcpy拷贝函数不安全，他不做任何的检查措施，也不判断拷贝大小，不判断目的地址内存是否够用。

char *strcpy（char *strDest，const char *strSrc）

strncat()主要功能是在字符串的结尾追加n个字符。

char * strncat(char *dest, const char *src, size_t n);

strcat()函数主要用来将两个char类型连接。例如：

char d[20]="Golden"; 
char s[20]="View"; 
strcat(d,s); //打印d printf("%s",d);

输出 d 为 GoldenView （中间无空格）

**延伸**：

memcpy拷贝函数，它与strcpy的区别就是memcpy可以拷贝任意类型的数据，strcpy只能拷贝字符串类型。

memcpy 函数用于把资源内存（src所指向的内存区域）拷贝到目标内存（dest所指向的内存区域）；

有一个size变量控制拷贝的字节数；

函数原型：

void *memcpy(void *dest, void *src, unsigned int count);

44.简述队列和栈的异同

队列和栈都是线性存储结构，但是两者的插入和删除数据的操作不同，队列是“先进先出”，栈是“后进先出”。

45.堆和栈的区别？

堆存放动态分配的对象——即那些在程序运行时动态分配的对象，比如 malloc出来的对象，其生存期由程序控制，必须手动申请，手动释放。

栈用来保存定义在函数内的非static对象，如局部变量，仅在其定义的程序块运行时才存在，由编译器自动创建和销毁。

46.堆和自由存储区的区别？

总的来说，堆是C语言和操作系统的术语，是操作系统维护的一块动态分配内存；自由存储是C++中通过new与delete动态分配和释放对象的抽象概念。他们并不是完全一样。

从技术上来说，堆（heap）是C语言和操作系统的术语。堆是操作系统所维护的一块特殊内存，它提供了动态分配的功能，当运行程序调用malloc()时就会从中分配，

稍后调用free可把内存交还。而自由存储是C++中通过new和delete动态分配和释放对象的抽象概念，通过new来申请的内存区域可称为自由存储区。

47.什么是内存泄漏？面对内存泄漏有什么避免方法

用动态存储分配函数动态开辟的空间，在使用完毕后未释放，结果导致一直占据该内存单元即为内存泄露。

malloc的时候得确定在那里free.  new的时候得确定delete。在C++中应该优先考虑使用智能指针.

48.链表和数组的区别

存储形式：数组是一块连续的空间，声明时就要确定长度。链表是一块可不连续的动态空间，长度可变，每个结点要保存相邻结点指针。 

数据查找：数组的线性查找速度快，查找操作直接使用偏移地址。链表需要按顺序检索结点，效率低。 

数据插入或删除：链表可以快速插入和删除结点，而数组则可能需要大量数据移动。 

越界问题：链表不存在越界问题，数组有越界问题。 

49.结构与联合有和区别

在使用结构变量时要先对其定义； 结构名是结构的标识符不是变量名；结构是按变量名字来访问成员的；结构体指针采用“->”访问成员，结构体变量采用“.”访问。

结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的

所有成员都存在（不同成员的存放地址不同）。

对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。

50.什么是“引用”？申明和使用“引用”要注意哪些问题？

引用就是某个目标变量的“别名”(alias)，对应用的操作与对变量直接操作效果完全相同。

声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用

分配存储单元。不能建立数组的引用。

51.将“引用”作为函数参数有哪些特点？

传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的

操作就是对其相应的目标对象（在主调函数中）的操作。

使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作.

52.STL标准模板库

vector单端数组，当现有的内存空间不够装下数据时，首先配置一块新的空间，然后将旧空间的数据搬往新空间，再释放原来的空间。

deque双端数组，可以在头尾两端分别做元素的插入和删除操作，除非必要，应尽可能的选择使用vector而非deque，因为 deque的迭代器比vector的迭代器要复杂的多。

list双向链表，相较于vector的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间，适合频繁的不确实位置元素

的移除插入。

set二叉树，map二叉树，底层实现都是 红黑树，它可以在O(logn)时间内高效的做查找，插入和删除。

53.陷阱题

 int main()
  {
   int j=2;
   int i=1;
   if(i = 1) j=3;
   if(i = 2) j=5;
   printf("%d",j);
  } 
  输出为5；如果再加上if(i=3)j=6;则输出6。

int main(void)
{
    unsigned int a = 6;
    int b = -20;
    char c;
    (a+b>6)?(c=1):(c=0);
}则c=1，但a+b=-14;如果a为int类型则c=0。
   原来有符号数和无符号数进行比较运算时（==，<,>,<=,>=）,有符号数隐式转换成了无符号数（即底层的补码不变，但是此数从有符号数变成了无符号数），
   比如上面 (a+b)>6这个比较运算，a+b=-14，-14的补码为1111111111110010。此数进行比较运算时，
  被当成了无符号数，它远远大于6，所以得到上述结果。

 main()
 {
    int a[5]={1,2,3,4,5};
     int *ptr=(int *)(&a+1);//&a相当于变成了行指针，加1则变成了下一行首地址
     printf("%d,%d",*(a+1),*(ptr-1));
 }
  *(a+1）就是a[1]，*(ptr-1)就是a[4],执行结果是2，5

int main()
{
     char a;
     char *str=&a;
     strcpy(str,"hello");
     printf(str);
     return 0;
 }
 将字符串赋值给字符变量，内存不够，存在越界。

void test(void) {
     char *p = null;
     strcpy(p,"hello");
     printf("%s\n",p);
 }
 段错误
 
 野指针问题

wap( int* p1,int* p2 )
 {
     int *p;
     *p = *p1;
     *p1 = *p2;
     *p2 = *p;
 }
 段错误，p没有空间，为其分配空间或者不使用指针

 char *RetMenory(void)
  {
      char p[] = “hellow world”;
      return p;
  }
 void Test(void)
 {
     char *str = NULL;
     str = RetMemory();
     printf(str);
 }
 由于p[]是自动变量，所以RetMenory执行完毕时，资源被回收，p指向未知地址。因此str的内容应是不可预测的, 打印的应该是str的地址
         
         
 void getmemery(char *p)
 {
     p = (char *)malloc(100);
 }
  
 main()
 {
     char *str = NULL;
     getmemery(str);
     strcpy(str,"hello world!");
     printf("%s\n",str);
 }     段错误
 
 问题出在这，上述代码传入getmemery(char *p)函数的字符串指针是形参，在函数内部修改形参并不能真正的改变传入形参的值，
 执行完char *str = NULL; gememory(str);后的str仍为NULL；
 一般函数的传递都是值传递，不会改变函数外的变量值。简单地说，就是形参不能够改变实参，实参只是复制了一份给形参！其自身并没有被改变
 
 void getmemery(char **p)
 {
     *p = (char *)malloc(100);
 }
  
 main()
 {
     char *str = NULL;
     getmemery(&str);
     strcpy(*str,"hello world!");
     printf("%s\n",*str);
 }
 这就是我们常说的“地址传递”，将str的地址传给getmemery()函数，getmemery()函数就会通过地址修改str里面的值，这样就会得到正确的结果。
 所以，我们要记住函数传参的两种方式：1）值传递 2）地址传递。

下面两种if语句判断方式。请问哪种写法更好？为什么？
 int n;
 if (n == 10) // 第一种判断方式
 if (10 == n) // 第二种判断方式
 【答案】这是一个风格问题，第二种方式如果少了个=号,编译时就会报错,减少了出错的可能行,可以检测出是否少了=。

#include "stdafx.h"
 #include <iostream>
 using namespace std;
 
 class human {
 public:
     ~human() {    
     //析构函数,该类对象在生存期结束的时候会自动调用的一个函数
         cout << "human over......" << endl;
     }
     void Disp() {
         cout << "human disp......" << endl;
     }
 };
 
 class man : public human
 {
 public:
     ~man() {
         cout << "man over......" << endl;
     }
     void Disp() {
         cout << "man disp......" << endl;
     }
 };
 
 int main()
 {
     human* p = new man;   //定义和初始化指向一个类的指针变量
     p->Disp();           //指向成员运算符,得到一个指针指向的元素
     delete p;
     system("pause");
     return 0;
 }
 答案】
 human disp…
 human over…

 以下三条输出语句分别输出什么？
 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”以常量形式存于静态数据区，而它们自己仅是指向该区首地址的指针，相等。

 int a=5, b=7, c;
 c = a+++b;
 【答案】a=6,b=7,c=12

 一个栈的入栈序列是A，B，C，D，E，则栈的不可能的输出序列是（ ）
 A、EDCBA；
 B、DECBA；
 C、DCEAB；
 D、ABCDE
 【答案】C