目录

1.part1 C++基础

1 C++特点

2 说说C语言和C++的区别

3 说说 C++中 struct 和 class 的区别

4 include头文件的顺序以及双引号""和尖括号<>的区别

5 说说C++结构体和C结构体的区别

6 导入C函数的关键字是什么，C++编译时和C有什么不同？

7 C++从代码到可执行二进制文件的过程

8 说说 static关键字的作用

9 数组和指针的区别

10 说说什么是函数指针，如何定义函数指针，有什么使用场景

11 静态变量什么时候初始化？

12 nullptr调用成员函数可以吗？为什么？

13 说说什么是野指针，怎么产生的，如何避免

14 说说静态局部变量，全局变量，局部变量的特点，以及使用场景

15 说说内联函数和宏函数的区别

17 说说new和malloc的区别，各自底层实现原理。

18 说说const和define的区别。

19 说说C++中函数指针和指针函数的区别。

20 说说const int *a, int const *a, const int a, int *const a, const int *const a分别是什么，有什么特点。

21 说说使用指针需要注意什么？

22 说说内联函数和函数的区别，内联函数的作用。

23 简述C++有几种传值方式，之间的区别是什么？

24 简述const（星号）和（星号）const的区别

2.C++内存 

1 简述堆和栈的区别

2 简述C++的内存管理

3. 内存泄露及解决办法：

3 malloc和局部变量分配在堆还是栈？

4 程序有哪些section，分别的作用？程序启动的过程？怎么判断数据分配在栈上还是堆上？

5 初始化为0的全局变量在bss还是data

6 简述C++中内存对齐的使用场景

3 面向对象

1 简述一下什么是面向对象

2 简述一下面向对象的三大特征

3简述一下 C++ 的重载和重写，以及它们的区别

4 说说 C++ 的重载和重写是如何实现的

5 说说构造函数有几种，分别什么作用

6 只定义析构函数，会自动生成哪些构造函数

7 说说一个类，默认会生成哪些函数

8 说说 C++ 类对象的初始化顺序，有多重继承情况下的顺序

9 简述下向上转型和向下转型

10 简述下深拷贝和浅拷贝，如何实现深拷贝

11 简述一下 C++ 中的多态

12 说说为什么要虚析构，为什么不能虚构造

14 说说类继承时，派生类对不同关键字修饰的基类方法的访问权限

15 简述一下移动构造函数，什么库用到了这个函数？

16 构造函数为什么不能被声明为虚函数？

17 简述一下什么是常函数，有什么作用

18 说说什么是虚继承，解决什么问题，如何实现？

19 简述一下虚函数和纯虚函数，以及实现原理

21 说说C++中虚函数与纯虚函数的区别

22 说说 C++ 中什么是菱形继承问题，如何解决？

23 请问构造函数中的能不能调用虚方法

24 请问拷贝构造函数的参数是什么传递方式，为什么

25 如何理解抽象类？

26 什么是多态？除了虚函数，还有什么方式能实现多态？

27 简述一下虚析构函数，什么作用

28 说说什么是虚基类，可否被实例化？

29 简述一下拷贝赋值和移动赋值？

30 仿函数了解吗？有什么作用

31 C++ 中哪些函数不能被声明为虚函数？

32 解释下 C++ 中类模板和模板类的区别

32 虚函数表里存放的内容是什么时候写进去的？

1.part1 C++基础

1 C++特点

2 说说C语言和C++的区别

3 说说 C++中 struct 和 class 的区别

4 include头文件的顺序以及双引号""和尖括号<>的区别

5 说说C++结构体和C结构体的区别

6 导入C函数的关键字是什么，C++编译时和C有什么不同？

int func(int a);
int (*f)(int a);
f = &func;

指针函数：int *fun(int x,int y);
函数指针：int (*fun)(int x,int y);

int* createArray(int size) {
    int* arr = (int*)malloc(size * sizeof(int));
    // 对 arr 进行初始化或其他操作
    return arr;
}

nt (*operation)(int, int); // 函数指针的声明
operation = &add; // 将函数指针指向 add 函数
int result = operation(3, 4); // 调用 add 函数进行计算

1. const int a; //指的是a是一个常量，不允许修改。
2. const int *a; //a指针所指向的内存里的值不变，即（*a）不变
3. int const *a; //同const int *a;
4. int *const a; //a指针所指向的内存地址不变，即a不变
5. const int *const a; //都不变，即（*a）不变，a也不变

2.C++内存 

1 简述堆和栈的区别

2 简述C++的内存管理

1. 内存分配方式 ：

在 C++ 中，内存分成 5 个区，他们分别是 堆、栈、自由存储区、全局 / 静态存储区和常量存储区 。

栈 ，在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元

自动被释放。

堆 ，就是那些由 new 分配的内存块，一般一个 new 就要对应一个 delete 。

自由存储区 ，就是那些由 malloc 等分配的内存块，和堆是十分相似的，不过是用 free 来结束自己的

生命。

全局 / 静态存储区 ，全局变量和静态变量被分配到同一块内存中

常量存储区 ，这是一块比较特殊的存储区，里面 存放的是常量，不允许修改。

2. 常见的内存错误及其对策 ：

（1）内存分配未成功，却使用了它。

（2）内存分配虽然成功，但是尚未初始化就引用它。

（3）内存分配成功并且已经初始化，但操作越过了内存的边界。

（4）忘记了释放内存，造成内存泄露。

（5）释放了内存却继续使用它。

对策：

（1）定义指针时，先初始化为 NULL 。

（2）用 malloc 或 new 申请内存之后，应该 立即检查 指针值是否为 NULL 。防止使用指针值为 NULL

的内存。

（3）不要忘记为数组和动态内存 赋初值 。防止将未被初始化的内存作为右值使用。

（4）避免数字或指针的下标 越界 ，特别要当心发生 “ 多 1” 或者 “ 少 1” 操作

（5） 动态内存的申请与释放必须配对，防止 内存泄漏

（6） 用 free 或 delete 释放了内存之后，立即将指针 设置为 NULL ，防止 “ 野指针 ”

（7）使用智能指针。

3. 内存泄露及解决办法：

什么是内存泄露？

简单地说就是 申请了一块内存空间，使用完毕后没有释放掉 。

（1） new 和 malloc 申请资源使用后，没有用 delete 和 free 释放；

（2）子类继承父类时，父类析构函数不是虚函数。

（3） Windows 句柄资源使用后没有释放。

怎么检测？

第一： 良好的编码习惯，使用了内存分配的函数，一旦使用完毕 , 要记得使用其相应的函数释放掉 。

第二： 将分配的内存的指针以链表的形式自行管理 ，使用完毕之后从链表中删除，程序结束时可检 查改链表。

第三： 使用智能指针。

第四：一些常见的工具插件，如 ccmalloc 、 Dmalloc 、 Leaky 、 Valgrind 等等。

3 malloc和局部变量分配在堆还是栈？

malloc 是在 堆上分配内存 ，需要程序员自己回收内存；局部变量是在 栈中分配内存 ，超过作用域就自动回收。

4 程序有哪些section，分别的作用？程序启动的过程？怎么判断数据分配在栈上还是堆上？

一个程序有哪些 section ：

如上图， 从低地址到高地址，一个程序由代码段、数据段、 BSS 段组成。

1. 数据段： 存放程序中 已初始化的 全局变量和静态变量的一块内存区域。

2. 代码段： 存放程序执行代码的一块内存区域。只读，代码段的头部还会包含一些只读的常数变量。

3. BSS 段：存放程序中 未初始化的 全局变量和静态变量的一块内存区域。

4. 可执行程序在运行时又会多出两个区域：堆区和栈区。

堆区： 动态申请内存用。堆从低地址向高地址增长。

栈区： 存储局部变量、函数参数值。栈从高地址向低地址增长。是一块连续的空间。

5. 最后还有一个 文件映射区 ，位于堆和栈之间。 堆 heap ：由 new 分配的内存块，其释放由程序员控制（一个 new 对应一个 delete ）

栈 stack ：是那些编译器在需要时分配，在不需要时自动清除的存储区。存放局部变量、函数参数。

常量存储区 ：存放常量，不允许修改。

程序启动的过程：

1. 操作系统 首先创建相应的进程并分配私有的进程空间 ，然后操作系统的 加载器负责把可执行文件的

数据段和代码段映射到进程的虚拟内存空间中。

2. 加载器读入可执行程序的导入符号表 ，根据这些符号表可以查找出该可执行程序的所有依赖的动态

链接库。

3. 加载器针对该程序的每一个动态链接库调用 LoadLibrary

（1）查找对应的动态库文件，加载器为该动态链接库确定一个合适的基地址。

（2）加载器读取该动态链接库的导入符号表和导出符号表，比较应用程序要求的导入符号是否匹

配该库的导出符号。

（3）针对该库的导入符号表，查找对应的依赖的动态链接库，如有跳转，则跳到 3

（4）调用该动态链接库的初始化函数

4. 初始化应用程序的全局变量，对于全局对象自动调用构造函数 。

5. 进入应用程序入口点函数开始执行。

怎么判断数据分配在栈上还是堆上：

首先局部变量分配在栈上；而通过 malloc 和 new 申请的空间是在堆上。

5 初始化为0的全局变量在bss还是data

BSS 段通常是指用来存放程序中 未初始化的或者初始化为 0 的 全局变量和静态变量的一块内存区域。特点是可读写的， 在程序执行之前 BSS 段会自动清 0 。

6 简述C++中内存对齐的使用场景

内存对齐应用于三种数据类型中： struct/class/union

struct/class/union 内存对齐原则有四个：

1. 数据成员对齐规则 ：结构 (struct) 或联合 (union) 的数据成员， 第一个数据成员放在 offset 为 0 的地

方 ，以后每个数据成员存储的 起始位置要从该成员大小或者成员的子成员大小的整数倍开始 。

2. 结构体作为成员 : 如果一个结构里有某些结构体成员 , 则结构体成员要从其 内部 " 最宽基本类型成

员 " 的整数倍地址开始存储。 (struct a 里存有 struct b,b 里有 char,int ,double 等元素 , 那 b 应该从 8 的

整数倍开始存储 ) 。

3. 收尾工作 : 结构体的总大小，也就是 sizeof 的结果， 必须是其内部最大成员的 " 最宽基本类型成员 " 的

整数倍。不足的要补齐。 ( 基本类型不包括 struct/class/uinon) 。

4. sizeof(union) ，以结构里面 size 最大元素为 union 的 size ，因为在某一时刻， union 只有一个成员真

正存储于该地址。

 什么是内存对齐？

那么什么是字节对齐？在 C 语言中，结构体是一种复合数据类型，其构成元素既可以是基本数据类型 （如int 、 long 、 float 等）的变量，也可以是一些复合数据类型（如数组、结构体、联合体等）的数据单 元。在结构体中，编译器为结构体的每个成员按其自然边界（ alignment ）分配空间。 各个成员按照它 们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构体的地址相同。

为了使 CPU 能够对变量进行快速的访问，变量的起始地址应该具有某些特性， 即所谓的 “ 对齐 ” ，比如 4 字 节的 int 型，其起始地址应该位于 4 字节的边界上，即起始地址能够被 4 整除 ，也即 “ 对齐 ” 跟数据在内存中 的位置有关。如果一个变量的内存地址正好位于它长度的整数倍，他就被称做自然对齐。

为什么要字节对齐？

为了快速准确的访问，若没有字节对齐则会出现多次访问浪费时间。

举例说明（定义一个 char 和 int 型数据不按照字节对齐存储的情况需要多次访问）

3 面向对象

1 简述一下什么是面向对象

1. 面向对象是一种编程思想，把一切东西看成是一个个对象 ，把这些对象拥有的属性变量和操作这些 属性变量的函数打包成一个类来表示

2. 面向过程和面向对象的区别

面向过程：根据业务逻辑从上到下写代码

面向对象： 将数据与函数绑定到一起，进行封装 ，加快开发程序，减少重复代码的重写过程。

2 简述一下面向对象的三大特征

  面向对象的三大特征是 封装、继承、多态

1. 封装： 将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互。 封装 本质上是一种管理 ，不想给别人看到的，我们使用 protected/private 把成员

封装起来。开放一些共有的成员函数对成员合理的访问。

2. 继承： 可以使用现有类的所有功能 ，并在无需重新编写原来的类的情况下对这些功能进行扩展。

三种继承方式。

3. 多态： 用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数 。实现多态，有二种方式， 重写，重载 。

 

3简述一下 C++ 的重载和重写，以及它们的区别

1. 重写

是指 派生类中存在重新定义的函数。其函数名，参数列表，返回值类型，所有都必须同基类中被重

写的函数一致。只有函数体不同（花括号内） ，派生类对象调用时会调用派生类的重写函数，不会

调用被重写函数。重写的基类中被重写的函数必须有 virtual 修饰。

#include<bits/stdc++.h>
using namespace std;
class A
{
public:
virtual void fun()
{
cout << "A";
}
};
class B :public A
{
public:
virtual void fun()
{
cout << "B";
}
};
int main(void)
{
A* a = new B();
a->fun();//输出B，A类中的fun在B类中重写
}

1. 重载

我们在平时写代码中会用到几个函数但是他们的实现功能相同，但是有些细节却不同。 函数重载是

指同一可访问区内被声明的几个具有不同参数列（参数的类型，个数，顺序不同）的同名函数，根

据参数列表确定调用哪个函数，重载不关心函数返回类型。

#include<bits/stdc++.h>
using namespace std;
class A
{
void fun() {};
void fun(int i) {};
void fun(int i, int j) {};
void fun1(int i,int j){};
};

4 说说 C++ 的重载和重写是如何实现的

1. 重载： C++ 利用命名倾轧（ name mangling ）技术，来改名函数名，区分参数不同的同名函数。命 名倾轧是在编译阶段完成的。 编译时将参数类型加入以区分不同。

2. 重写： 在 基类的函数前加上 virtual 关键字，在派生类中重写该函数，运行时将会根据对象的实际类 型来调用相应的函数 。如果 对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调 用基类的函数。

虚函数需要注意的地方：

用 virtual 关键字申明 的函数叫做虚函数，虚函数肯定是类的成员函数。 存在虚函数的类都有一个一维的虚函数表叫做虚表 ， 类的对象有一个指向虚表开始的虚指针。 虚表是和类对应的，虚表指针是和对象对应的。 多态性是一个接口多种实现 ，是面向对象的核心，分为类的多态性和函数的多态性。 重写用虚函数来实现，结合动态绑定 。 纯虚函数 是虚函数再加上 = 0 。 抽象类 是指包括至少一个 纯虚函数的类 。

纯虚函数： virtual void fun()=0 。即抽象类 必须在子类实现这个函数，即先有名称，没有内容 ，在

派生类实现内容。

5 说说构造函数有几种，分别什么作用

C++ 中的构造函数可以分为 4 类：默认构造函数、初始化构造函数、拷贝构造函数、移动构造函数。 1. 默认构造函数和初始化构造函数。 在定义类的对象的时候，完成对象的初始化工作。

注意： 有了有参的构造了，编译器就不提供默认的构造函数。

class Student
{
public:
//默认构造函数
Student()
{
num=1001;
age=18;
}
//初始化构造函数
Student(int n,int a):num(n),age(a){}
private:
int num;
int age;
};
int main()
{
//用默认构造函数初始化对象S1
Student s1;
//用初始化构造函数初始化对象S2
Student s2(1002,18);
return 0;
}

2. 拷贝构造函数

        

#include "stdafx.h"
#include "iostream.h"
class Test
{
int i;
int *p;
public:
Test(int ai,int value)
{
i = ai;
p = new int(value);
}
~Test()
{
delete p;
}
Test(const Test& t)
{
this->i = t.i;
this->p = new int(*t.p);
}
};
//复制构造函数用于复制本类的对象
int main(int argc, char* argv[])
{
Test t1(1,2);
Test t2(t1);//将对象t1复制给t2。注意复制和赋值的概念不同
return 0;
}

赋值构造函数默认实现的是值拷贝（浅拷贝） 。

3. 移动构造函数。用于将其他类型的变量，隐式转换为本类对象。 下面的转换构造函数，将 int 类型的 r转换为 Student 类型的对象，对象的 age 为 r ， num 为 1004.

Student(int r)
｛
int num=1004；
int age= r；
｝

6 只定义析构函数，会自动生成哪些构造函数

只定义了析构函数，编译器将自动为我们生成 拷贝构造函数和默认构造函数 。

默认构造函数和初始化构造函数。 在定义类的对象的时候，完成对象的初始化工作。

class Student
{
public:
//默认构造函数
Student()
{
num=1001;
age=18;
}
//初始化构造函数
Student(int n,int a):num(n),age(a){}
private:
int num;
int age;
};
int main()
{
//用默认构造函数初始化对象S1
Student s1;
//用初始化构造函数初始化对象S2
Student s2(1002,18);
return 0;
}

 有了有参的构造了，编译器就不提供默认的构造函数。拷贝构造函数

#include "stdafx.h"
#include "iostream.h"
class Test
{
int i;
int *p;
public:
Test(int ai,int value)
{
i = ai;
p = new int(value);
}
~Test()
{
delete p;
}
Test(const Test& t)
{
this->i = t.i;
this->p = new int(*t.p);
}
};
//复制构造函数用于复制本类的对象
int main(int argc, char* argv[])
{
Test t1(1,2);
Test t2(t1);//将对象t1复制给t2。注意复制和赋值的概念不同。
return 0;
}

class HasPtr
{
public:
HasPtr(const string& s = string()) :ps(new string(s)), i(0) {}
~HasPtr() { delete ps; }
private:
string * ps;
int i;
};

HasPtr f(HasPtr hp)
{
HasPtr ret = hp;
///... 其他操作
return ret;
}

class Empty
{
};

Empty()
{
}

Empty(const Empty& copy)
{
}

Empty& operator = (const Empty& copy)
{
}

~Empty()
{
}

include<iostream>
using namespace std;
int Add(int a,int b)//1
{
return a+b;
}
char Add(char a,char b)//2
{
return a+b;
}
int main()
{
cout<<Add(666,888)<<endl;//1
cout<<Add('1','2');//2
return 0;
}

#include <iostream>
using namespace std;
// #1 模板定义
template<class T>
struct TemplateStruct
{
TemplateStruct()
{
cout << sizeof(T) << endl;
}
};
// #2 模板显示实例化
template struct TemplateStruct<int>;
// #3 模板具体化
template<> struct TemplateStruct<double>
{
TemplateStruct() {
cout << "--8--" << endl;
}
};
int main()
{
TemplateStruct<int> intStruct;
TemplateStruct<double> doubleStruct;
// #4 模板隐式实例化
TemplateStruct<char> llStruct;
}

#include<iostream>
using namespace std;
class CStu
{
public:
int a;
CStu()
{
a = 12;
}
void Show() const
{
//a = 13; //常函数不能修改数据成员
cout <<a << "I am show()" << endl;
}
};
int main()
{
CStu st;
st.Show();
system("pause");
return 0;
}

#include<iostream>
using namespace std;
class A{
public:
int _a;
};
class B :virtual public A
{
public:
int _b;
};
class C :virtual public A
{
public:
int _c;
};
class D :public B, public C
{
public:
int _d;
};
//菱形继承和菱形虚继承的对象模型
int main()
{
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
cout << sizeof(D) << endl;
return 0;
}

class Person{
public:
//虚函数
virtual void GetName(){
cout<<"PersonName:xiaosi"<<endl;
};
};
class Student:public Person{
public:
void GetName(){
cout<<"StudentName:xiaosi"<<endl;
};
};
int main(){
//指针
Person *person = new Student();
//基类调用子类的函数
person->GetName();//StudentName:xiaosi
}

//抽象类
class Person{
public:
//纯虚函数
virtual void GetName()=0;
};
class Student:public Person{
public:
Student(){
};
void GetName(){
cout<<"StudentName:xiaosi"<<endl;
};
};
int main(){
Student student;
}

class Base
{
public:
virtual void func() = 0;
};
#include<iostream>
using namespace std;
class Base
{
public:
virtual void func() = 0;
};
class Derived :public Base
{
public:
void func() override
{
cout << "哈哈" << endl;
}
};
int main()
{
Base *b = new Derived();
b->func();
return 0;
}

class A
{
public:
virtual void foo()
{
cout<<"A::foo() is called"<<endl;
}
};
class B:public A
{
public:
void foo()
{
cout<<"B::foo() is called"<<endl;
}
};
int main(void)
{
A *a = new B();
a->foo(); // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!
return 0;
}

class A
{
public:
void do(int a);
void do(int a, int b);
};

class TimeKeeper
{
public:
TimeKeeper() {}
virtual ~TimeKeeper() {}
};

class TimeKeeper
{
public:
TimeKeeper() {}
~TimeKeeper() {} //非virtual的
};
//都继承与TimeKeeper
class AtomicClock :public TimeKeeper{};
class WaterClock :public TimeKeeper {};
class WristWatch :public TimeKeeper {};

TimeKeeper* getTimeKeeper()
{
//返回一个指针，指向一个TimeKeeper派生类的动态分配对象
}

TimeKeeper* ptk = getTimeKeeper();
delete ptk;

class TimeKeeper
{
public:
TimeKeeper() {}
virtual ~TimeKeeper() {}
};

1. 在被继承的类前面加上virtual关键字，这时被继承的类称为虚基类，代码如下：

class A
class B1:public virtual A;
class B2:public virtual A;
class D:public B1,public B2;

 2. 虚继承的类可以被实例化，举例如下：

class Animal {/* ... */ };
class Tiger : virtual public Animal { /* ... */ };
class Lion : virtual public Animal { /* ... */ }
int main( )
{
Liger lg ;
/*既然我们已经在Tiger和Lion类的定义中声明了"virtual"关键字，于是下面的代码编译OK */
int weight = lg.getWeight();
}

29 简述一下拷贝赋值和移动赋值？

class Func{
public:
void operator() (const string& str) const {
cout<<str<<endl;
}
};
Func myFunc;
myFunc("helloworld!");
>>>helloworld!

bool LengthIsLessThanFive(const string& str) {
return str.length()<5;
}
int res=count_if(vec.begin(), vec.end(), LengthIsLessThanFive);

bool LenthIsLessThan(const string& str, int len) {
return str.length()<len;
}

class ShorterThan {
public:
explicit ShorterThan(int maxLength) : length(maxLength) {}
bool operator() (const string& str) const {
return str.length() < length;
}
private:
const int length;
};