C++学习实践(一)高频面试问题总结(附详细答案)

发布时间:2023年12月25日

一、基础常见面试题

1、数组和链表区别

**(1)数组:**一组具有相同数据类型的变量的集合。
(2)链表:一种物理存储单元上非连续、非顺序的存储结构,逻辑顺序是通过链表中的指针链接次序实现的。
逻辑结构:
(1)数组在内存中连续;链表用动态内存分配的方式,内存中不连续。
(2)数组在使用前固定长度,不能改变数组长度;链表动态增删元素。
(3)数组元素减少时会造成内存浪费;链表使用malloc或new来申请内存,使用free或delete来释放内存。
内存结构: 数组从栈上分配内存,使用方便但自由度小;链表在堆上分配内存,自由度大但要注意造成内存泄漏。
访问效率: 数组在内存中顺序存储,下标访问效率高,插入删除效率低;链表需要从头遍历访问,访问效率低,插入删除效率高。
越界问题: 数组大小固定,存在访问越界的风险;链表只要能申请空间就无越界风险。

2、深拷贝和浅拷贝相关问题的区别

拷贝构造函数: 建立对象时可用同一类的另一个对象来初始化该对象的存储空间。这个拷贝过程只需要拷贝数据成员,而函数成员是共用的(只有一份拷贝)。没有自己定义拷贝构造函数时,会在拷贝对象时调用默认拷贝构造函数,进行的是浅拷贝。
用到拷贝构造的情况:
a.一个对象以值传递的方式传入函数体;
b.一个对象以值传递的方式从函数返回;
c. 一个对象需要通过另外一个对象进行初始化。
1.当函数的参数为对象时,实参传递给形参的实际上是实参的一个拷贝对象,系统自动通过拷贝构造函数实现;
2.当函数的返回值为一个对象时,该对象实际上是函数内对象的一个拷贝,用于返回函数调用处。

浅拷贝是让两个指针指向同一个位置,仅复制指针变量的地址,没有复制指向的对象。没有重新分配资源。假如B复制A,如果改变A,则B也被改变,就是浅拷贝

深拷贝是让另一个指针自己再开辟空间。一个类拥有资源,当这个类的对象发生复制过程的时候,会重新开辟内存空间。假如B复制A,A改变而B不变,就是深拷贝。

什么时候使用深拷贝? 在对含有指针成员的类对象进行拷贝时,须自定义拷贝构造函数进行深拷贝,避免内存泄漏。

浅拷贝带来问题:在于析构函数释放多次堆区内存,使用std::shared_ptr,可以解决这个问题。
调用一次构造函数,调用两次析构函数。在没有自己定义拷贝构造函数时,会在拷贝对象时调用默认拷贝构造函数,进行浅拷贝。对指针拷贝后会出现两个指针指向同一个内存空间。 指针被分配一次内存,但是程序结束时该内存却被释放了两次,会导致崩溃。

3、a++和++a区别

a++是先取值后自增;取a的地址,把它的值装入寄存器,然后增加内存中的a的值;++a是先自增后取值。取a的地址,增加它的内容,然后把值放在寄存器中。
如 a = 3,(a++)+(++a) = 8;

4、c++内存模型

栈区: 存放函数参数以及局部变量,在出作用域时,将自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但分配的内存容量有限。

堆区: new 分配的内存块,包括数组,类实例等,需 delete 手动释放。如果未释放,在整个程序结束后,操作系统会自动回收掉。

全局/静态区: 保存自动全局变量和static变量(包括static全局和局部变量)。静态区的内容在整个程序的生命周期内都存在,有编译器在编译的时候分配(数据段(存储全局数据和静态数据)和代码段(可执行的代码/只读常量))。

常量存储区: 常量存于此处,此存储区不可修改。

代码区: 存放函数体的二进制代码,由操作系统进行管理的。

5、四种强制转换和应用场景

二、指针相关

1、指针和引用的区别

(1)定义性质:指针是变量,存储地址;引用是变量的别名,与原始变量是同一块内存;
(2)指针可以不初始化,引用必须初始化。指针可以改变指向地址和指向地址中存放数据的改变。引用不可变
(3)指针可以多级,引用只能一级。
(4)指针可以指向空值, 引用不可以指向空值。
(5)sizeof运算结果不同,自增运算意义不同。

2、函数指针和指针函数

(1) 函数指针:指向函数的入口的指针(函数名替换(*p))
声明返回int类型,形参为int, int:int (*p)(int, int);
(2) 指针函数:返回值是指针的函数。
声明形参为int, intm 返回值是int型指针的函数
int *p(int, int);

类似地:
(3)指针数组和数组指针
指针数组:一个数组,包含元素为指针: int* arr[10];
数组指针: 一个指针,指向一个数组:int(*arr_ptr)[10];

(4)函数模板和模板函数
函数模板:一个模板,用于生成函数。
template
void fun(T a) {}
模板函数:一个函数,由模板生成而来。
fun<Shape*>:fun(int)、fun(double)…

(5)类模板和模板类
类模板:一个模板,生产类的模板;
template
class vector {};
模板类:一个类,由模板生成的类。
vector<Shape*>:vector 、vector…

3、传指针、引用和值

值传递:
(1)形参和实参各占一个独立的存储空间。
(2)形参的存储空间是函数被调用时才分配的,调用开始,系统为形参开辟一个临时的存储区,然后将各实参传递给形参,这是形参就得到了实参的值。

形参是实参的拷贝,改变形参的值并不会影响外部实参的值。值传递是单向的(实参->形参)(形参的操作无法反作用到实参上),参数的值只能传入,不能传出。

当函数内部需要修改参数,并且不希望这个改变影响调用者时,采用值传递。

指针传递:
形参为指向实参地址的指针,当对形参的指向操作时,就相当于对实参本身进行的操作。
指针类型也可以作为函数参数的原型,视为把变量的地址传入函数,此时在函数中,对地址中的元素进行修改,则原先的数据就会确实地被修改。
引用传递:
形参相当于是实参的“别名”,对形参的操作其实就是对实参的操作,在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。
被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。被调函数对形参做的任何操作都影响了主调函数中的实参变量。

引用和指针传递: 形参可以修饰实参
值传递不如地址传递高效,因为值传递先从实参的地址中取值,再赋值给形参代入函数计算。而指针则把形参的地址直接指向实参地址,使用时直接取出数据,效率提高。

*指针需要检查是否为空,引用不需要。

4、常量指针和指针常量

(1)常量指针:指针指向可以改,指针指向的值不可以改。

int a = 10;
int b = 10;
const int *p1 = &a;
p1 = &b // 正确
//*p1 = 100 // 错误

(2)指针常量:指针指向不可以变,值可以更改

int const p2 = &a
//p2 = &b //错误
*p2  = 100 //正确

5、野指针

**野指针:**访问一个已销毁或者访问受限的内存区域的指针,野指针不能判断是否为NULL来避免指针,指向了一块随机的空间,不受程序控制。
**空悬指针:**指针正常初始化,曾指向一个对象,该对象被销毁了,但是指针未制空,那么就成了悬空指针。

野指针产生的原因:
1.指针定义时未被初始化:指针在被定义的时候,如果程序不对其进行初始化的话,它会随机指向一个区域,因为任意指针变量(除了了static修饰的指针)它的默认值都是随机的

2.指针被释放时没有置空:我们在用malloc()开辟空间的时候,要检查返回值是否为空,如果为空,则开辟失败;如果不为空,则指针指向的是开辟的内存空间的首地址。指针指向的内存空间在用free()和delete释放后,如果程序员没有对其进行置空或者其他赋值操作的话,就会成为一个野指针。

3.指针操作超越变量作用域:不要返回指向栈内存的指针或者引用,因为栈内存在函数结束的时候会被释放。

野指针的危害:
指针指向的内容已经无效了,而指针没有被置空,解引用一个非空的无效指针是一个未被定义的行为,也就是说不一定导致错误,野指针被定位到是哪里出现问题,在哪里指针就失效了,不好查找错误的原因。
规避方法:
初始化指针的时候将其置为nullptr,之后对其操作。
释放指针的时候将其置为nullptr

6、智能指针的用法

优点:
(1)处理资源泄露问题;
(2)处理空悬指针的问题;
(3)处理比较由异常造成的资源泄露(new失败抛出异常,没delete)
 
三种智能指针:
auto_ptr已废弃,C++98中的Class auto_ptr在C++11中已不再建议使用。两个指针(同类型)不能指向同一个资源,复制或赋值都会改变资源的所有权。
unique_ptr:独占式/禁止拷贝,
独占式拥有(exclusive ownership)或严格拥有(strict ownership)概念,保证同一时间内只有一个智能指针可以指向该对象。可以避免资源泄露。
shared_ptr:引用计数/自动析构/死循环
实现共享式拥有(shared ownership),多个智能指针可以指向相同对象,该对象和其相关资源会在“最后一个引用(reference)被销毁”时候释放。多个智能指针共享一个控制块(constrol block),包含指向资源的 shared_ptr对象个数、指向资源的 weak_ptr 对象个数以及删除器(delete:用户自定义的用于释放资源的函数,可以默认没有)。

基于引用计数模型?
每次有 shared_ptr 对象指向资源,引用计数器就加1;
当有 shared_ptr 对象析构时,计数器减1;
当计数器值为0时,被指向的资源将会被释放掉。
且该类型的指针可复制和可赋值,即其可用于STL容器中。此外,shared_ptr 指针可与多态类型和不完全类型一起使用。
缺点: 无法检测出循环引用,如一颗树,其中既有指向孩子结点的指针又有指向父亲结点的指针,即孩子父亲相互引用。这会造成资源无法释放,从而导致内存泄露。

weak_ptr:弱引用解决shared_ptr死循环的问题。
指向有shared_ptr 指向的资源(即其需要shared_ptr的参与,其辅助 shared_ptr 之用),但是不会导致计数。一旦计数器为0,不管此时指向资源的 weak_ptr 指针有多少,资源都会被释放。
所有的这些 weak_ptr 指针会被标记为无效状态(即 weak_ptr作为观察shared_ptr 的角色存在着,shared_ptr 不会感受到 weak_ptr 的存在)。通过函数 expired() 来检查是是否 weak_ptr 处于无效状态。

weak_ptr 在访问所引用的对象前必须先转换为 shared_ptr。
作用: weak_ptr 是用来表达临时所有权的概念:当某个对象只有存在时才需要被访问,而且随时可以被他人删除时,可以使用 weak_ptr 来跟踪该对象。需要获得临时所有权时,则将其转换为 shared_ptr ,此时若原来的 shared_ptr 被销毁,则该对象的生命周期将延长至这个临时生成的 shared_ptr 同样被销毁为止。

三、关键字作用

1、define、typdef、inline

(1)define:
简单的字符串替换,没有类型检查
在预处理阶段起作?
防?头?件重复引?
不分配内存,给出的是?即数,有多少次使?就进?多少次替换。
(2)typedef
用于定义类型别名,有对应的数据类型,是要进?判断的
在编译、运?的时候起作?
在静态存储区中分配空间,在程序运?过程中内存中只有?个拷?

两者其他区别:
define没有作用域的限制,之前预定义过的宏,在以后的程序中都可以使用,而typedef有自己的作用域。

#define INTPTR1 int*
typedef int* INTPTR2;
INTPTR1 p1, p2;  // 声明一个指针变量p1和一个整型变量p2
INTPTR2 p3, p4; //声明两个指针变量p3、p4

(3)inline:避免频繁调用的小函数大量消耗栈空间(栈内存)
将内联函数编译完成?成了函数体直接插?被调?地?,减少了压栈跳转和返回的操作。没有普通函数调?时的额外开销;
内联函数是?种特殊的函数,会进?类型检查;
对编译器的?种建议,编译器有可能拒绝这种请求;

inline编译限制:

  1. 不能存在任何形式的循环语句
  2. 不能存在过多的条件判断语句
  3. 函数体不能过于庞?
  4. 内联函数声明必须在调?语句之前,内联函数的定义放在头文件。

2、overrride和overload

**(1)overrride:**用于子类继承父类,重写父类方法。
参数列表、返回值和抛出异常与被重写方法一致。
被重写方法不能为私有private
静态方法不能重写为非静态方法
重写的访问修饰符大于被重写方法的访问修饰符。

(2)overload: 一个方法的参数形式不同
不同的参数类型如不同的参数个数、参数顺序

3、new和malloc

(1)返回状态:new失败抛出异常。malloc失败返回NULL。
(2)内存大小: new无需指出内存块大小,malloc需要指出内存尺寸大小。C++提供了new[]与delete[]来专门处理数组类型,使用new[]分配的内存必须使用delete[]进行释放;

A *ptr1 = new A
A *ptr2 = (A*)malloc(sizeof (A))
//数组
A * ptr = new A[10];//分配10个A对象
delete [] ptr;

(3)重载: operator new/operator delete可以被重载,而malloc/free并不允许重载。
(4)构造函数和析构函数: new/delete会调用对象的构造函数和析构函数,malloc不会。(5)malloc与free是标准库函数,new/delete是c++运算符。
(6)内存位置: new是从自由存储区上为对象动态分配内存空间,而malloc函数是从堆上动态分配内存。
(7)返回类型安全: new操作符内存分配成功时,返回的是对象类型的指针,类型严格与对象匹配,故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void* ,需要通过强制类型转换将void*指针转换成我们需要的类型。

4、costexpr和const区别

const 表示只读,constexpr 表示常量/常量表达式。
constexpr 只能定义编译期常量,在编译程序时可以将其结果计算出来,? const 可以定义编译期和运?期常量。
如果标记为constexpr,则同样它是const的。但相反并不成立

5、const关键字和用法

6、static关键字和用法

(1)修饰局部变量:使得被修饰的变量成为静态变量,存储在静态区。作用范围为该函数体,不同于auto变量,该变量的内存只被分配一次,
因此其值在下次调用时仍维持上次的值。变量的值不会因为函数终止而丢失

(2)修饰全局变量:改变了作用域。被static修饰的全局变量只能被包含该定义的文件内所有函数访问。只对定义在同一文件中的函数可见。
(3)修饰函数:使得函数只能在包含该函数定义的文件中被调用。对于静态函数,声明和定义需要放在同一个文件夹中。
(4)修饰类的数据成员:使其成为类的全局变量,会被类的所有对象共享,包括派生类的对象,所有的对象都只维持同一个实例。
因此,static成员必须在类外进行初始化(初始化格式:int base::var=10;),而不能在构造函数内进行初始化,不过也可以用const修饰static数据成员在类内初始化。
(5)修饰成员函数:使这个类只存在这一份函数,所有对象共享该函数,不含this指针,因而只能访问类的static成员变量。静态成员是可以独立访问的,无须创建任何对象实例就可以访问。

例如可以封装某些算法,比如数学函数,如ln,sin,tan等等,这些函数本就没必要属于任何一个对象,所以从类上调用感觉更好,比如定义一个数学函数类Math,调用Math::sin(3.14); 还可以实现某些特殊的设计模式:如Singleton;

7、extern:

extern: 声明外部变量,在函数或者文件外部定义的全局变量。

修饰全局变量: 表明该变量定义于其他翻译单元。
修饰全局常量: 表明该全局常量拥有外部链接(可以被其他翻译单元发现),否则全局常量默认是只有内部链接,即不可被其他翻译单元发现。

//file1
extern const int a = 10; //定义拥有外部链接的全局常量J
//file2
extern const int a; //声明全局常量J来自于其他翻译单元

修饰局部变量: 表明该局部变量在其他翻译单元中被定义,需要在链接的时候去解析。
对于局部变量来说,extern可用于声明该局部变量来自其他翻译单元,但是不能使用extern定义一个拥有外部链接的局部单元

void Fun()
{
	extern int a; //表明a来自于其他翻译单元
	extern int b = 10; //错误,因为局部变量b的生命周期在退出函数的时结束,不允许其建立		外部链接
}

修饰一个字符串:** 形如extern “C” 之类的用法大家肯定见过了,表明后接的代码块(或者后接的声明)使用C语言调用惯例。
修饰一个模板: 表明该模板已经在其他翻译单元实例化,不需要在这里实例化。

四、类/结构体相关

1、构造函数和析构函数调用顺序

(1)构造函数顺序:基类构造函数、对象成员构造函数、派生类本身的构造函数 。

(2)派生类本身的析构函数、对象成员析构函数、基类析构函数(与构造顺序相反)

2、虚函数用法

**定义:**在基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数,通过基类访问派生类定义的函数,实现多态性,必须是基类的非静态成员函数。
使用方法:
在基类用virtual声明成员函数为虚函数。在派生类中重新定义此函数,为它赋予新的功能。在类外定义虚函数时,不必在定义virtual。在派生类中重新定义此函数,要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同,并根据派生类的需要重新定义函数体。

虚函数表:
每个包含了虚函数的类都包含一个虚表,虚表是一个指针数组,其元素是虚函数的指针,每个元素对应一个虚函数的函数指针。虚函数指针的赋值发生在编译器的编译阶段。

同一个类的所有对象都使用同一个虚表,对象内部包含一个虚表的指针,来指向自己所使用的虚表。为了让每个包含虚表的类的对象都拥有一个虚表指针,编译器在类中添加了一个指针,*__vptr,用来指向虚表。
在这里插入图片描述

3、虚析构作用

**析构函数为什么是虚函数?**为了当用一个基类的指针删除一个派生类的对象时,派生类的析构函数会被调用。
虚函数的作用,就是用基类的指针操作对象时,能在运行时判断出对象的真正类型。 如(A为基类,B为派生类)

A * p= new B(); 
delete p; 

如果A中的析构函数为虚函数,那么delete p的时候程序就会发现p指向的是一个B的对象,然后调用B的析构函数。

如果A中的析构函数不是虚函数,那么编译器就认为p指向的是一个A的对象,然后调用A的析构函数。B中定义的部分没有被析构,造成内存泄漏。

但并不是要把所有类的析构函数都写成虚函数。只有当一个类被用来作为基类的时候,才把析构函数写成虚函数。

4、三大特性

继承
封装
多态

5、抽象类

类中至少有一个函数被声明为纯虚函数,则这个类就是抽象类。纯虚函数是通过在声明中使用 “= 0” 来指定的,如下所示:

class Box
{
public:
  	// 纯虚函数
  	virtual double getVolume() = 0;
 private:
  	double length;    
 	double width;     
};

侵权联系删除,持续更新中~

如果你对自动驾驶预测规划决策控制学习规划、科研方向、求职感兴趣,欢迎咸鱼搜索“技术咨询小店”,向我咨询。

文章来源:https://blog.csdn.net/qq_41667348/article/details/135168321
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。