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

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

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位编译器），而这个指针变量的值自然就是虚函数表的地址了。

这里指针操作比较混乱,在此稍微解析下:
1. &father代表对象b的起始地址
2. (int *)&father 强转成int *类型,为了后面取b对象的前四个字节,前四个字节是虚表指针
3. *(int *)&father 取前四个字节,即vptr虚表地址

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

*(int *)&father

#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");
}

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

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

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

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

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

#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;
}

[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倍的方式扩容的。