C++基础

什么是野指针？

指向未分配或已释放内存的指针。比如未初始化、delete后未指向空、保存了局部变量的地址

怎么解决野指针问题？

• 使用智能指针
• 释放后置空
• 指针初始化
• 避免返回局部变量的地址

C++空类会创造那些函数？

• 默认构造
• 析构函数
• 拷贝构造
• 赋值运算符
• 取址运算符
• 移动拷贝构造
• 移动赋值运算符

C++的内存分布？

内核空间

栈空间（向下）

内存映射区（文件映射、动态库、匿名映射）

堆空间（向上）

数据段（存储全局和静态变量）

代码段 （可执行代码和数据常量）

什么是内存泄漏？什么情况会发生内存泄漏？

申请的空间没有被释放，导致这些内存不能被重用。不断累积耗尽系统内存。

• 堆上申请的空间没有释放
• 循环引用

多态是怎么实现的？

C++的多态分两种：

• 静态多态：

• • 函数重载：允许同一作用域定义多个同名函数，这些函数的参数列表不同（类型、个数、顺序）。编译期根据传入参数类型和个数在编译时期决定调用哪个函数。
  • 模板：允许写泛型代码，编译器会在实例化模板的时候生成针对特定类型的代码。类型检查和代码生成发生在编译时期。

• 动态多态：

• • 虚函数：在基类中声明函数为虚函数，允许在派生类中重写该函数，使用基类指针指向派生类对象时，通过基类指针调用虚函数会执行派生类的实现。
  • RTTI：提供了一些转换函数例如dynamic_cast，在运行时类型转换

虚函数可以内联吗？

内联是编译期的操作，虚函数实现多态是运行期的操作，如果没有实现多态的虚函数可以内联

虚函数是怎么实现的？

编译器为包含虚函数的类生成一个虚函数表，这个表是一个函数指针数组，包含了类的所有虚函数地址，每一个有虚函数的类对象都会有指向虚函数表的指针。通过这个指针找到正确的函数地址并调用

类对象是怎么找到类内函数的？

• 虚函数：通过类对象虚函数指针在虚函数表中找到
• 普通函数：在编译期就能确定调用的具体函数，因为函数地址是固定的，在链接期间将函数调用链接到具体实现上

move和forawrd?

move是将左值强制转换到右值，forawrd是完美转发，不会改变值属性

右值引用有什么作用？解决了什么问题？

减少了临时对象的拷贝，提高了运行效率。

四种强制类型转换

static_cast：基本数据类型的转换，基类和派生类的转换（不会检查安全性）

dynamic_cast：基类转化到派生类（安全检查）

const_cast：用来添加或者去除变量的const或volatile属性

reinterpret_cast:将一个指针类型转换为另一个不同类型的指针。

拷贝构造和赋值运算符都什么时间调用?

A a;
//拷贝构造
A b(a);
A c = a;

//赋值运算符
A a, b；
b = a；

源码到可执行文件的步骤？都做了什么？

预处理（处理头文件、处理宏定义、处理预处理指令、处理条件编译）

编译（语法分析、词法分析，生成中间代码）

汇编（编译为机器码）

链接（解析并连接各目标的符号（变量和函数），地址分配（给符号分配地址），库链接，生成可执行文件）

sizeof一个空类大小是多少？编译器为什么这么做？添加一个构造和析构呢？

sizeof一个空类的大小是1，为了确保每个对象有一个唯一地址，函数存储在代码段，不占用类内空间

多继承是怎么实现的？

class A : public B, public C {
};

多继承可能出现菱形继承的问题，子类重复继承积累，造成资源浪费和二义性问题。

知道虚拟继承吗？解决了什么问题？

虚拟继承:保证了基类的唯一性，避免多继承造成的资源浪费和二义性问题。虚拟继承在每个派生类创建一个虚拟基类表，用来指向它所继承的虚拟基类地址。在对象的头部创造虚拟基类表指针用来指向虚拟继承表。

class A : virtual public B, virtual public C {
};

虚拟基类指针和虚函数指针的布局？

+-------------------------+
| vptr_to_D_vtable        |  <-- 虚表指针，指向D的虚函数表
+-------------------------+
| vptr_to_A_vtable (B)    |  <-- 虚拟基类表指针，指向A的虚基表（B部分）
+-------------------------+
| int b                   |
+-------------------------+
| vptr_to_A_vtable (C)    |  <-- 虚拟基类表指针，指向A的虚基表（C部分）
+-------------------------+
| int c                   |
+-------------------------+
| int d                   |
+-------------------------+
| A::a                    |
+-------------------------+

C++的断言？

静态断言static_assert：在编译期运行，语法为static_assert(constant-expression,string-literal);如果表达式constant-expression为false，展示string-literal并且编译失败。

assert (CRT) 宏在运行时有效。它会计算用户指定的表达式，如果结果为零，系统将发出诊断消息并关闭应用程序。

STL

map的存储结构？key和value分别怎么存储？

map是以红黑树形式存储的，红黑树可以的做到在插入、查找、删除操作在最坏的情况下的时间复杂度是O(logn)。key和value

Vector初始容量和扩容机制（macos环境 Clang编译器）

初始容量是0，每次扩容是2倍，直到申请被kill

hashmap的初始容量和扩容机制？哈希冲突怎么解决？

初始容量是0，当达到负载因子的时候进行扩容，每次扩容一般是2倍（下图是clang编译期结果）。负载因子一般是1，即实际存储达到桶最大容量时会扩容。

push_back和emplace_back区别?

• push_back会先在尾部进行构造，然后通过拷贝构造或者移动构造放入
• emplace_back会在末尾直接构造，减少了一次拷贝构造或者移动构造的过程

代码优化

什么是缓存友好的代码？如何编写缓存友好的代码？

缓存友好地代码指的是，更好利用缓存特性的代码，因为程序具有局部特性。

空间局部：如果程序访问了某块内存地址，那么他将来可能访问邻近的内存地址

时间局部：如果程序访问了某块内存地址，那么他将来可能还会访问这块内存地址

怎么写缓存友好的代码？

按顺序访问数据

使用局部性好的数据结构，数组和vertor

类大小最好是缓存的整数倍，注意内存对齐

如何优化循环性能？

• 循环展开：用更多的计算，减少循环次数，适用于整数的加法和乘法。
• 前置++：使用++iter代替iter++
• 变量申请尽量放到循环之外
• 缓存容器的size

什么是函数内联（inline）？它如何影响性能？

函数内联是在编译期，将函数嵌入到调用位置，减少函数的调用，提高性能。内联函数是对编译期的一个建议，短小的函数会被内联，类内函数是有默认内联声明的

无锁编程？？？

如何优化文件I/O操作？

缓存IO：数据从磁盘拷贝到内核缓冲区，再从内核缓冲区拷贝到用户程序地址空间。

直接IO：直接访问磁盘数据，不经过内核缓冲区

内存映射：直接将内核缓冲区的数据映射到用户空间

什么是零拷贝（Zero-Copy）技术？如何在C++中实现？

零拷贝技术就是不再用户态和内核态之间拷贝数据，需要操作系统和硬件层面的支持。

解释C++中的临时对象消除（Temporary Object Elimination）？如何实现？

临时对象是，程序运行过程中生成了不可见的临时对象，对象进行了构造、析构等操作浪费性能。

返回值优化：

RVO：返回值优化，消除了返回值的临时对象（return MyClass()）。

NRVO：对RVO的补充，适用于有命名返回的情况

移动语义：通过所有权转移而不是深拷贝

emplace：直接进行构造，避免临时对象

传递参数的时候使用引用

多步骤合并，减少临时对象产生

什么是原子操作？有什么用？

原子操作（Atomic Operation）是指一个不可分割的操作，即使在多线程环境中，这些操作也不会被中断。原子操作确保在任何时刻，一个操作要么全部完成，要么完全没有进行，不会出现中间状态。

原子操作的作用

• 数据一致性：在多线程环境中，确保共享数据的一致性，避免数据竞争和竞态条件。
• 同步机制：提供一种轻量级的同步机制，避免了使用锁（mutex）带来的开销和复杂性。
• 性能提升：在某些情况下，原子操作比使用锁更高效，因为它避免了上下文切换和内核态的开销。

在C++中，原子操作主要通过<atomic>库来实现。std::atomic模板类提供了对基本数据类型的原子操作支持。

#include <iostream>
#include <atomic>
#include <thread>

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 1000; ++i) {
        ++counter;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Final counter value: " << counter << std::endl;
    return 0;
}