C++高频面试知识总结 part2

C++高频面试

1.sizeof是什么？sizeof一个class大小怎么确定？是在编译期还是在运行期确定?
2.函数重载的机制，重载是在编译期还是在运行期确定，重载有额外开销吗
3.函数重写在编译还是运行时确定？
4.如何找到虚函数表，如何找到虚函数指针
5.虚函数表存在什么内存区域上，如果一个子类没有重写虚函数，会和基类公用一个虚函数表吗？
6.虚指针在哪初始化？
7.vector扩容，插入n次远远大于当前长度，求扩容次数

1.sizeof是什么？sizeof一个class大小怎么确定？是在编译期还是在运行期确定?

1.1 sizeof是一个在C和C++等编程语言中使用的运算符，它用于获取存储在内存中某个类型或对象所占用的字节大小 。当你使用sizeof运算符时，它会返回一个size_t类型的值，这个值表示的是字节数。

1.2 对于一个类来说，其大小是在编译期间确定 的，因为编译器需要知道每个类型的确切大小以便于分配内存空间。

1.3 一个类的sizeof是由多个因素决定的，主要包括：

类中所有非静态成员变量的大小：每个成员变量都有自己的数据类型，sizeof运算符可以用来计算这些类型的字节大小，类的大小至少是这些成员变量大小的总和。

内存对齐：为了提高访问效率，许多系统会对数据进行对齐处理。例如，某些系统要求所有类型的数据按照其大小的倍数进行对齐。这意味着如果一个成员变量是一个char类型（通常是1字节），而下一个成员变量是一个double类型（通常是8字节），那么char变量后面可能会有额外的填充字节，以确保double变量按照其自身大小的倍数进行对齐。

虚函数：如果类包含虚函数，编译器会在这个类的对象中插入一个虚函数表指针（vptr） 。这个指针指向一个虚函数表，该表包含了类中所有虚函数的地址。这个额外的指针会增加类的大小。

继承：如果一个类是从其他类派生出来的，派生类的大小至少是其直接基类和间接基类 的大小加上派生类 自己添加的成员变量大小。需要注意的是，虽然派生类包含了基类的所有成员，但基类的成员不会重复计算，也就是说，派生类的大小不会是所有基类大小的简单累加。

C++类的大小------sizeof(class)

在编译期间，编译器会根据上述因素计算出一个类的总大小。这个大小是固定的，与运行时无关。因此，当你在程序中创建类的实例或将类的指针或引用传递给函数时，sizeof运算符会返回这个在编译时确定的大小。

需要注意的是，sizeof并不考虑运行时可能发生的变化，例如动态分配的内存或者对象的动态大小。它只是简单地返回在编译时确定的、存储该类型或对象所需的字节大小。

举个例子，如果你有一个简单的类定义如下：

cpp 复制代码

class MyClass {
public:
    int a;
    double b;
    char c;
};

2.函数重载的机制，重载是在编译期还是在运行期确定，重载有额外开销吗

函数重载是C++等编程语言中的一种特性，它允许在同一个作用域 中定义多个具有相同名称 但参数列表不同的函数。

函数重载的确定是在编译期间 进行的。编译器在处理函数调用时，会根据函数名和提供的参数类型 及数量来匹配对应的函数声明或定义 。也就是C++编译时多态的体现。

在函数重载的过程中，可能会涉及到以下几个方面：
参数类型匹配：编译器会检查提供的参数类型是否与函数声明中的参数类型兼容。这可能涉及到类型转换，如隐式类型转换或显式类型转换（使用static_cast等）。

参数数量匹配：函数调用必须提供正确数量的参数，与函数声明或定义中列出的参数数量相匹配。

函数参数顺序：虽然参数顺序对于函数重载的解析不是决定性因素，但在某些情况下，参数顺序可能会影响最佳匹配的判断，尤其是在存在可变形参数（如C++中的std::initializer_list）的情况下。

至于开销，函数重载本身在运行时并没有额外的执行开销 。一旦编译器在编译期间确定了调用哪个重载版本，运行时的函数调用就像调用任何其他函数一样。然而，函数重载可能会增加编译器的工作负担 ，因为它需要在多个候选函数中进行匹配 ，这可能会使得编译时间略有增加。

此外，如果重载的函数数量过多，可能会导致编译器报错，如模板实例化过多导致编译错误，或者在某些情况下，重载函数的选择可能会变得复杂，增加程序员的理解和调试难度。

3.函数重写在编译还是运行时确定？

重写(OverWrite)：重写是子类对父类 的允许访问的方法 的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

方法的重写发生在运行时 。因为在编译时，编译器是无法知道我们到底是调用父类的方法还是子类的方法，相反的，只有在实际运行的时候，我们才知道应该调用哪个方法。这个也是C++运行时多态的体现。

4.如何找到虚函数表，如何找到虚函数指针

虚函数表（vtable）是C++中实现动态多态性的关键组件之一。当你在类中声明至少一个虚函数时 ，编译器 会为该类创建一个虚函数表 ，这个表是一个存储了指向类中所有虚函数的指针的数组 。每个包含虚函数的类实例 都包含一个指向其虚函数表的指针 ，称为虚函数指针（vptr）。虚函数表在编译的时候产生，否则这个类的结构信息中也不会插入虚指针的地址信息。

虚函数表指针是虚函数表所在位置的地址。虚函数表指针属于对象实例。因而通过new 出来的对象的虚函数表指针位于堆，声明对象的虚函数表指针位于栈
虚函数表位于只读数据段 （.rodata），即：C++内存模型中的常量区
虚函数代码则位于代码段 （.text），也就是C++内存模型中的代码区

C++类的虚函数表和虚函数在内存中的位置

对于这种简单的类，其对象内存布局的最开始四个字节 就是一个虚函数表指针 （32位编译器），而这个指针变量的值 自然就是虚函数表的地址了。

这里指针操作比较混乱,在此稍微解析下:

&father代表对象b的起始地址
(int *)&father 强转成int *类型,为了后面取b对象的前四个字节 ,前四个字节是虚表指针
*(int *)&father 取前四个字节,即vptr虚表地址

根据上面的解析我们知道*(int *)&father即虚表地址.并且虚表是存放虚函数指针的，所以虚表中每个元素(虚函数指针)在32位编译器下是4个字节,因此(int *)*(int *)&father，这样强转后为了后面的取四个字节.所以*(int *)*(int *)&father就是虚表的第一个元素，即FatherFun1()的地址，那么接下来的取第二个虚函数地址也就依次类推. 始终记着vptr 指向的是一块内存, 这块内存存放着虚函数地址 ,这块内存就是我们所说的虚表.

cpp 复制代码

*(int *)&father

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

class Father
{
	virtual void FatherFun1() {cout << "FatherFun1" <<endl;}
	virtual void FatherFun2() {cout << "FatherFun2" <<endl;}
	virtual void FatherFun3() {cout << "FatherFun3" <<endl;}
};

typedef void (*Fun)(void);

int main()
{
	Father father;
	cout << "类对象地址：" << &father << endl;
	cout << "虚函数表地址: " << (int*)*(int*)&father << endl;
	cout << "虚函数FatherFun1地址：" <<(int*)*(int*)&father << endl;
	cout << "虚函数FatherFun2地址：" <<(int*)*(int*)&father + 1 << endl;
	cout << "虚函数FatherFun3地址：" <<(int*)*(int*)&father + 2 << endl;

	cout << "测试地址是否正确" << endl;
	Fun fun = (Fun)*(int*)*(int*)&father;
	fun();
	fun = (Fun)*((int*)*(int*)(&father) + 1);
	fun();
	fun = (Fun)*((int*)*(int*)(&father) + 2);
	fun();

	system("pause");
}

cpp 复制代码

类对象地址：003BF90C
虚函数表地址: 00867898
虚函数FatherFun1地址：00867898
虚函数FatherFun2地址：0086789C
虚函数FatherFun3地址：008678A0
测试地址是否正确
FatherFun1
FatherFun2
FatherFun3
请按任意键继续. . .

从这个输出我们可以看到，FatherFun1、FatherFun2、FatherFun3的地址只差了4个字节，且输出是正确的，那么第三点已确认！

5.虚函数表存在什么内存区域上，如果一个子类没有重写虚函数，会和基类公用一个虚函数表吗？

虚函数表（vtable）通常存储在程序的只读数据段 （也称为代码段或文本段）中。这个区域是用于存储程序执行时不可变的数据，例如代码本身、字符串常量以及其他只读数据。虚函数表作为类的一部分，包含了指向类中所有虚函数的指针，因此需要被保护起来，以防止程序运行时被意外修改。

那么在有继承情况下 ，只要基类有虚函数 ，子类不论实现或没实现，都有虚函数表。虚表里面存放的是父类的虚函数指针。
基类的虚函数表 和子类的虚函数表不是同一个表。

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
class CTest
{
public:
	CTest() {};
	~CTest() {};
	virtual void SFunc() {
		cout << "测试虚函数" << endl;
	};
private:
	int a;
	short b;
};

class CTestC : public CTest
{
public:
	CTestC() { m_iValueC = 0; };
	~CTestC() {};

private:
	int m_iValueC;
};

typedef void(*Fun)(void);  //函数指针 
int main()
{
	CTest t;
	printf("CTest 虚表地址:%p\n", *(int *)&t);

	CTestC t0;
	printf("CTestC 虚表地址:%p\n", *(int *)&t0 );

	return 0;
}

bash 复制代码

[root@iZ2zeirmyddvdjh8g2zyxzZ virtual]# ./v
CTest 虚表地址:0x402088
CTestC 虚表地址:0x402070

虚函数表构成、地址详细说明

6.虚指针在哪初始化？

由于每个对象调用的虚函数都是通过虚表指针 来索引的，也就决定了虚表指针的正确初始化是非常重要的。换句话说，在虚表指针没有正确初始化之前 ，我们不能够去调用虚函数。那么虚表指针在什么时候，或者说在什么地方初始化呢？

答案是在构造函数中进行虚表的创建和虚表指针的初始化。

构造函数的调用顺序，在构造子类对象 时，要先调用父类的构造函数 ，之后再完成子类的构造 。在调用父类的构造函数时，编译器只"看到了"父类，并不知道后面是否后还有继承者，它初始化虚表指针 ，将该虚表指针指向父类的虚表 。

当执行子类的构造函数 时，虚表指针被重新赋值 ，指向自身的虚表。

7.vector扩容，插入n次远远大于当前长度，求扩容次数

1.扩容机制回顾

当向vector中插入元素时，如果元素有效个数size 与空间容量capacity相等时，vector内部会触发扩容机制：

开辟新空间
拷贝元素
释放旧空间。

注意：每次扩容新空间不能太大，也不能太小，太大容易造成空间浪费，太小则会导致频繁扩容而影响程序效率。

2.选择以倍数方式扩容

假设有n个元素需要像vector插入，倍增因子为m,则完成n个元素像vector的push_back操作需要扩容log以m为低n的次方 。比如：以二倍方式扩容，当向vector插入1000 个元素，需要扩容log以2为底1000次方，就是扩容10次，第i次增容会把m的i次方个元素搬移到新空间 ，n次push_back的总操作次数为：

使用2倍（k=2）扩容机制扩容时，每次扩容后的新内存大小必定大于前面的总和 。

而使用1.5倍（k=1.5)扩容时，在几次扩展以后，可以重用之前的内存空间了。

因为STL标准并没有严格说明需要按何种方式进行扩容，因此不同的实现厂商都是按照自己的方式扩容的，即：linux下是按照2倍 的方式扩容的，而vs下是按照1.5倍 的方式扩容的。