C++面试总结之C++语言特性（二）_c++ should be initialized-优快云博客

本文链接：https://blog.youkuaiyun.com/lxin_liu/article/details/89309085

本文总结了C++面试中的重要知识点，包括New与malloc的区别、文件删除后的内存恢复、内存分配方式、堆栈特性、==与equals的区别、右值引用、全局与局部变量、Auto关键字、lambda函数实现及函数对象的原理，以及指针、多线程场景和assert的使用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. New和malloc都能创建新的对象，区别在哪？哪个效率高

（1） malloc/free是C++的标准库函数，new/delete是运算符

（2）不能将执行构造函数和析构函数的任务强加给malloc/free，只能用new/delete

（3） New返回指定类型的指针，malloc返回空指针再进行类型转换

（4） new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。

（5） new内存分配失败时，会抛出bad_alloc异常，它不会返回NULL；malloc分配内存失败时返回NULL。

（6）使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算，而malloc则需要显式地指出所需内存的尺寸。

（7） operator new /operator delete的实现可以基于malloc，而malloc的实现不可以去调用new。

void *operator new(size_t); //allocate an object 
void operator delete(void ); //free an object
void *operator new; //allocate an array 
void operator delete[](void ); //free an array

前面两个均是 C++ 标准库函数， C++ Primer 一书上说这不是重载 new 和 delete 表达式（如 operator= 就是重载 = 操作符），因为 new 和 delete 是不允许重载的。这两个函数和malloc/free 函数有点像了，都是用来申请和释放内存的，并且 operator new 申请内存之后不对内存进行初始化，直接返回申请内存的指针。

2. 文件存储，文件删除了内存里面还有木有，能不能找回来

有，可以找回

3. 内存分配（腾讯内推）

（1）内存分配方式有三种：

[1] 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量, static 变量。

[2] 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

[3] 从堆上分配，亦称动态内存分配。程序在运行的时候用 malloc 或 new 申请任意多少的内存，程序员自己负责在何时用 free 或 delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但如果在堆上分配了空间，就有责任回收它，否则运行的程序会出现内存泄漏，频繁地分配和释放不同大小的堆空间将会产生堆内碎块。

（2）程序的内存空间：

代码区 (code area) ：程序内存空间

全局数据区 (data area)

堆区 (heap area)

栈区 (stack area)

（3）一个由 C/C++ 编译的程序占用的内存分为以下几个部分：

[1]栈区（ stack ）由编译器自动分配释放，存放为运行函数而分配的局部变量、函数参数、返回数据、返回地址等。其操作方式类似于数据结构中的栈。

[2]堆区（ heap ）一般由程序员分配释放，若程序员不释放，程序结束时可能由 OS 回收。分配方式类似于链表。

[3]全局区（静态区）（ static ）存放全局变量、静态数据、常量。程序结束后有系统释放

[4]文字常量区: 常量字符串就是放在这里的。程序结束后由系统释放。

4. 堆与栈的比较（腾讯实习内推）:

[1]申请方式: stack由系统自动分配。heap需要程序员自己申请，并指明大小。堆:频繁new/delete会造成内存空间的不连续，造成大量的碎片，程序效率降低

[2]申请后系统的响应:栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。（伙伴算法、SLAB算法）

[3]申请大小的限制: 堆向着内存地址增加的方向；栈是向着内存地址减小的方向增长。栈：在 Windows 下 , 栈是由高向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，能从栈获得的空间较小。堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

[4]申请效率的比较: 栈由系统自动分配，速度较快。但程序员是无法控制的。

堆是由 new 分配的内存，一般速度比较慢，而且容易产生内存碎片 , 不过用起来最方便。

5. ==和equals区别

==是一个逻辑运算符，判断两个值是否相等，而对于对象的引用来说，它的值就是它的指向；而equals()方法是一个普通的方法，它里面包含了自定义比较的成份，也就是说，你可以定义你自己的相等的标准，而不一定是比较引用的指向.

6. 右值引用的概念

作用：右值引用引用的是寄存器

（1）消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。

（2）能够更简洁明确地定义泛型函数

https://www.cnblogs.com/qicosmos/p/4283455.html（经典）

7.全局变量和局部变量有什么区别，是怎么实现的？操作系统和编译器是怎么知道的？

8. Auto关键字

1. 直观地，auto的一个最大的优势在于简化代码。由于C++的发展，变量类型变得越来越复杂。但是很多时候，名字空间、模板成为类型的一部分，导致了程序员在使用库的时候如履薄冰。

2. 可以避免类型声明时的麻烦而且避免类型声明时的错误。

使用时应该注意：

①可以使用valatile，pointer（*），reference（&），rvalue reference（&&）来修饰auto

1. auto k = 5;

2. auto* pK = new auto(k);

3. auto** ppK = new auto(&k);

4. const auto n = 6;

②用auto声明的变量必须初始化

auto m; // m should be intialized

③auto不能与其他类型组合连用

auto int p; // 这是旧auto的做法。

④函数和模板参数不能被声明为auto

1. void MyFunction(auto parameter){} // no auto as method argument

2. template<auto T> // utter nonsense - not allowed

3. void Fun(T t){}

⑤定义在堆上的变量，使用了auto的表达式必须被初始化

1. int* p = new auto(0); //fine

2. int* pp = new auto(); // should be initialized

3. auto x = new auto(); // Hmmm ... no intializer

4. auto* y = new auto(9); // Fine. Here y is a int*

5. auto z = new auto(9); //Fine. Here z is a int* (It is not just an int)

⑥auto是一个占位符，并不是一个他自己的类型，因此不能用于类型转换或其他一些操作，如sizeof和typeid

1. int value = 123;

2. auto x2 = (auto)value; // no casting using auto

3. auto x3 = static_cast<auto>(value); // same as above

⑦定义在一个auto序列的变量必须始终推导成同一类型

1. auto x1 = 5, x2 = 5.0, x3='r'; // This is too much....we cannot combine like this

⑧auto不能自动推导成CV-qualifiers（constant & volatile qualifiers），除非被声明为引用类型

1. const int i = 99;

2. auto j = i; // j is int, rather than const int

3. j = 100 // Fine. As j is not constant

4. // Now let us try to have reference

5. auto& k = i; // Now k is const int&

6. k = 100; // Error. k is constant

7. // Similarly with volatile qualifer

⑨auto会退化成指向数组的指针，除非被声明为引用

1. int a[9];

2. auto j = a;

3. cout<<typeid(j).name()<<endl; // This will print int*

4. auto& k = a;

5. cout<<typeid(k).name()<<endl; // This will print int [9]

9. C++的lambda函数实现原理

原理：编译器会把一个lambda表达式生成一个匿名类的匿名对象，并在类中重载函数调用运算符。

（1）无捕获列表和参数列表

auto print = []{cout << "zhangxiang" << endl; };

编译器会把这一句翻译成如下情形：

//用给定的lambda表达式生成相应的类  

class print_class{  
    public:  
        void operator()(void) const {  
            cout << "zhangxiang" << endl;  
        }  
};  

//用构造的类创建对象，print此时就是一个函数对象  
auto print = print_class();

（2）无捕获列表但有参数列表

auto add = [](int a, int b){return a + b; };

编译器会把这一句翻译成如下情形：

class add_class  {  
    public:  
        auto operator()(int a, int b) const   {  
            return a + b;  
        }  
};  

auto add = add_class();

（3）有捕获列表，参数列表可选

由于捕获方式分为两种：引用捕获、值捕获。

A. 值捕获

int year = 19900212;  
char *name = "zhangxiang";  

//采用值捕获，捕获所有的已定义的局部变量，如year，name  
auto print = [=](){  
    cout << year << ends << name << endl;  
};

编译器会把这一句翻译成如下情形：

int year = 19900212;  
char *name = "zhangxiang";  
class print_class  {  
    public:  
        //根据捕获列表来决定构造函数的参数列表形式  
        print_class(int year, char *name) :year(year), name(name)   {  
        }  

        void operator()(void) const   {  
            cout << year << ends << name << endl;  
        }  

    private:  
        int year;  
        char *name;  
};  

auto print = print_class(a, str);

B.引用捕获

int year = 19900212;  
char *name = "zhangxiang";  
auto print = [&](){  
    year++;  
    cout << year << ends << name << endl;  
};

编译器会把这一句翻译成如下情形：

int year = 19900212;  
char *name = "zhangxiang";  

class print_class  {  
    public:  
        //由于是引用捕获，参数列表采用引用的方式  
        print_class(int &year, char *&name) :year(year), name(name)    {  
        }  

        void operator()(void) const   {     
            year++;   //编译通过，const对引用类型无效  
            cout << year << ends << name << endl;  
        }  
    private:  
        int &year;  
        char *&name;  
};

C. 混合捕获

int year = 19900212;  
int shoes = 42;  
char *name = "zhangxiang";  

auto show = [&, shoes]()mutable{  
    shoes++;  
    year++;  
    cout << year << ends << shoes << ends << name << endl;  
};

编译器会把这一句翻译成如下情形：

int year = 19900212;  
int shoes = 42;  
char *name = "zhangxiang";  

class show_class  {  
    private:  
        int &year;  
        mutable int shoes;  
        char *&name;  
public:  
    show_class(int &year, int shoes, char *&name) :year(year), shoes(shoes), name(name)  {  
    }  
    void operator()(void)const{  
        shoes++;  
        year++;  
        cout << year << ends << shoes << ends << name << endl;  
    }  
};  

auto show = show_class(year, shoes, name);  
show();

默认情况下，经过值捕获的变量是不可以被修改的，除非在参数列表后加关键字mutable。以上代码展示了，对应类中mutable是如何加的。当然还有另一种实现方法，只要lambda表达式加了mutable，重载函数调用运算符时就不加const修饰。

10. C++的函数对象是如何实现的

类的对象跟括号结合，表现出函数一般的行为，这个对象可以称作是函数对象(类重载了()运算符)。引到Lambda

#include <iostream>  
using namespace std;  

class MyClass  {  
    public:  
        //重载函数调用运算符()  
        int operator()(int i)  {  
            return i;  
        }  
};  

int main() {  
    MyClass my;  
    //my()的调用行为似同函数  
    int i = my(1);     //本质是调用 my.operator()(1)  
    cout << "i = " << i << endl;  
    cin.get();  
    return 0;  
}