2023年最新总结，阿里，腾讯，百度，美团，头条等技术面试题目，以及答案，专家出题人分析汇总。

阿里篇

---

1.1.1 如何实现一个高效的单向链表逆序输出？

1.1.2 已知sqrt(2)约等于1.414，要求不用数学库，求sqrt(2)精确到小数点后10位

1.1.3 给定一个二叉搜索树(BST)，找到树中第 K 小的节点

1.1.4 LRU缓存机制

1.1.5 关于epoll和select的区别，以下哪些说法是正确的

1.1.6 从innodb的索引结构分析，为什么索引的 key 长度不能太长

1.1.7 MySQL的数据如何恢复到任意时间点？

1.1.8 什么是静态关联？什么是动态关联？

1.1.9 输入 ping IP 后敲回车，发包前会发生什么？

1.2.0 请解释下为什么鹿晗发布恋情的时候，微博系统会崩溃，如何解决？

1.2.1 现有一批邮件需要发送给订阅顾客，且有一个集群（集群的节点数不定，会动态扩容缩容）来负责具体的邮件发送任务，如何让系统尽快地完成发送？

1.2.2 有一批气象观测站，现需要获取这些站点的观测数据，并存储到 Hive 中。但是气象局只提供了 api 查询，每次只能查询单个观测点。那么如果能够方便快速地获取到所有的观测点的数据？

1.2.3 如何实现两金额数据相加（最多小数点两位）

1.2.4 关于并行计算的一些基础开放问题

1.2.5 请计算XILINX公司VU9P芯片的算力相当于多少TOPS，给出计算过程与公式

1.2.6 一颗现代处理器，每秒大概可以执行多少条简单的MOV指令，有哪些主要的影响因素

1.2.7 请分析 MaxCompute 产品与分布式技术的关系、当前大数据计算平台类产品的市场现状和发展趋势

1.2.8 对大数据平台中的元数据管理是怎么理解的，元数据收集管理体系是怎么样的，会对大数据应用有什么样的影响

1.2.9 你理解常见如阿里，和友商大数据平台的技术体系差异以及发展趋势和技术瓶颈，在存储和计算两个方面进行概述

1.3.0 虚函数是如何实现的？

1.3.1 最大频率栈

1.3.2 给定一个链表，删除链表的倒数第N个节点，并且返回链表的头结点

1.3.3 如果让你设计一个通用的、支持各种数据库秒级备份和恢复的系统，你会如何设计

1.3.4 如果让你来设计一个支持数据库、NOSQL 和大数据之间数据实时流动的数据流及处理的系统，你会考虑哪些问题？如何设计？

1.3.5 给定一个整数数组和一个整数，返回两个数组的索引，这两个索引指向的数字的加和等于指定的整数。需要最优的算法，分析算法的空间和时间复杂度

1.3.6 假如给你一个新产品，你将从哪些方面来保障它的质量？

1.3.7 请评估一下程序的执行结果？

华为篇

---

2.1.0 static有什么用途？（请至少说明两种）

2.1.1 变量的声明和定义有什么区别？

2.1.2 sizeof 和 strlen 的区别

2.1.3 C 语言的关键字 static 和 C++ 的关键字 static 有什么区别

2.1.4 Ｃ中的 malloc 和Ｃ＋＋中的 new 有什么区别

2.1.5 写一个“标准”宏 MIN

2.1.6 一个指针可以是 volatile 吗

2.1.7 a 和&a 有什么区别

2.1.8 简述 C、C++程序编译的内存分配情况

2.1.9 简述 strcpy、sprintf 与 memcpy 的区别

2.2.0 设置地址为 0x67a9 的整型变量的值为 0xaa66

2.2.1 面向对象的三大特征

2.2.2 C++的空类有哪些成员函数

2.2.3 谈谈你对拷贝构造函数和赋值运算符的认识

2.2.4 用 C++设计一个不能被继承的类

2.2.5 访问基类的私有虚函数

2.2.6 简述类成员函数的重写、重载和隐藏的区别

2.2.7 简述多态实现的原理

2.2.8 链表和数组有什么区别

2.2.9 怎样把一个单链表反序

2.3.0 简述队列和栈的异同

2.3.1 能否用两个栈实现一个队列的功能

2.3.2 计算一颗二叉树的深度

2.3.3 编码实现直接插入排序

2.3.4 编码实现冒泡排序

2.3.5 编码实现直接选择排序

2.3.6 编程实现堆排序

2.3.7 编程实现基数排序

2.3.8 谈谈你对编程规范的理解或认识

2.3.9 short i = 0; i = i + 1L；这两句有错吗

2.4.0 &&和&、||和|有什么区别

2.4.1 C++的引用和 C 语言的指针有什么区别

2.4.2 在二元树中找出和为某一值的所有路径

2.4.3 typedef 和 define 有什么区别

2.4.4 关键字 const 是什么

2.4.5 static 有什么作用

2.4.6 extern 有什么作用

2.4.7 流操作符重载为什么返回引用

2.4.8 简述指针常量与常量指针区别

2.4.9 数组名和指针的区别

2.5.0 如何避免“野指针”

2.5.1 常引用有什么作用

2.5.2 编码实现字符串转化为数字

2.5.3 简述 strcpy、sprintf 与 memcpy 的区别

2.5.4 用 C 编写一个死循环程序

2.5.5 编码实现某一变量某位清 0 或置 1

2.5.6 评论下面这个中断函数

2.5.7 构造函数能否为虚函数

2.5.8 谈谈你对面向对象的认识

2.5.9 动态库和静态库的区别

百度篇

---

3.1.0 提高c++性能，你用过哪些方式去提升

3.1.1 引用和指针的区别？

3.1.2 从汇编层去解释一下引用

3.1.3 C++中的指针参数传递和引用参数传递

3.1.4 形参与实参的区别？

3.1.5 static的用法和作用？

3.1.6 静态变量什么时候初始化

3.1.7 const?

3.1.8 const成员函数的理解和应用？

3.1.9 指针和const的用法

3.2.0 mutable

3.2.1 extern用法？

3.2.2 int转字符串字符串转int?strcat,strcpy,strncpy,memset,memcpy的内部实现？

3.2.3 深拷贝与浅拷贝？

3.2.4 C++模板是什么，底层怎么实现的？

3.2.5 C语言struct和C++struct区别

3.2.6 虚函数可以声明为inline吗?

3.2.7 类成员初始化方式？构造函数的执行顺序 ？为什么用成员初始化列表会快一些？

3.2.8 成员列表初始化？

3.2.9 构造函数为什么不能为虚函数？析构函数为什么要虚函数？

3.3.0 析构函数的作用，如何起作用？

3.3.1 构造函数和析构函数可以调用虚函数吗，为什么？

3.3.2 构造函数的执行顺序？析构函数的执行顺序？构造函数内部干了啥？拷贝构造干了啥？

3.3.3 虚析构函数的作用，父类的析构函数是否要设置为虚函数？

3.3.4 构造函数析构函数可否抛出异常

3.3.5 类如何实现只能静态分配和只能动态分配

3.3.6 如果想将某个类用作基类，为什么该类必须定义而非声明？

3.3.7 什么情况会自动生成默认构造函数？

3.3.8 什么是类的继承？

3.3.9 什么是组合？

3.4.0 抽象基类为什么不能创建对象？

3.4.1 类什么时候会析构？

3.4.2 为什么友元函数必须在类内部声明？

3.4.3 介绍一下C++里面的多态？

3.4.4 用C语言实现C++的继承

3.4.5 继承机制中对象之间如何转换？指针和引用之间如何转换？

3.4.6 组合与继承优缺点？

3.4.7 左值右值

3.4.8 移动构造函数

3.4.9 C语言的编译链接过程？

3.5.0 vector与list的区别与应用？怎么找某vector或者list的倒数第二个元素

3.5.1 STL vector的实现，删除其中的元素，迭代器如何变化？为什么是两倍扩容？释放空间？

3.5.2 容器内部删除一个元素

3.5.3 STL迭代器如何实现

3.5.4 set与hash_set的区别

3.5.5 hashmap与map的区别

3.5.6 map、set是怎么实现的，红黑树是怎么能够同时实现这两种容器？ 为什么使用红黑树？

3.5.7 如何在共享内存上使用stl标准库？

腾讯篇

---

4.1.0 map插入方式有几种？

4.1.1 STL中unordered_map(hash_map)和map的区别，hash_map如何解决冲突以及扩容

4.1.2 vector越界访问下标，map越界访问下标？vector删除元素时会不会释放空间？

4.1.3 map[]与find的区别？

4.1.4 STL中list与queue之间的区别

4.1.5 STL中的allocator,deallocator

4.1.6 STL中hash_map扩容发生什么？

4.1.7 map如何创建？

4.1.8 vector的增加删除都是怎么做的？为什么是1.5倍？

4.1.9 函数指针？

4.2.0 说说你对c和c++的看法，c和c++的区别？

4.2.1 c/c++的内存分配，详细说一下栈、堆、静态存储区？

4.2.2 堆与栈的区别？

4.2.3 野指针是什么？如何检测内存泄漏？

4.2.4 悬空指针和野指针有什么区别？

4.2.5 内存泄漏

4.2.6 new和malloc的区别？

4.2.7 delete p;与delete[]p，allocator

4.2.8 new和delete的实现原理， delete是如何知道释放内存的大小的额？

4.2.9 malloc申请的存储空间能用delete释放吗

4.3.0 malloc与free的实现原理？

4.3.1 malloc、realloc、calloc的区别

4.3.2 __stdcall和__cdecl的区别？

4.3.3 使用智能指针管理内存资源，RAII

4.3.4 手写实现智能指针类

4.3.5 内存对齐？位域？

4.3.6 结构体变量比较是否相等

4.3.7 位运算

4.3.8 为什么内存对齐

4.3.9 函数调用过程栈的变化，返回值和参数变量哪个先入栈？

4.4.0 怎样判断两个浮点数是否相等？

4.4.1 宏定义一个取两个数中较大值的功能

4.4.2 define、const、typedef、inline使用方法？

4.4.3 printf实现原理？

4.4.4 #include 的顺序以及尖叫括号和双引号的区别

4.4.5 lambda函数

4.4.6 hello world 程序开始到打印到屏幕上的全过程?

4.4.7 模板类和模板函数的区别是什么？

4.4.8 为什么模板类一般都是放在一个h文件中

4.4.9 C++中类成员的访问权限和继承权限问题。

4.5.0 cout和printf有什么区别？

4.5.1 重载运算符？

4.5.2 函数重载函数匹配原则

4.5.3 定义和声明的区别

4.5.4 C++类型转换有四种

4.5.5 全局变量和static变量的区别

4.5.6 静态成员与普通成员的区别

4.5.7 说一下理解 ifdef endif

4.5.8 隐式转换，如何消除隐式转换？

4.5.9 多继承的优缺点，作为一个开发者怎么看待多继承

4.6.0 迭代器++it,it++哪个好，为什么

4.6.1 模板和实现可不可以不写在一个文件里面？为什么？

4.6.2 在成员函数中调用delete this会出现什么问题？对象还可以使用吗？

4.6.3 智能指针的作用

4.6.4 auto_ptr作用

4.6.5 class、union、struct的区别

4.6.6 动态联编与静态联编

4.6.7 动态编译与静态编译

4.6.8 动态链接和静态链接区别

4.6.9 在不使用额外空间的情况下，交换两个数？

4.7.0 strcpy和memcpy的区别

4.7.1 执行int main(int argc, char *argv[])时的内存结构

4.7.2 volatile关键字的作用？

4.7.3 讲讲大端小端，如何检测（三种方法）

4.7.4 查看内存的方法

4.7.5 空类会默认添加哪些东西？怎么写？

4.7.6 标准库是什么？

4.7.7 new、delete、operator new、operator delete、placement new、placement delete

4.7.8 为什么拷贝构造函数必须传引用不能传值？

4.7.9 空类的大小是多少？为什么？

4.8.0 你什么情况用指针当参数，什么时候用引用，为什么？

4.8.1 大内存申请时候选用哪种？C++变量存在哪？变量的大小存在哪？符号表存在哪？

美团篇

---

5.1.0 为什么会有大端小端，htol这一类函数的作用

5.1.1 静态函数能定义为虚函数吗？常函数?

5.1.2 this指针调用成员变量时，堆栈会发生什么变化？

5.1.3 静态绑定和动态绑定的介绍

5.1.4 设计一个类计算子类的个数

5.1.5 怎么快速定位错误出现的地方

5.1.6 虚函数的代价？

5.1.7 类对象的大小

5.1.8 移动构造函数

5.1.9 何时需要合成构造函数

5.2.0 何时需要合成复制构造函数

5.2.1 何时需要成员初始化列表？过程是什么？

5.2.2 程序员定义的析构函数被扩展的过程？

5.2.3 构造函数的执行算法？

5.2.4 构造函数的扩展过程？

5.2.5 哪些函数不能是虚函数

5.2.6 sizeof 和strlen 的区别

5.2.7 简述strcpy、sprintf与memcpy的区别

5.2.8 编码实现某一变量某位清0或置1

5.2.9 将“引用”作为函数参数有哪些特点？

5.3.0 分别写出BOOL,int,float,指针类型的变量a 与“零”的比较语句。

5.3.1 局部变量全局变量的问题？

5.3.2 数组和指针的区别？

5.3.3 C++如何阻止一个类被实例化？一般在什么时候将构造函数声明为private？

5.3.4 如何禁止自动生成拷贝构造函数？

5.3.5 assert与NDEBUGE

5.3.6 Denug和release的区别

5.3.7 main函数有没有返回值

5.3.8 写一个比较大小的模板函数

5.3.9 c++怎么实现一个函数先于main函数运行

5.4.0 虚函数与纯虚函数的区别在于

5.4.1 智能指针怎么用？智能指针出现循环引用怎么解决？

5.4.2 strcpy函数和strncpy函数的区别？哪个函数更安全？

5.4.3 为什么要用static_cast转换而不用c语言中的转换？

5.4.4 成员函数里memset(this,0,sizeof(*this))会发生什么

5.4.5 方法调用的原理（栈，汇编）

5.4.6 回调函数的作用

随机数的生成

5.4.8 变量的声明和定义有什么区别？

5.4.9 请简述#ifdef、#else、#endif、和#ifndef的作用是？

头条篇

---

6.1.0 请写出int、bool、float、指针变量与"零值"比较的if语句？

6.1.1 结构体是否可以直接赋值？

6.1.2 sizeof和strlen的区别？

6.1.3 C语言和C++语言中的关键字static有什么区别？

6.1.4 C语言的malloc和C++中的new有什么区别？

6.1.5 请写一个标准宏MIN？

6.1.6 ++i和i++的区别？

6.1.7 关键字volatile有什么作用？

6.1.8 一个参数可以既是const又是volatile吗？

6.1.9 *a和&a有什么区别？

6.2.0 用C语言编写一个死循环程序？

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

6.2.2 请简述C/C++程序编译的内存分配情况？

6.2.3 请简述strcpy、sprintf和memcpy的区别？

6.2.4 请解释((void ()())0)()的含义？

6.2.5 C语言的指针和引用和C++的有什么区别？

6.2.6 typedef和define有什么区别？

6.2.7 指针常量和常量指针有什么区别？

6.2.8 请简述队列和栈的异同？

6.2.9 如何设置地址为0x67a9的整型变量的值为0xaa66？

6.3.0 请编程实现字符串转换为数字？

6.3.1 C语言的结构体和C++的有什么区别？

6.3.2 简述指针常量与常量指针的区别？

6.3.3 如何避免"野指针"？

6.3.4 句柄和指针的区别和联系是什么？

6.3.5 new/delete与malloc/free的区别是什么？

6.3.6 请说一说extern "C"？

6.3.7 请说一说C++中struct和class的区别是什么？

6.3.8 new、delete、malloc、free关系

6.3.9 delete与 delete []区别

6.4.0 C++有哪些性质（面向对象特点）

6.4.1 子类析构时要调用父类的析构函数吗？

6.4.2 多态，虚函数，纯虚函数

6.4.3 求下面函数的返回值（微软）

6.4.4 什么是“引用”？申明和使用“引用”要注意哪些问题？

6.4.5 将“引用”作为函数参数有哪些特点？

6.4.6 在什么时候需要使用“常引用”？

6.5.0 结构与联合有和区别？

6.5.1 试写出程序结果

6.5.2 重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？

6.5.3 有哪几种情况只能用intialization list 而不能用assignment?

滴滴篇

---

7.1.0 C++是不是类型安全的？

7.1.1 main 函数执行以前，还会执行什么代码？

7.1.2 描述内存分配方式以及它们的区别?

7.1.3 分别写出BOOL,int,float,指针类型的变量a 与“零”的比较语句。

7.1.4 请说出const与#define 相比，有何优点？

7.1.5 简述数组与指针的区别？

7.1.6 int (*s[10])(int) 表示的是什么？

7.1.7 栈内存与文字常量区

7.1.8 将程序跳转到指定内存地址

7.1.9 int id[sizeof(unsigned long)];这个对吗？为什么？

7.2.0 引用与指针有什么区别？

7.2.1 const 与 #define 的比较 ，const有什么优点?

京东篇

---

8.1.0 内存的分配方式有几种?

8.1.1 基类的析构函数不是虚函数，会带来什么问题？

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

8.1.3 const关键字（反义词mutable）

8.1.4 static关键字

8.1.5 extern关键字

8.1.6 指针和引用的区别

8.1.7 explicit是干什么用的 ?

8.1.8 浅拷贝与深拷贝？为什么要使用深拷贝？

8.1.9 深入谈谈堆和栈？

8.2.0 内存的静态分配和动态分配的区别？

8.2.1 什么是继承？什么是多态？

8.2.2 虚函数与纯虚函数的区别？含有纯虚函数的类叫什么？

mysql篇

---

9.1.0 主键 超键 候选键 外键

9.1.1 数据库事务的四个特性及含义

9.1.2 视图的作用，视图可以更改么？

9.1.3 drop,delete与truncate的区别

9.1.4 索引的工作原理及其种类

9.1.5 连接的种类

9.1.6 数据库范式

9.1.7 数据库优化的思路

9.1.8 存储过程与触发器的区别

redis篇

---

10.1.0 使用Redis有哪些好处？

10.1.1 redis相比memcached有哪些优势？

10.1.2 redis常见性能问题和解决方案

10.1.3 MySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据

10.1.4 Memcache与Redis的区别都有哪些？

10.1.5 Redis 常见的性能问题都有哪些？如何解决？

10.1.6 redis 最适合的场景

10.1.7 Redis的同步机制了解么？

10.1.8 是否使用过Redis集群，集群的原理是什么？

10.1.9 redis集群如何保证一致性？

MongoDB篇

---

11.1.0 什么是MongoDB？

11.1.1 MongoDB是由哪种语言写的？

11.1.2 MongoDB的优势有哪些？

11.1.3 什么是数据库？

11.1.4 什么是集合？

11.1.5 什么是文档？

11.1.6 MongoDB和关系型数据库术语对比图

11.1.7 什么是“mongod”？

11.1.8 “mongod”参数有什么？

11.1.9 什么是“mongo”？

11.2.0 MongoDB哪个命令可以切换数据库？

11.2.1 什么是非关系型数据库？

11.2.2 非关系型数据库有哪些类型？

11.2.3 为什么用MongoDB？

11.2.4 在哪些场景使用MongoDB？

11.2.5 MongoDB中的命名空间是什么意思?

11.2.6 哪些语言支持MongoDB?

11.2.7 在MongoDB中如何创建一个新的数据库？

11.2.8 在MongoDB中如何查看数据库列表？

11.2.9 MongoDB中的分片是什么意思？

11.3.0 如何查看使用MongoDB的连接？

11.3.1 什么是复制？

11.3.2 在MongoDB中如何在集合中插入一个文档？

11.3.3 在MongoDB中如何除去一个数据库？

11.3.4 在MongoDB中如何创建一个集合？

11.3.5 在MongoDB中如何查看一个已经创建的集合？

11.3.6 在MongoDB中如何删除一个集合？

11.3.7 为什么要在MongoDB中使用分析器？

11.3.8 MongoDB支持主键外键关系吗？

11.3.9 MongoDB支持哪些数据类型？

11.4.0 为什么要在MongoDB中用"Code"数据类型？

11.4.1 为什么要在MongoDB中用"Regular Expression"数据类型？

11.4.2 为什么在MongoDB中使用"Object ID"数据类型？

11.4.3 如何在集合中插入一个文档？

11.4.4 “ObjectID”有哪些部分组成？

11.4.5 在MongoDB中什么是索引？

11.4.6 如何添加索引？

11.4.7 MongoDB有哪些可替代产品？

11.4.8 如何查询集合中的文档？

11.4.9 用什么方法可以格式化输出结果？

11.5.0 如何使用"AND"或"OR"条件循环查询集合中的文档？

11.5.1 在MongoDB中如何更新数据？

11.5.2 如何删除文档？

11.5.3 在MongoDB中如何排序？

11.5.4 什么是聚合？

11.5.5 在MongoDB中什么是副本集？

11.5.6 Mongodb存储特性与内部原理?

Zookeeper篇

---

12.1.0 zookeeper是什么？

12.1.1 zookeeper提供了什么？

12.1.2 zookeeper文件系统

12.1.3 zookeeper的四种类型的znode

12.1.4 zookeeper通知机制

12.1.5 zookeeper有哪些应用场景？

12.1.6 zk的命名服务

12.1.7 zk的配置管理服务

12.1.8 zk的集群管理

12.1.9 zk的分布式锁

12.2.0 zk队列管理

12.2.1 zk数据复制

12.2.2 zk的工作原理

12.2.3 zk是如何保证事物的顺序一致性

12.2.4 zk集群下server工作状态

12.2.5 zk是如何选举Leader的？

12.2.6 zk同步流程

12.2.7 分布式通知和协调

12.2.8 zk的session机制

其他中大厂700道精选面试题

---

13.1.0 多重继承如何解决？

13.1.1 派生类与虚函数概述

13.1.2 为什么析构函数要定义为虚函数？哪些函数不能是虚函数？

13.1.3 析构函数可以抛出异常吗？为什么不能抛出异常？除了资源泄露，还有其他需考虑的因素吗？

13.1.4 动态链接库的两种使用方法及特点？

13.1.5 STL各类容器（3个顺序+4个关联+1个无序关联）的实现原理及使用情形

13.1.6 什么是STL？

13.1.7 什么是智能指针？底层实现？)

13.1.8 多进程与多线程之间的区别？（最好要了解透彻）

13.1.9 什么是进程池和线程池？

13.2.0 进程间的通信方式有哪些？如何实现的？

13.2.1 简述inux中的同步与异步机制？

13.2.2 简述阻塞与非阻塞？

13.2.3 简述Linux中的5种I/O模式？

13.2.4 什么是死锁？四个死锁的条件？避免死锁的方法？

13.2.5 Linux的任务调度机制是什么？

13.2.6 标准库函数与系统调用的区别？

13.2.7 分别简述三次握手与四次挥手的过程？

13.2.8 tcp和udp之间的区别？

13.2.9 epoll有哪些触发模式？

13.3.1 C和C++的区别

13.3.2 C++中指针和引用的区别

13.3.3 结构体struct和共同体union（联合）的区别

13.3.4 #define和const的区别

13.3.5 重载overload，覆盖（重写）override，隐藏（重定义）overwrite，这三者之间的区别

13.3.6 new、delete、malloc、free之间的关系

13.3.7 delete和delete[]的区别

13.3.8 虚函数、纯虚函数

13.3.9 STL库用过吗？常见的STL容器有哪些？算法用过几个？

13.4.1 const知道吗？解释一下其作用

13.4.2 虚函数是怎么实现的

13.4.3 堆和栈的区别

13.4.4 关键字static的作用

13.4.5 STL中map和set的原理（关联式容器）

13.4.6 #include<file.h> #include "file.h" 的区别

13.4.7 什么是内存泄漏？面对内存泄漏和指针越界，你有哪些方法？

13.4.8 定义和声明的区别

13.4.9 C++文件编译与执行的四个阶段

13.5.1 STL中unordered_map和map的区别

13.5.2 C++的内存管理

13.5.3 构造函数为什么一般不定义为虚函数？而析构函数一般写成虚函数的原因 ？

13.5.4 静态绑定和动态绑定的介绍

13.5.5 引用是否能实现动态绑定，为什么引用可以实现

13.5.6 深拷贝和浅拷贝的区别

13.5.7 什么情况下会调用拷贝构造函数（三种情况）

13.5.8 C++的四种强制转换

13.5.9 调试程序的方法

13.6.1 extern“C”作用

13.6.2 typdef和define区别

13.6.3 引用作为函数参数以及返回值的好处

13.6.4 纯虚函数

13.6.5 什么是野指针

13.6.6 线程安全和线程不安全

13.6.7 C++中内存泄漏的几种情况

13.6.8 栈溢出的原因以及解决方法

13.6.9 C++标准库vector以及迭代器

13.7.1 C++中vector和list的区别

13.7.2 C++中的基本数据类型及派生类型

13.7.3 友元函数和友元类

13.7.4 c++函数库中一些实用的函数

13.7.5 线程的基本概念、线程的基本状态及状态之间的关系？

13.7.6 线程与进程的区别？

13.7.7 C++多线程有几种实现方法，都是什么？

13.7.8 C和C++的区别

13.7.9 封装、继承、多态

13.8.1 虚函数的作用及其实现原理

13.8.2 深拷贝和浅拷贝（值拷贝和位拷贝）

13.8.3 虚函数、纯虚函数怎么实现

13.8.4 为什么要有纯虚函数

13.8.5 纯虚函数

13.8.6 为什么要有虚析构函数

13.8.7 构造函数能不能是虚函数

13.8.8 C++里面构造函数能有返回值吗？

13.8.9 构造函数和析构函数能被继承吗？

13.9.1 C++中Overload、Overwrite及Override的区别

13.9.2 一个空的class类里有什么

13.9.3 C++中一个空类的大小为什么是1？

13.9.4 一个结构体中有一个int，一个char，一个static int，问这个结构体占多少内存？（涉及到内存对齐机制）

13.9.5 结构体与联合体的区别

13.9.6 函数与宏的差别

13.9.7 宏函数和inline函数的异同点

13.9.8 define 和 typedef 区别

13.9.9 标准C++中的include “” 与<>的区别

14.1.1 C++的内存管理机制

14.1.2 C语言中的malloc/free和C++中的new/delete的区别和联系

14.1.3 迭代和递归区别

14.1.4 不可操作的操作符

14.1.5 C++关键字mutable作用

14.1.6 引用与指针有什么区别？

14.1.7 什么是黑盒测试和白盒测试？

14.1.8 你知道的类模版有哪些

14.1.9 new可以搭配free吗，为什么？

14.2.1 怎么查看内存泄漏

14.2.2 什么是内存溢出

14.2.3 内存溢出的解决方案

14.2.4 函数指针与指针函数分别是什么

14.2.5 C++11新特性了解吗

14.2.6 接口和抽象类的区别

14.2.7 预编译在做些什么事情？

14.2.8 动态库和静态库？

14.2.9 堆和栈的区别，以及为什么栈效率高

14.3.1 函数参数压栈方式为什么是从右到左的？

14.3.2 C++中的智能指针

14.3.3 基类里private成员函数可以声明为虚函数吗？

14.3.4 函数A调用函数B的时候，有什么需要压栈？

14.3.5 数组和指针区别？数组和链表呢？双向链表和单向链表？

14.3.6 vector底层实现？

14.3.7 vector与list的区别？

14.3.8 变量的声明和定义有什么区别？

14.3.9 简述#ifdef、#else、#endif和#ifndef的作用

14.4.1 写出int、bool、float、指针变量与“零值”比较的if语句

14.4.2 结构体可以直接赋值吗？

14.4.3 sizeof和strlen的区别

14.4.4 c语言的关键字static和c++关键字static有什么区别？

14.4.5 c语言的malloc和c++中的new有什么区别？

14.4.6 写一个”标准“宏MIN

14.4.7 ++i和i++的区别

14.4.8 volatile有什么作用

14.4.9 一个参数可以既是const又是volatile吗

14.5.1 a和&a有什么区别？

14.5.2 用c编写一个死循环程序

14.5.3 结构体内存对齐的问题

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

14.5.5 简述c、c++程序编译的内存分配情况

14.5.6 简述strcpy、sprintf、memcpy的区别

14.5.7 解析（(void()())0)()的含义

14.5.8 c语言的指针和引用和c++的有什么区别？

14.5.9 new与malloc的区别

14.6.1 malloc/free 为什么还要 new/delete？

14.6.2 delete与 delete []区别

14.6.3 在物理内存为1G的计算机中能否malloc(1.2G)？

14.6.4 用C写个程序，如何判断一个操作系统是16位还是32位的？

14.6.5 解释下位域，为什么要用位域，位域的好处？

14.6.6 位操作

14.6.7 在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。

14.6.8 给定一个整型变量a，写两段代码，第一个设置a的bit3，第二个清除a的bit，在以上两个操作中，要保持其它位不变。

14.6.9 什么是右值引用，跟左值又有什么区别

14.7.1 判断x=x+1,x+=1,x++哪个效率最高?为什么?

14.7.2 用变量a定义

14.7.3 C语言是强类型的语言，这是什么意思？

14.7.4 char 与 int之间的转换

14.7.5 float（单精度浮点型）和double（双精度浮点型）

14.7.6 字符常量

14.7.7 写出bool 、int、 指针变量与“零值”比较的if语句

14.7.8 写出float x 与“零值”比较的if语句。

14.7.9 区分 %d, %ld, %lld, %lf, %f

14.8.1 输出数据问题

14.8.2 嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环

14.8.3 惰性计算方法

14.8.4 变量的声明和定义有什么区别

14.8.5 用预处理指令#define 声明一个常数，用以表明1年中有多少秒(忽略闰年问题)

14.8.6 写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个

14.8.7 sizeof和strlen的区别

14.8.8 c语言中的static和C++中static的区别

14.8.9 C++函数中值的传递方式有哪几种?

14.9.1 C++里面是不是所有的动作都是main()引起的？如果不是，请举例。

14.9.2 谈谈对面向对象的认识

14.9.3 谈谈你对编程规范的理解

14.9.4 面向对象的三大特性

14.9.5 简述多态的原理

14.9.6 多态的作用？

14.9.7 多态，虚函数，纯虚函数

14.9.8 重载（overload)、重写(override，有的书也叫做“覆盖”）、重定义（redefinition）的区别?

14.9.9 所有的运算符都能重载吗？

15.1.1 用C++设计一个不能继承的类

15.1.2 构造函数能否为虚函数

15.1.3 在C中用const 能定义真正意义上的常量吗？C++中的const呢？

15.1.4 宏和内联（inline）函数的比较？

15.1.5 typedef和define由什么区别

15.1.6 strcat、strncat、strcpy哪些函数会导致内存溢出？如何改进？

15.1.7 简述队列和栈的异同

15.1.8 堆和栈的区别？

15.1.9 堆和自由存储区的区别？

15.2.1 什么是内存泄漏？面对内存泄漏有什么避免方法

15.2.2 链表和数组的区别

15.2.3 结构与联合有和区别

15.2.4 什么是“引用”？申明和使用“引用”要注意哪些问题？

15.2.5 将“引用”作为函数参数有哪些特点？

15.2.6 STL标准模板库

15.2.7 陷阱题

15.2.8 一个C++源文件从文本到可执行文件经历的过程

15.2.9 #include 的顺序以及尖叫括号和双引号的区别

15.3.1 进程和线程，为什么要有线程

15.3.2 C++11有哪些新特性

15.3.3 malloc的原理，brk系统调用干什么的，mmap呢

15.3.4 C++的内存管理方式，STL的allocator，最新版本默认使用的分配器

15.3.5 hash表的实现，包括STL中的哈希桶长度常数。

15.3.6 hash表如何rehash，怎么处理其中保存的资源

15.3.7 Redis的rehash怎么做的，为什么要渐进rehash，渐进rehash怎么实现的

15.3.8 Redis的定时机制怎么实现的，有哪些弊端，你将如何改进这个弊端

15.3.9 Redis是单线程的，为什么这么高效)

15.4.1 Redis的数据类型有哪些，底层怎么实现

15.4.2 Redis和memcached的区别

15.4.3 TCP的模型，状态转移

15.4.4 用过哪些设计模式，单例模式，观察者模式的多线程安全问题

15.4.5 用过多线程吗，以前的多线程代码还能怎么优化，线程池的实现

15.4.6 epoll怎么实现的，reactor模型组成

15.4.7 线程间的同步方式，最好说出具体的系统调用

15.4.8 哈希表的桶个数为什么是质数，合数有何不妥？

15.4.9 C/C++内存有哪几种类型？

15.5.1 堆和栈的区别？

15.5.2 堆和自由存储区的区别？

15.5.3 程序编译的过程？

15.5.4 计算机内部如何存储负数和浮点数？

15.5.5 函数调用的过程？

15.5.6 左值和右值

15.5.7 什么是内存泄漏？面对内存泄漏和指针越界，你有哪些方法？你通常采用哪些方法来避免和减少这类错误？

15.5.8 C++11 中有哪些智能指针？shared_ptr 的引用计数是如何实现的？unique_ptr 的unique 是如何实现的？make_shared 和 make_unique 的作用？智能指针使用注意事项？

15.5.9 C和C++的区别？

15.6.1 int fun() 和 int fun(void)的区别?)

15.6.2 const 有什么用途

15.6.3 在C中用const 能定义真正意义上的常量吗？C++中的const呢？

15.6.4 宏和内联（inline）函数的比较？

15.6.5 C++中有了malloc / free , 为什么还需要 new / delete？

15.6.6 C和C++中的强制类型转换？

15.6.7 static 有什么用途

15.6.8 类的静态成员变量和静态成员函数各有哪些特性？

15.6.9 在C++程序中调用被C编译器编译后的函数，为什么要加extern“C”?

15.7.1 头文件中的 ifndef/define/endif 是干什么用的? 该用法和 program once 的区别？

15.7.2 当i是一个整数的时候++i和i++那个更快一点？i++和++i的区别是什么？

15.7.3 指针和引用的区别？

15.7.4 引用占用内存空间吗？

15.7.5 三目运算符

15.7.6 指针数组和数组指针的区别

15.7.7 左值引用与右值引用

15.7.8 右值引用的意义

15.7.9 什么是面向对象（OOP）？面向对象的意义？

15.8.1 解释下封装、继承和多态？

15.8.2 什么时候生成默认构造函数（无参构造函数）？什么时候生成默认拷贝构造函数？什么是深拷贝？什么是浅拷贝？默认拷贝构造函数是哪种拷贝？什么时候用深拷贝？

15.8.3 构造函数和析构函数的执行顺序？

15.8.4 虚析构函数的作用？

15.8.5 细看拷贝构造函数

15.8.6 C++的编译环境

15.8.7 Most vexing parse

15.8.8 STL 六大组件

15.8.9 stack 中有 pop() 和 top() 方法，为什么不直接用 pop() 实现弹出和取值的功能？

15.9.1 map 和 unordered_map 的区别？各自的优缺点？

15.9.2 如何初始化一个指针数组

15.9.3 关键字const是什么含意？

15.9.4 什么是动态特性?

15.9.5 基类的有1个虚函数，子类还需要申明为virtual吗？为什么。

15.9.6 在C++ 程序中调用被 C 编译器编译后的函数，为什么要加 extern “C”声明？

15.9.7 如何定义Bool变量的TRUE和FALSE的值。

15.9.8 内联函数INline和宏定义一起使用的区别。

15.9.9 编写my_strcpy函数，实现与库函数strcpy类似的功能，不能使用任何库函数；

16.1.2 完成程序，实现对数组的降序排序

16.1.3 .ICMP是什么协议,处于哪一层?

16.1.4 C中static有什么作用

16.1.5 请问运行Test函数会有什么样的结果？

16.1.6 C++特点是什么，如何实现多态？画出基类和子类在内存中的相互关系。

16.1.7 C++中的什么是多态性? 是如何实现的?

16.1.8 关键字static的作用是什么？

16.1.9 #define MAX_LEN 500 char arry[MAX_LEN]; cin>>arry; 这段代码有问题吗？若有，请指出并修改；

16.2.1 delete []arry 和 delete arry 一样吗？不一样请说明；

16.2.2 多态的作用？

16.2.3 C语言的volatile的含义是什么。使用时会对编译器有什么暗示。

16.2.4 请简述以下两个for循环的优缺点

16.2.5 预处理器标识#error的目的是什么？

16.2.6 C语言的volatile的含义是什么。使用时会对编译器有什么暗示。

16.2.7 MFC中CString是类型安全类么？

16.2.8 内联函数INline和宏定义一起使用的区别。

16.2.9 C++中什么数据分配在栈或堆中，New分配数据是在近堆还是远堆中？

16.3.1 DB事务处理的四个特性：

16.3.2 如何初始化一个指针数组。

16.3.3 int i=(j=4,k=8,l=16,m=32); printf(“%d”, i); 输出是多少？

16.3.4 如何在C中初始化一个字符数组。

16.3.5 参数传递有几种方式；实现多态参数传递采用什么方式，如果没有使用某种方式原因是什么

16.3.6 请填写BOOL , float, 指针变量 与“零值”比较的 if 语句。

16.3.7 C++特点是什么，如何实现多态？画出基类和子类在内存中的相互关系。

16.3.8 什么是“引用”？申明和使用“引用”要注意哪些问题？

16.3.9 触发器怎么工作的?

16.4.1 C也可以通过精心封装某些函数功能实现重用，那C++的类有什么优点吗，难道仅仅是为实现重用。

16.4.2 CSingleLock是干什么的。

16.4.3 C++中引用和指针的区别?

16.4.4 C与C++各自是如何定义常量的?有什么不同?

16.4.5 C++函数中值的传递方式有哪几种?

16.4.6 一般数据库若出现日志满了，会出现什么情况，是否还能使用？

16.4.7 C++里面如何声明constvoidf(void)函数为C程序中的库函数？

16.4.8 c++中类和c语言中struct的区别（至少两点）

16.4.9 IP组播有那些好处?

16.5.1 变量的声明和定义有什么区别？

16.5.2 程序什么时候应该使用线程，什么时候单线程效率高。

16.5.3 介绍一下模板和容器。如何实现？（也许会让你当场举例实现）

16.5.4 以下为WindowsNT下的32位C++程序，请计算sizeof的值

16.5.5 C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？inta=5,b=7,c;c=a+++b;

16.5.6 #include与#include“file.h”的区别？

16.5.7 如何在C中初始化一个字符数组。

16.5.8 在C++程序中调用被C编译器编译后的函数，为什么要加extern“C”？

16.5.9 内存的分配方式的分配方式有几种?

16.6.1 在C++程序中调用被C编译器编译后的函数，为什么要加extern"C"?

16.6.2 如何让局部变量具有全局生命期。

16.6.3 解释堆和栈的区别。

16.6.4 在C++程序中调用被C编译器编译后的函数，为什么要加extern“C”声明？

16.6.5 strtok函数在使用上要注意什么问题。

16.6.6 用预处理指令#define声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

16.6.7 说一说C与C++的内存分配方式?

16.6.8 你如何理解MVC。简单举例来说明其应用。

16.6.9 在C++程序中调用被C编译器编译后的函数，为什么要加extern“C”声明？

16.7.1 inti=(j=4,k=8,l=16,m=32);printf(“%d”,i);输出是多少？

16.7.2 ＃include与＃include“file.h”的区别？

16.7.3 既然C++中有更好的const为什么还要使用宏?

16.7.4 重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？

16.7.5 C++和C定义结构的分别是什么。

16.7.6 #include和#include"a.h"有什么区别?

16.7.7 ＃include和＃include“filename.h”有什么区别？

16.7.8 C函数可否单独编译？

16.7.9 请简述以下两个for循环的优缺点

16.8.1 完成程序，实现对数组的降序排序

16.8.2 delete[]arry和deletearry一样吗？不一样请说明；

16.8.3 结合1个你认为比较能体现OOP思想的项目，用UML来描述。

16.8.4 C与C++各自是如何定义常量的?有什么不同?

16.8.5 头文件中的ifndef/define/endif干什么用？

16.8.6 C++中为什么用模板类。

16.8.7 动态连接库的两种方式?

16.8.8 在什么时候需要使用“常引用”？

16.8.9 预处理器标识#error的目的是什么？

16.9.1 GCC3.2.2版本中支持哪几种编程语言。

16.9.2 已知strcpy的函数原型：charstrcpy(charstrDest,constchar*strSrc)其中strDest是目的字符串，strSrc是源字符串。不调用C++/C的字符串库函数，请编写函数strcpy。

16.9.3 重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？

16.9.4 多重继承如何消除向上继承的二义性。

16.9.5 #include与#include“file.h”的区别？

16.9.6 对数据库的一张表进行操作,同时要对另一张表进行操作,如何实现?

16.9.7 #include<filename.h>和#include“filename.h”有什么区别？

16.9.8 预处理器标识#error的目的是什么？

16.9.9 头文件的作用是什么?

17.1.1 请问运行Test函数会有什么样的结果？

17.1.2 delete[]arry和deletearry一样吗？不一样请说明；

17.1.3 请问运行Test函数会有什么样的结果？

17.1.4 请简述以下两个for循环的优缺点

17.1.5 构造函数可否是虚汗数，为什么？析构函数呢，可否是纯虚的呢？

17.1.6 在C++程序中调用被C编译器编译后的函数，为什么要加extern"C"?

17.1.7 请写出下面代码在32位平台上的运行结果，并说明sizeof的性质：

17.1.8 高级通信包括信号量，——-，——–

17.1.9 关联、聚合(Aggregation)以及组合(Composition)的区别？

17.2.1 尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。那么嵌入式系统中，动态分配内存可能发生的问题是什么？

17.2.2 请问运行Test函数会有什么样的结果？

17.2.3 多态的实现

17.2.4 Cpp四种强制类型转换

17.2.5 类的static成员的特点

17.2.6 指针和引用的区别

17.2.7 谈谈对Cpp内存的理解

17.2.8 谈谈new、delete、malloc、free

17.2.9 const关键字

17.3.1 知道STL吗，挑两个你最常用的容器说一说

17.3.2 怎么确定一个程序是C编译的还是C++编译的

17.3.3 一个文件从源码到可执行文件所经历的过程

17.3.4 了解C++新特性吗

17.3.5 什么是纯虚函数

17.3.6 构造函数和析构函数可以为虚函数吗

17.3.7 栈和堆的区别，什么时候必须使用堆

17.3.8 用宏定义实现swap

17.3.9 头文件<>和""的区别

17.4.1 编写string的构造函数、拷贝构造函数、赋值操作符重载和析构函数

17.4.2 进程和线程间的通信方式

17.4.3 死锁产生的原因和死锁的条件

17.4.4 如何采用单线程处理高并发

17.4.5 线程的状态

17.4.6 进程的状态

17.4.7 系统调用brk和mmap

17.4.8 说说三种内存管理机制

17.4.9 大端和小端，用C++代码怎么确定

17.5.1 TCP和UDP的区别

17.5.2 TCP三次握手

17.5.3 三次握手的原因

17.5.4 TCP四次挥手

17.5.5 四次挥手的原因

17.5.6 TIME_WAIT

17.5.7 Http协议

17.5.8 几种常见的排序算法

17.5.9 链表的一些性质和操作

17.6.1 常见的查找算法

17.6.2 动态规划

17.6.3 关键字 static 的作用是什么？

17.6.4 “引用”与指针的区别是什么？

17.6.5 ..h 头文件中的 ifndef/define/endif 的作用？

17.6.6 #include 与 #include “file.h”的区别？

17.6.7 描述实时系统的基本特性

17.6.8 全局变量和局部变量在内存中是否有区别？如果有，是什么区别？

17.6.9 什么是平衡二叉树？

17.7.1 堆栈溢出一般是由什么原因导致的？

17.7.2 冒泡排序算法的时间复杂度是什么？

17.7.3 什么函数不能声明为虚函数？

17.7.4 队列和栈有什么区别？

17.7.5 不能做 switch()的参数类型

17.7.6 局部变量能否和全局变量重名？

17.7.7 如何引用一个已经定义过的全局变量？

17.7.8 全局变量可不可以定义在可被多个.C 文件包含的头文件中？为什么？

17.7.9 语句 for( ；1 ；)有什么问题？它是什么意思？

17.8.1 do……while 和 while……do 有什么区别？

17.8.2 statac 全局变量、局部变量、函数与普通全局变量、局部变量、函数 static 全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？ static 函数与普通函数有什么区别？

17.8.3 程序的内存分配

17.8.4 解释堆和栈的区别

17.8.5 什么是预编译,何时需要预编译?

17.8.6 关键字 const 是什么含意？

17.8.7 关键字 volatile 有什么含意 并给出三个不同的例子。

17.8.8 三种基本的数据模型

17.8.9 结构与联合有和区别？

17.9.1 描述内存分配方式以及它们的区别?

17.9.2 请说出 const 与#define 相比，有何优点？

17.9.3 简述数组与指针的区别？

17.9.4 分别写出 BOOL,int,float,指针类型的变量 a 与“零”的比较语句。

17.9.5 如何判断一段程序是由 C 编译程序还是由 C++编译程序编译的？

17.9.6 用两个栈实现一个队列的功能？要求给出算法和思路！

17.9.7 嵌入式系统中经常要用到无限循环，你怎么样用 C 编写死循环呢？

17.9.8 位操作（Bit manipulation）

17.9.9 访问固定的内存位置（Accessing fixed memory locations）

18.1.1 中断（Interrupts）

18.1.2 动态内存分配（Dynamic memory allocation）

18.1.3 Typedef

18.1.4 用变量 a 给出下面的定义

18.1.5 写一个“标准”宏

18.1.6 A.c 和 B.c 两个 c 文件中使用了两个相同名字的 static 变量,编译的时候会不会有问题? 这两个 static 变量会保存到哪里（栈还是堆或者其他的）?

18.1.7 一个单向链表，不知道头节点,一个指针指向其中的一个节点，问如何删除这个指针指 向的节点？

18.1.8 比较字符串，输出它们第一个不同字母的位置，大小写不敏感

18.1.9 判断一个数是不是回文数，数字 1234321。

18.2.1 比较两字符串长短，并返回结果。

18.2.2 给一个字符串，编程取其中一个特定的字符并输出。

18.2.3 是比较两个英文字符串的不相同的字符的位置（忽略字母大小写）

18.2.4 主函数调用一函数

18.2.5 输入一个整数n，计算不大于n的数中和7相关的数的个数，包括能被7整出的数和含有字符7的数。

18.2.6 输入一个整数将每一位上的奇数放在一个新整数中，高位放在高位，地位在低位。

18.2.7 输入一串数，将其最小的放在第一位，次小的放在最后一位，再小的放在第二位，再再小的放在倒数第二位，以此类推。

18.2.8 写一个函数，传入参数为应付钱数。返回值为买家最少付出的钱的张数int get MoneyNum(int iInputMoney)例如：买家应付351元，最少张数为5.备注：可支付的钱币只有100、50、10、5、1不考虑2、20以及小数部分。

18.2.9 对姓氏进行排名

18.3.1 将一组整数中为奇数的数提取出来，高低位顺序不变。如：8 3 7 9 5 2 1 4-----》3 7 5 1

18.3.2 一组2n+1个元素的正整形数组，按升序排序，然后将小于中间数值的成员替换为中间的值。

18.3.3 输入一个四位的十进制整数，编程实现将这四位整数转化为十六进制的字符串，并输出十六进制的字符串（注意负数的处理）

18.3.4 介绍一下STL，详细说明STL如何实现vector。

18.3.5 如果用VC开发程序，常见这么几个错误，C2001,c2005,c2011,这些错误的原因是什么。

18.3.6 继承和委派有什么分别，在决定使用继承或者委派的时候需要考虑什么

18.3.7 指针和引用有什么分别；如果传引用比传指针安全，为什么？如果我使用常量指针难道不行吗？

18.3.8 参数传递有几种方式；实现多态参数传递采用什么方式，如果没有使用某种方式原因是什么

18.3.9 结合一个项目说明你怎样应用设计模式的理念。

18.4.1 介绍一下你对设计模式的理解。（这个过程中有很多很细节的问题随机问的）

18.4.2 C++和C定义结构的分别是什么。

18.4.3 构造函数可否是虚汗数，为什么？析构函数呢，可否是纯虚的呢？

18.4.4 拷贝构造函数相关问题，深拷贝，浅拷贝，临时对象等。

18.4.5 结合1个你认为比较能体现OOP思想的项目，用UML来描述。

18.4.6 基类的有1个虚函数，子类还需要申明为virtual吗？为什么。

18.4.7 C也可以通过精心封装某些函数功能实现重用，那C++的类有什么优点吗，难道仅仅是为实现重用。

18.4.8 C++特点是什么，如何实现多态？画出基类和子类在内存中的相互关系。

18.4.9 为什么要引入抽象基类和纯虚函数？

18.5.1 介绍一下模板和容器。如何实现？（也许会让你当场举例实现）

18.5.2 你如何理解MVC。简单举例来说明其应用。

18.5.3 什么是并行计算?

18.5.4 与10.110.12.29mask 255.255.255.224属于同一网段的主机IP地址有哪些？

18.5.5 讲一讲Makefile的内容.

18.5.6 讲一讲C++的内联函数

18.5.7 vector, deque, list, set, map底层数据结构 vector（向量）——STL中标准而安全的数组。只能在vector 的“前面”增加数据。

18.5.8 宏定义的优缺点

18.5.9 bfs和dfs如何遍历

18.6.1 CPU如果访问内存?

18.6.2 找出在A数组中，B数组中没有的数字，在B数组中，A数组中没有的数字

18.6.3 在C++ 程序中调用被C 编译器编译后的函数，为什么要加extern “C”？

18.6.4 头文件中的ifndef/define/endif有什么作用？

18.6.5 ＃include<file.h> 与 ＃include "file.h"的区别？

18.6.6 评价一下C/C++各自的特点

18.6.7 const 有什么用途？

18.6.8 const和#define有什么区别？

18.6.9 关于sizeof小结的。

18.7.1 sizeof与strlen的区别？

18.7.2 指针和引用的区别？

18.7.3 数组和指针的区别？

18.7.4 空指针和悬垂指针的区别？

18.7.5 C++中有malloc/free，为什么还有new/delete？

18.7.6 什么是智能指针？

18.7.7 面向对象技术的基本概念是什么，三个基本特征是什么？

18.7.8 C++空类默认有哪些成员函数？

18.7.9 哪一种成员变量可以在一个类的实例之间共享？

18.8.1 继承层次中，为什么基类析构函数是虚函数？

18.8.2 为什么构造函数不能为虚函数？

18.8.3 如果虚函数是有效的，那为什么不把所有函数设为虚函数？

18.8.4 什么是多态？多态有什么作用？

18.8.5 重载和覆盖有什么区别？

18.8.6 公有继承、受保护继承、私有继承

18.8.7 有哪几种情况只能用构造函数初始化列表而不能用赋值初始化？

18.8.8 什么是虚指针？

18.8.9 C++如何阻止一个类被实例化？一般在什么时候将构造函数声明为private？

18.9.1 main函数执行之前会执行什么？执行之后还能执行代码吗？

18.9.2 请描述进程和线程的区别？

18.9.3 进程间如何通信？

18.9.4 在网络编程中涉及并发服务器，使用多进程与多线程的区别？

18.9.5 TCP和UDP有什么区别。

18.9.6 经常要操作的内存分为那几个类别？

18.9.7 请讲述堆和栈的区别。

18.9.8 全局变量放在数据段，内部变量static int count；

18.9.9 类使用static成员的优点，如何访问？

19.1.1 static数据成员和static成员函数

19.1.2 如何引用一个已经定义过的全局变量？

19.1.3 static关键字的作用

19.1.4 多态类中的虚函数表是 Compile-Time，还是 Run-Time时建立的?

19.1.5 一个父类写了一个 virtual 函数，如果子类覆盖它的函数不加 virtual ,也能实现多态?

19.1.6 完成字符串拷贝可以使用 sprintf、strcpy 及 memcpy 函数，请问这些函数有什么区别，你喜欢使用哪个，为什么？

19.1.7 应用程序在运行时的内存包括代码区和数据区，其中数据区又包括哪些部分？

19.1.8 C++函数中值的传递方式有哪几种?

19.1.9 C++里面是不是所有的动作都是main()引起的？如果不是，请举例.

19.2.1 下列哪两个是等同的

19.2.2 内联函数在编译时是否做参数类型检查？

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

19.2.4 有 A 、 B 、 C 、 D 四个人，要在夜里过一座桥。他们通过这座桥分别需要耗时 1 、 2 、 5 、 10 分钟，只有一支手电，并且同时最多只能两个人一起过桥。请问，如何安排，能够在 17 分钟内这四个人都过桥？

19.2.5 static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？

19.2.6 对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现?

19.2.7 有1,2,....一直到n的无序数组,求排序算法,并且要求时间复杂度为O(n),空间复杂度O(1),使用交换,而且一次只能交换两个数。

19.2.8 sizeof相关系列问题, const相关系列问题

19.2.9 写出二分查找的代码

19.3.1 写出在母串中查找子串出现次数的代码.

19.3.2 查找第一个匹配子串位置,如果返回的是s1长度len1表示没有找到

19.3.3 实现strcpy函数

19.3.4 实现strcmp函数

19.3.5 实现字符串翻转

19.3.6 用指针的方法，将字符串“ABCD1234efgh”前后对调显示

19.3.7 给定字符串A和B,输出A和B中的最大公共子串。比如A="aocdfe" B="pmcdfa" 则输出"cdf"

19.3.8 判断一个字符串是不是回文

19.3.9 写函数完成内存的拷贝

19.4.1 写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)

19.4.2 编写一个 C 函数，该函数在一个字符串中找到可能的最长的子字符串，且该字符串是由同一字符组成的

19.4.3 写出快速排序或者某种排序算法代码

19.4.4 将一个单链表逆序

19.4.5 循环链表的节点对换和删除

19.4.6 有双向循环链表结点定义为

19.4.7 写出程序删除链表中的所有接点

19.4.8 线形表a、b为两个有序升序的线形表，编写一程序，使两个有序线形表合并成一个有序升序线形表h

19.4.9 怎么判断链表中是否有环？

19.5.1 static有什么用途？（请至少说明两种）

19.5.2 引用与指针有什么区别？

19.5.3 全局变量和局部变量在内存中是否有区别？如果有，是什么区别？

19.5.4 static变量和static 函数各有什么特点？

19.5.5 static全局变量与普通的全局变量有什么区别？

19.5.6 static函数与普通函数有什么区别

19.5.7 什么是平衡二叉树？

19.5.8 什么函数不能声明为虚函数？

19.5.9 写出float x 与“零值”比较的if语句

19.6.1 进程间通信的方式有?

19.6.2 const 符号常量

19.6.3 c和c++中的struct有什么不同？

19.6.4 纯虚函数如何定义？使用时应注意什么？

19.6.5 数组和链表的区别

19.6.6 线程与进程的区别和联系? 线程是否具有相同的堆栈? dll是否有独立的堆栈?

19.6.7 一语句实现x是否为2的若干次幂的判断

19.6.8 计算结果题目

19.6.9 输出下面程序结果

19.7.1 写出程序运行结果

19.7.2 求函数返回值，输入x=9999

19.7.3 用户输入M,N值，从1至N开始顺序循环数数，每数到M输出该数值，直至全部输出。写出C程序

19.7.4 有10亿个浮点数，求出其中最大的10000个 ,用了标准库的，不让用的话，只能自己写堆函数

19.7.5 在不用第三方参数的情况下，交换两个参数的值 感觉比较:( , bt 而且还是基础题

19.7.6 写一段程序，找出数组中第k大小的数，输出数所在的位置

19.7.7 求1000！的未尾有几个0（用素数相乘的方法来做，如72=22233）

19.7.8 编程实现：把十进制数(long型)分别以二进制和十六进制形式输出，不能使用printf系列库函数

19.7.9 输入N, 打印 N*N 矩阵

19.8.1 斐波拉契数列递归实现的方法如下

19.8.2 将一个数字字符串转换为数字."1234" -->1234

19.8.3 编程实现：把十进制数(long型)分别以二进制和十六进制形式输出，不能使用printf系列库函数

19.8.4 实现任意长度的整数相加或者相乘功能

19.8.5 用递归算法判断数组a[N]是否为一个递增数组

19.8.6 给两个数组和他们的大小，还有一动态开辟的内存，求交集，把交集放到动态内存dongtai，并且返回交集个数

19.8.7 用两个栈实现一个队列的功能？要求给出算法和思路！

19.8.8 求组合数： 求n个数（1....n）中k个数的组合.... 如：combination(5,3)

19.8.9 下面是C语言中两种if语句判断方式。请问哪种写法更好？为什么？

19.9.1 下面的代码有什么问题？

19.9.2 下面的代码有什么问题？并请给出正确的写法。

19.9.3 下面代码有什么错误?

19.9.4 下面代码有什么问题?

19.9.5 下面的代码有什么问题？

19.9.6 下面的代码有什么问题？

19.9.7 下面的代码有什么问题？

19.9.8 下面这个程序执行后会有什么错误或者效果

19.9.9 请找出下面代码中的所以错误

20.1.1 请问下面程序有什么错误?

20.1.2 32位，64位系统中，各种常用内置数据类型占用的字节数？

20.1.3 悬空指针与野指针区别

20.1.4 vector、map、multimap底层数据结构

20.1.5 C++的内存分区

20.1.6 结构与联合有和区别？

20.1.7 将“引用”作为函数参数有哪些特点？

20.1.8 多态，虚函数，纯虚函数

20.1.9 delete与 delete []区别

20.2.1 new、delete、malloc、free关系

20.2.2 链表和数组存储线性表的比较

20.2.3 C语言中链表的特点

20.2.4 C语言中链表定义及结构

20.2.5 C++中的临时对象

20.2.6 C++中的析构函数

20.2.7 C++中对象的构造的顺序

20.2.8 C++中赋值和初始化的区别

20.2.9 C++类成员的初始化

20.3.1 C++什么时候需要进行深拷贝

20.3.2 拷贝构造函数的意义

20.3.3 C++中对象的声明和定义

20.3.4 C++中带参数的构造函数

20.3.5 C++中的构造函数

20.3.6 C++对象初始化

20.3.7 C++面向对象的意义

20.3.8 C++中类之间的基本关系

20.3.9 C++中类成员的作用域

20.4.1 C++中类的关键字

20.4.2 C++中类声明和实现的分离

20.4.3 C++中的命名空间

20.4.4 C和C++相互调用

20.4.5 函数重载的定义、条件、注意事项

20.4.6 C++中 inline 内联编译的限制

20.4.7 内联函数的定义和特点

20.4.8 C++引用的意义

20.4.9 C++引用的本质

20.5.1 C++中特殊的引用--const引用

20.5.2 C 到 C++ 的升级

20.5.3 C和C++语言中的三目运算符

20.5.4 宏的局限和妙用

20.5.5 C 语言中的顺序点

20.5.6 C/C++语言中的函数参数

20.5.7 声明和定义

20.5.8 C/C++语言中内存操作的交通规则

20.5.9 C/C++语言中常见的内存错误

20.6.1 内存操作的基本原则

20.6.2 C/C++语言中野指针的含义

20.6.3 C/C++语言中文件布局在内存中的映射

20.6.4 C/C++语言中程序与进程

20.6.5 C/C++程序中的静态存储区

20.6.6 C/C++程序中的堆

20.6.7 C语言中calloc 和 realloc 函数

20.6.8 malloc和free函数及使用过程需要注意的地方

20.6.9 C语言中动态内存分配

20.7.1 C语言中的指针阅读技巧

20.7.2 C语言中的函数指针

20.7.3 C语言中指向指针的指针

20.7.4 C语言中的数组指针和指针数组

20.7.5 C语言中字符串相等的比较

20.7.6 C语言中的字符串和字符数组

20.7.7 数组参数

20.7.8 数组的访问方式

20.7.9 数组地址与数组名

20.8.1 C++中类封装的基本概念

20.8.2 C++中的引用基本点

20.8.3 函数设计原则

20.8.4 C语言中的回调函数

20.8.5 C语言中二维数组参数

20.8.6 数组的本质

20.8.7 数组的含义

20.8.8 C语言中#pragma 的使用

20.8.9 C语言中#line的用法

20.9.1 C语言中#error的用法

20.9.2 c语言中数组参数退化为指针的意义

20.9.3 程序中的顺序点

20.9.4 面向过程的程序设计

20.9.5 C语言中的函数类型

20.9.6 C语言二维数组与二级指针

20.9.7 C语言中字符串的长度

20.9.8 指针的运算

20.9.9 数组名的知识点

21.1.1 C语言中的条件编译

21.1.2 C语言中函数和宏定义的对比

21.1.3 c语言中动态库和静态库的使用

21.1.4 c语言中的逗号表达式

21.1.5 C语言中的单引号和双引号

21.1.6 C语言中接续符和转义符

21.1.7 C语言中union关键字

21.1.8 C语言中变量的属性关键字

21.1.9 c语言中enum关键字的作用

21.2.1 C语言中sizeof关键字的作用

21.2.2 c语言中extern关键字的作用

21.2.3 C语言中volatile关键字的作用

21.2.4 C语言中const关键字的作用

21.2.5 ‘#’与‘##’的区别

21.2.6 如何引用一个已经定义过的全局变量？

21.2.7 大小端问题

21.2.8 typedef关键字

21.2.9 什么是封装？C++中是如何实现的？

21.3.1 C与C++各自是如何定义常量的？有什么不同？

21.3.2 内存的分配方式的分配方式有几种?

21.3.3 头文件中的 ifndef/define/endif 干什么用?

21.3.4 什么是预编译？何时需要预编译？

21.3.5 在C++程序中调用被C编译器编译后的函数，为什么要加extern“C”声明?

21.3.6 memset ,memcpy 的区别

21.3.7 一下三种指针的区别？

21.3.8 “常量指针”和“指针常量”有什么区别？

 详见：https://github.com/0voice/interview_internal_reference