仿函数

（1）定义

仿函数又称为函数对象，是一个能行使函数功能的类。仿函数的语法几乎和我们普通的函数调用一样，不过作为仿函数的类，都必须重载 operator() 运算符。因为调用仿函数，实际上就是通过类对象调用重载后的 operator() 运算符

（2）使用

①仿函数方式

class Sort{  
public:  bool operator()(int a,int b) const {return a > b;}   
};
class Display{
public:void operator()(int a) const{cout << a << endl;} 
};
int main()  
{  int arr[5] = { 4, 1, 2, 5, 6 }; sort(arr, arr+5,Sort());  for_each(arr,arr+5,Display());return 0;   
}

②仿函数模板方式

template<class T>
class Sort{  
public:  inline bool operator()(T const& a,T const& b) const {return a > b;}   
};
template<class T>
class Display{
public:inline void operator()(T const& a) const{cout << a << endl;} 
};
int main()  
{  int arr[5] = { 4, 1, 2, 5, 6 }; sort(arr, arr+5,Sort<int>());  for_each(arr,arr+5,Display<int>());return 0;   
}

（3）STL的仿函数

深拷贝和浅拷贝

（1）深拷贝

每个对象共同拥有自己的资源，必须显式提供拷贝构造函数和赋值运算符

（2）浅拷贝

多个对象共用同一块资源，若同一块资源被释放多次，则会崩溃或者内存泄漏

动态链接库和静态链接库

（1）静态链接库

把(lib)文件中用到的函数代码直接链接进目标程序，程序运行的时候不再需要其它的库文件

（2）动态链接库

把调用的函数所在文件模块（DLL）和调用函数在文件中的位置等信息链接进目标程序，程序运行的时候再从DLL中寻找相应函数代码，因此需要相应DLL文件的支持

（3）区别

• 采用静态链接库，lib中的指令都全部被直接包含在最终生成的exe文件中；采用动态链接库，dll不必被包含在最终exe文件中，exe文件执行时可以“动态”地引用和卸载这个与exe独立的dll文件

• 静态链接库中不能再包含其他的动态链接库或者静态库；动态链接库中可以再包含其他的动态或静态链接库

• 动态链接库在需要调用其中的函数时，根据函数映射表找到该函数然后调入堆栈执行，如果在当前工程中有多处对dll文件中同一个函数的调用，那么执行这个函数只会留下一份拷贝；静态链接库中，如果在当前工程中有多处对lib文件中同一个函数的调用，那么执行时，该函数将在当前程序的执行空间里留下多份拷贝，而且是一处调用就产生一份拷贝。

（4）静态链接库优点与不足

①优点

• 代码装载速度快，执行速度略比动态链接库快； 

• 只需保证在开发者的计算机中有正确的lib文件，在以二进制形式发布程序时不需考虑在用户的计算机上lib文件是否存在及版本问题

②不足 

使用静态链接生成的可执行文件体积较大，包含相同的公共代码，造成浪费

（5）动态链接库优点与不足

①优点

• 更加节省内存并减少页面交换；

• dll文件与exe文件独立，只要输出接口不变（即名称、参数、返回值类型和调用约定不变），更换dll文件不会对exe文件造成任何影响，因而极大地提高了可维护性和可扩展性；

• 不同编程语言编写的程序只要按照函数调用约定就可以调用同一个dll函数；

• 适用于大规模的软件开发，使开发过程独立、耦合度小，便于不同开发者和开发组织之间进行开发和测试。

②不足 

使用动态链接库的应用程序不是自完备的，它依赖的DLL模块也要存在，如果使用载入时动态链接，程序启动时发现DLL不存在，系统将终止程序并给出错误信息。而使用运行时动态链接，系统不会终止，但由于DLL中的导出函数不可用，程序会加载失败；速度比静态链接慢。当某个模块更新后，如果新模块与旧的模块不兼容，那么那些需要该模块才能运行的软件，统统撕掉。

select，poll，epoll三者之间的区别

（1）IO多路复用的机制

select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。  

（2）select（时间复杂度为O(n)）

它仅仅知道有I/O事件发生了，却并不知道是哪几个流（可能有一个，多个，甚至全部），只能无差别轮询所有流，找出能读出数据，或者写入数据的流，对他们进行操作。所以select具有O(n)的无差别轮询复杂度，同时处理的流越多，无差别轮询时间就越长。

缺点：

• 能监听端口的大小有限

• 采用轮询的方法，效率较低

• 需要维护一个用来存放大量fd的数据结构，这样会使得用户空间和内核空间在传递该结构时复制开销大

（3）poll（时间复杂度为O(n)）

poll本质上和select没有区别，它将用户传入的数组拷贝到内核空间，然后查询描述符中每个索引对应的设备状态， 但是它没有最大连接数的限制，因为它是基于链表来存储的.

缺点：

• 大量fd的数组被整体复制于用户态和内核地址空间之间，不管这样的复制是不是有意义

• 报告了fd后，没有被处理，那么下次poll时会再次报告该fd

（4）epoll（时间复杂度为O(1)）

不同于忙轮询和无差别轮询，epoll会把哪个流发生了怎样的I/O事件通知我们。

优点：

• 虽然连接数有上限，但是很大

• 只有活跃可用的FD才会调用callback函数，效率提高

• epoll使用mmap减少复制开销

（5）注意

• 表面上看epoll的性能最好，但是在连接数少并且连接都十分活跃的情况下，select和poll的性能可能比epoll好，毕竟epoll的通知机制需要很多函数回调。

• select低效是因为每次它都需要轮询。但低效也是相对的，视情况而定，也可通过良好的设计改善 

（6）水平触发和边沿触发

• select和poll属于水平触发

• epoll有水平触发和边缘触发两种触发模式，水平触发是默认的模式

①水平触发

当被监控的文件描述符上有可读写事件发生时，会通知用户程序去读写，如果用户一次读写没取完数据，他会一直通知用户，如果这个描述符是用户不关心的，它每次都返回通知用户，则会导致用户对于关心的描述符的处理效率降低。

②边缘触发

当被监控的文件描述符上有可读写事件发生时，会通知用户程序去读写，它只会通知用户进程一次，这需要用户一次把内容读取玩，相对于水平触发，效率更高。如果用户一次没有读完数据，再次请求时，不会立即返回，需要等待下一次的新的数据到来时才会返回，这次返回的内容包括上次未取完的数据。

（7）fd

进程独有的文件描述符表的索引

delete[]和delete的区别

（1）针对简单类型，使用new分配后的不管是数组还是非数组形式内存空间用两种方式均可

原因在于：分配简单类型内存时，内存大小已经确定，系统可以记忆并且进行管理，在析构时，系统并不会调用析构函数

（2）针对类Class，两种方式体现出具体差异 

delete a：只调用了a[0]对象的析构函数，剩下的都没有调用，造成内存泄漏

delete [] a：调用全部的对象的析构函数

class A{private:char *m_cBuffer;int m_nLen;public:A(){ m_cBuffer = new char[m_nLen]; }~A() { delete [] m_cBuffer; }};A *a = new A[10];delete a;   

delete[]如何知道size

• 使用一个记录分配空间大小的内存小块绑定在分配内存的地址头部（四个字节）

• 使用表来对分配了的指针进行管理，每一个分配了空间的指针都在表中对应着分配空间的大小

 constexpr、volatile、explicit、mutable作用

（1）explicit（只能用于一个参数或n个参数，但是n-1个提供默认值）

被explicit关键字修饰的类构造函数，不能进行自动地隐式类型转换，只能显式地进行类型转换

（2）mutable

被mutable修饰的变量，将永远处于可变的状态，即使在一个const函数中。

#include <iostream>class Person {
public:Person();~Person();int getAge() const; /*调用方法*/
private:int age;char *name;float score;mutable int m_nums;            /*用于统计次数*/
};Person::Person()
{m_nums = 0;
}Person::~Person(){}int Person::getAge() const
{std::cout << "Calling the method" << std::endl;m_nums++;// age = 4; 仍然无法修改该成员变量return age;
}

（3）volatile

volatile提醒编译器它后面所定义的变量随时都有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数据。如果没有volatile关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值

（4）constexpr

• const指的是编译期常量和运行时常量（编译期定义，但是可以在运行时初始化）

• constexpr特指编译期常量（需要在编译期定义并初始化）

switch和多重if else区别及switch对小范围case和大范围case的处理

（1）switch

①小范围case

生成一张跳转表，把值作为索引，直接跳转到对应的地址

②大范围case

不生成跳转表

（2）if else

逐个比较，跳转，效率较低

_stdcall _cdecl _fastcall

（1）_stdcall

参数采用从右到左的压栈方式，被调函数自身在返回前清空堆栈

（2）_cdecl

参数采用从右到左的压栈方式，传送参数的内存栈由调用者维护

（3）_fastcall

调用较快，它通过CPU内部寄存器传递参数

数组指针和指针数组

（1）数组指针

它是一个指针，指向一个数组

char a[5] = { 'A','B','C','D','\0'};
char(*p3)[5] = &a;//指向一个数组a
cout << *p3 << endl;

（2）指针数组

它是一个数组，数组的元素都是指针

int *p1[10];//p1是数组名，有10个元素，元素类型为int*（因为[]优先级高于*）

指针与数组的区别（char *a 与char a[] ）

（1）定义

数组：存储的连续多个相同类型的数据

指针：变量，存的是地址

（2）sizeof

数组：整个数组所占的内存空间

指针：指针所占的字节数

（3）注意

数组名被编译器当作一个指向该数组第一个元素的指针

数组的下标与指针的偏移量相同

传参时，数组名被编译器当作指向该数组第一个元素的指针

（4）指针与数组名区别

指针是一个变量，有自己对应的存储空间，而数组名仅仅是一个符号，不是变量，因而没有自己对应的存储空间

指针所占内存判断

#include <algorithm>
#include <iostream>
using namespace std;int main()
{//在32位中，指针占用的内存大小的4个字节，()和[]的优先级一样，结核性从左到右，且都比*优先级要高double** a1[3][4];//[]优先级大于*，则有3*4=12个指针，所以占的内存为：3*4*4=48double(**a2)[3][4];//(**a)表示一个指针，所以占的内存为4double* (*a3)[3][4];//(*a)表示一个指针，所以占的内存为4double* (*a4[3])[4];//(*a4[3])有三个指针，所以占的内存为3*4=12double* (**a5[2][3])[4];//(**a5[2][3])有2*3=6个指针，所以占的内存为6*4=24cout << sizeof(a1) << endl << sizeof(a2) << endl << sizeof(a3) << endl << sizeof(a4) << endl << sizeof(a5) << endl;
}

硬件和软件

（1）硬件

电脑中的实物设备：主机，显示屏之类的

（2）软件

• 系统软件：操作系统，网络系统软件。系统服务器程序之类的

• 应用软件：office软件，微信，qq之类的

（3）硬件环境

计算机及其外围设备组成的计算机物理系统，即硬件设施

（4）软件环境 

运行于计算机硬件之上的驱动计算机及其外围设备实现某种目的的软件系统

变量名的命名规则

• 在名称中只能使用字母字符、数字和下划线

• 名称的第一个字符不能是数字

• 区分大写和小写字符

• 不能将C++的关键字作为名称

• 以两个下划线或下划线和大写字母开头的名称被保留给实现使用；以一个下划线开头的名称被保留给实现，用做全局标识符

short sam = SHRT_MAX;//sam=32767
unsigned short sue = sam;//sue=32767
sam += 1;//sam=-32768
sue += 1;//sue=32768
sam = ZERO;//sam=0
sue = ZERO;//sue=0
sam -= 1;//sam=-1
sue -= 1;//sue=65535

#include <iostream>using namespace std;template <typename T>
void fun(T a)
{cout << "void fun(T1 a)" << endl;
}template <typename T1, typename T2>
void fun(T1 a, T2 b)
{cout << "void fun(T1 a, T2 b)" << endl;
}void fun(int a, float b)
{cout << "void fun(int a, float b)" << endl;
}void main()
{int a = 0;float b = 0.0;fun(a);   fun(a, b);	//普通函数void fun(int a, float b)已经能完美匹配，于是调用普通函数fun(b, a);	//这个调用，函数模板有更好的匹配，于是调用函数模板fun<>(a, b);	//限定只使用函数模板
}

#include <iostream>
using namespace std;
struct person {string name;int age;
};
template <typename T>
void Swap(T& a, T& b) {T tem;tem = a;a = b;b = tem;
}
template<>void Swap(person& a, person& b) {int tem;tem = a.age;a.age = b.age;b.age = tem;
}int main() {person p1 = { "Tony",12 };person p2 = { "Jenny",14 };Swap(p1, p2);//显示具体化cout << p1.name << " " << p1.age << endl;//Tony 14cout << p2.name << " " << p2.age << endl;//Jenny 12int a = 1;int b = 2;Swap(a, b);//隐式实例化cout << a << " " << b << endl;//2 1double c = 1.5;double d = 2.5;Swap<double>(c, d);//显示实例化cout << c << " " << d << endl;
}