c++面试个人知识点记录

小咪咪 2022-05-17 07:50 183阅读 0赞

**目录**

1）C/C++基础

C和C++区别：

什么是面向对象：

虚函数：

C++内存管理：

New和malloc的区别：

多线程编程：

进程间通信：

内存映射：

双缓冲：

Socket：

函数参数入栈：

MFC：

2）操作系统

3）计算机网络

4）图像采集TWAIN协议

--------------------

## 1）C/C++基础 ##

### C和C++区别： ###

首先就是C和C++区别，这里转载一篇面试总结 [https://blog.csdn.net/bitboss/article/details/62884694][https_blog.csdn.net_bitboss_article_details_62884694]

C语言是面向过程的编程，它最重要的特点是函数，通过main函数来调用各个子函数。程序运行的顺序都是程序员事先决定好的。

C++是面向对象的编程，类是它的主要特点，在程序执行过程中，先由主main函数进入，定义一些类，根据需要执行类的成员函数，过程的概念被淡化了（实际上过程还是有的，就是主函数的哪些语句），以类驱动程序运行，类就是对象，所以我们称之为面向对象程序设计。面向对象在分析和解决问题的时候，将涉及到的数据和数据的操作封装在类中，通过类可以创建对象，以事件或消息来驱动对象执行处理。

C语言和C++的最大区别在于它们解决问题的思想方法不一样。C语言主要用于嵌入式领域，驱动开发等与硬件直接打交道的领域， C++可以用于应用层开发，用户界面开发等于操作系统打交道的领域。

C++既继承了C强大的底层操作特性，又被赋予了教科书式的面向对象机制。它特性繁多，有其他面向对象语言鲜见的多继承，有耐人寻味的对值传递与引用传递入木三分的区分以及const关键字，等等。C++就像是一把瑞士军刀，或者像是一个工具箱，它为你提供尽可能多的工具，多到让不熟悉它的人无所适从，让懂得如何使用它的人如鱼得水。C++的种种特性使得它非常适合用来编写底层数据结构，算法，库等，是系统软件开发以及数学模型构建等的强大武器库，被誉为工业级编程语言。

C++对C的“增强”，表现在以下几个方面：

类型检查更为严格。增加了面向对象的机制。增加了泛型编程的机制（Template）。增加了异常处理。增加了运算符重载。增加了标准模板库（STL）。增加了命名空间，避免全局命名冲突。

### 什么是面向对象： ###

面向对象是一种思想，是基于面向过程而言的，就是说面向对象是将功能等通过对象来实现，将功能封装进对象之中，让对象去实现具体的细节；这种思想是将数据作为第一位，而方法或者说是算法作为其次，这是对数据一种优化，操作起来更加的方便，简化了过程。

面向对象有三大特征：**封装性、继承性、多态性**

**封装性**：指的是隐藏了对象的属性和实现细节，仅对外提供公共的访问方式，这样就隔离了具体的变化，便于使用，提高了复用性和安全性。

**继承性**：就是两种事物间存在着一定的所属关系，那么继承的类就可以从被继承的类中获得一些属性和方法；这就提高了代码的复用性。继承是作为多态的前提的。

**多态性**：父类或接口的引用指向了子类对象，这就提高了程序的扩展性，也就是说只要实现或继承了同一个接口或类，那么就可以使用父类中相应的方法，提高程序扩展性，但是多态有一点不好之处在于：父类引用不能访问子类中的成员。多态是通过虚函数实现的。简单的说，就是一句话：允许将子类类型的[指针][Link 1]赋值给父类类型的指针。

class A
    {
    public:
        A(){}
        virtual void foo()
        {
            cout<<"This is A."<<endl;
        }
    };
     
    class B: public A
    {
    public:
        B(){}
        void foo()
        {
            cout<<"This is B."<<endl;
        }
    };
     
    int main(int argc, char *argv[])
    {
        A *a = new B();
        a->foo();
        if(a != NULL)
        delete a;
        return 0;
    }

上面的列子会显示This is B.如果把virtual去掉，将显示：This is A.前面的多态通过使用[虚函数][Link 2]virtual void foo()来实现。

### 虚函数： ###

在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数，用法格式为：

virtual 函数返回类型 函数名（参数表） \{函数体\}；

实现多态性，通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数，多态性是将接口与实现进行分离。我们只需在把基类的成员函数设为virtual，其派生类的相应的函数也会自动变为虚函数。

### C++内存管理： ###

分为5个储存区：[https://www.cnblogs.com/mrlsx/p/5411874.html][https_www.cnblogs.com_mrlsx_p_5411874.html]

栈（Stack）：局部变量，函数参数等存储在该区，由编译器自动分配和释放.栈属于计算机系统的数据结构，进栈出栈有相应的计算机指令支持，而且分配专门的寄存器存储栈的地址，效率分高，内存空间是连续的，但栈的内存空间有限。

堆(Heap)：需要程序员手动分配和释放（new,delete），属于动态分配方式。内存空间几乎没有限制，内存空间不连续，因此会产生内存碎片。操作系统有一个记录空间内存的链表，当收到内存申请时遍历链表，找到第一个空间大于申请空间的堆节点，将该节点分配给程序，并将该节点从链表中删除。一般，系统会在该内存空间的首地址处记录本次分配的内存大小，用于delete释放该内存空间。

全局/静态存储区:全局变量，静态变量分配到该区，到程序结束时自动释放，包括DATA段（全局初始化区）与BBS段（全局未初始化段）。其中，初始化的全局变量和静态变量存放在DATA段，未初始化的全局变量和静态变量存放在BBS段。BBS段特点：在程序执行前BBS段自动清零，所以未初始化的全局变量和静态变量在程序执行前已经成为0.

文字常量区：存放常量，而且不允许修改。程序结束后由系统释放。

程序代码区：存放程序的二进制代码

### New和malloc的区别： ###

[https://blog.csdn.net/happyxieqiang/article/details/50775847][https_blog.csdn.net_happyxieqiang_article_details_50775847]

（1） **new 返回指定类型的指针，并且可以自动计算所需要大小。而 malloc 则必须要由我们计算字节数，并且在返回后强行转换为实际类型的指针。**   
例：

//new
    int *p; 　　
    p = new int; //返回类型为int* 类型(整数型指针)，分配大小为 sizeof(int); 
    int* parr; 　　
    parr = new int [100]; //返回类型为 int* 类型(整数型指针)，分配大小为sizeof(int) * 100;
    
    //malloc
    int* p; 　　
    p = (int *) malloc (sizeof(int)*128);//分配128个（可根据实际需要替换该数值）整型存储单元，并将这128个连续的整型存储单元的首地址存储到指针变量p中  
    double *pd=(double *) malloc (sizeof(double)*12);//分配12个double型存储单元，并将首地址存储到指针变量pd中

（2） **malloc 只管分配内存，并不能对所得的内存进行初始化，所以得到的一片新内存中，其值将是随机的。new创建的对象可以用初始化变量的方式初始化。**

除了分配及最后释放的方法不一样以外，通过malloc或new得到指针，在其它操作上保持一致。

### 多线程编程： ###

其实C++语言本身并没有提供多线程机制，但Windows系统为我们提供了相关API，我们可以使用它们来进行多线程编程。

**基本概念：**

1.  **进程。**程序是计算机指令的集合。它以文件的形式存储在磁盘上。进程通常被定义为一个正在运转的程序的实例，是一个程序在其自身地址空间中的一次执行活动。是并发执行的程序在执行过程中分配和管理资源的基本单位，是一个动态概念，竞争计算机系统资源的基本单位。
2.  **线程**。是进程的一个执行单元，是进程内科调度实体。比进程更小的独立运行的基本单位。线程也被称为轻量级进程。一个程序至少一个进程，一个进程至少一个线程。

进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。线程是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

在Windows的多线程编程中，创建线程的函数主要有CreateThread和\_beginthread（及\_beginthreadex）。

3. **互斥对象（mutex）**。属于内核对象。能够确保线程拥有对单个资源的互斥访问权。创建互斥对象需要使用CreateMutex函数。

使用互斥对象还会用到的两个函数是 WaitForSingleObject和ReleaseMutex，函数声明可以百度或查阅MSDN，这两个函数的功能分别是申请互斥对象的拥有权和释放互斥对象的拥有权。线程必须主动申请共享对象的使用权才有可能得到该所有权。

如果一个线程拥有了一个互斥对象后，当该线程运行完成后就要释放该互斥对象，不然其他的线程得不到互斥对象则无法运行。用ReleaseMutex(HWND)它的具体作用是每调用它一次将互斥对象的计数器减一，直到减到零为止，此时释放互斥对象，并将互斥对象中的线程id置零。它的使用条件是，互斥对象在哪个线程中被创建，就在哪个线程里面释放。因为调用的时候会检查当前线程的id是不是  
与互斥对象中保存的id一致，若一致，则此次操作有效，不一致，则无效。

通过互斥对象也可以保证一个应用程序只有一个实例运行。

4.**线程同步**。除了之前的互斥对象实现线程同步，还有事件对象和关键代码段两种方法。

### 进程间通信： ###

**进程间通信**（Interprocess Communication, IPC）,经典的IPC：管道、FIFO、消息队列、信号量以及共享存储和套接字。

MFC上说的是剪贴板、匿名管道、命名管道、邮槽：

### 内存映射： ###

WIN32的内存映射文件确实允许我们分配一个装得下现实中可能存在的足够大的文件的内存。利用内存映射文件您可以认为操作系统已经为您把文件全部装入了内存，然后您只要移动文件指针进行读写即可了。这样您甚至不需要调用那些分配、释放内存块和文件输入/输出的API函数，另外您可以把这用作不同的进程之间共享数据的一种办法。运用内存映射文件实际上没有涉及实际的文件操作，它更象为每个进程保留一个看得见的内存空间。至于把内存映射文件当成进程间共享数据的办法来用，则要加倍小心，因为您不得不处理数据的同步问题，否则您的应用程序也许很可能得到过时或错误的数据甚至崩溃。

内存映射文件与虚拟内存有些类似，通过内存映射文件可以保留一个地址空间的区域，同时将物理存储器提交给此区域，只是内存文件映射的物理存储器来自一个已经存在于磁盘上的文件，而非系统的页文件，而且在对该文件进行操作之前必须首先对文件进行映射，就如同将整个文件从磁盘加载到内存。由此可以看出，使用内存映射文件处理存储于磁盘上的文件时，将不必再对文件执行I/O操作，这意味着在对文件进行处理时将不必再为文件申请并分配缓存，所有的文件缓存操作均由系统直接管理，由于取消了将文件数据加载到内存、数据从内存到文件的回写以及释放内存块等步骤，使得内存映射文件在处理大数据量的文件时能起到相当重要的作用。另外，实际工程中的系统往往需要在多个进程之间共享数据，如果数据量小，处理方法是灵活多变的，如果共享数据容量巨大，那么就需要借助于内存映射文件来进行。实际上，内存映射文件正是解决本地多个进程间数据共享的最有效方法。  
内存映射文件并不是简单的文件I/O操作，实际用到了Windows的核心编程技术--内存管理。

首先要通过CreateFile()函数来创建或打开一个文件内核对象，这个对象标识了磁盘上将要用作内存映射文件的文件。在用CreateFile()将文件映像在物理存储器的位置通告给操作系统后，只指定了映像文件的路径，映像的长度还没有指定。为了指定文件映射对象需要多大的物理存储空间还需要通过CreateFileMapping()函数来创建一个文件映射内核对象以告诉系统文件的尺寸以及访问文件的方式。在创建了文件映射对象后，还必须为文件数据保留一个地址空间区域，并把文件数据作为映射到该区域的物理存储器进行提交。由MapViewOfFile()函数负责通过系统的管理而将文件映射对象的全部或部分映射到进程地址空间。此时，对内存映射文件的使用和处理同通常加载到内存中的文件数据的处理方式基本一样，在完成了对内存映射文件的使用时，还要通过一系列的操作完成对其的清除和使用过资源的释放。这部分相对比较简单，可以通过UnmapViewOfFile()完成从进程的地址空间撤消文件数据的映像、通过CloseHandle()关闭前面创建的文件映射对象和文件对象。

### 双缓冲： ###

双缓冲甚至是多缓冲，在许多情况下都很有用。一般需要使用双缓冲区的地方都是由于“生产者”和“消费者”供需不一致所造成的。这样的情况在很多地方后可能会发生，使用多缓冲可以很好的解决。我举几个常见的例子：

**例 1**. 在网络传输过程中数据的接收，有时可能数据来的太快来不及接收导致数据丢失。这是由于“发送者”和“接收者”速度不一致所致，在他们之间安排一个或多个缓冲区来存放来不及接收的数据，让速度较慢的“接收者”可以慢慢地取完数据不至于丢失。

** 例2.** 再如，计算机中的三级缓存结构：外存（硬盘）、内存、高速缓存（介于CPU和内存之间，可能由多级）。从左到右他们的存储容量不断减小，但速度不断提升，当然价格也是越来越贵。作为“生产者”的 CPU 处理速度很快，而内存存取速度相对CPU较慢，如果直接在内存中存取数据，他们的速度不一致会导致 CPU  能力下降。因此在他们之间又增加的高速缓存来作为缓冲区平衡二者速度上的差异。

**例3**. 在图形图像显示过程中，计算机从显示缓冲区取数据然后显示，很多图形的操作都很复杂需要大量的计算，很难访问一次显示缓冲区就能写入待显示的完整图形数据，通常需要多次访问显示缓冲区，每次访问时写入最新计算的图形数据。而这样造成的后果是一个需要复杂计算的图形，你看到的效果可能是一部分一部分地显示出来的，造成很大的闪烁不连贯。而使用双缓冲，可以使你先将计算的中间结果存放在另一个缓冲区中，但全部的计算结束，该缓冲区已经存储了完整的图形之后，再将该缓冲区的图形数据一次性复制到显示缓冲区。

例1 中使用双缓冲是为了防止数据丢失，例2 中使用双缓冲是为了提高 CPU 的处理效率，而例3使用双缓冲是为了防止显示图形时的闪烁延迟等不良体验。

### Socket： ###

socket即套接字，用于描述地址和端口，是一个通信链的句柄。应用程序通过socket向网络发出请求或者回应。

sockets(套接字)编程有三种，流式套接字（SOCK\_STREAM），数据报套接字（SOCK\_DGRAM），原始套接字（SOCK\_RAW）；前两种较常用。基于TCP的socket编程是采用的流式套接字。

**编程步骤**

**（1）服务端**

1、加载套接字库，创建套接字（WSAStartup()/socket()）;

2、绑定套接字到一个IP地址和一个端口上（bind()）;

3、将套接字设置为监听模式等待连接请求（listen()）；

4、请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字（accept()）；

5、用返回的套接字和客户端进行通信（send()/recv()）；

6、返回，等待另一个连接请求；

7、关闭套接字，关闭加载的套接字库（closesocket()/WSACleanup()）；

**（2）客户端**

1、加载套接字库，创建套接字（WSAStartup()/socket()）；

2、向服务器发出连接请求（connect()）；

3、和服务器进行通信（send()/recv()）；

4、关闭套接字，关闭加载的套接字库（closesocket()/WSACleanup()）；

### 函数参数入栈： ###

[https://blog.csdn.net/u012329294/article/details/12447405][https_blog.csdn.net_u012329294_article_details_12447405]

从右到左的参数方式，原因是参数都是用压栈方式实现的，使用从右到左的传参方式,栈顶看到的就是左边输入的首参数,因此,无论怎样的变长,都可以通过指针偏移的方式找到值。而从左到右的话，栈顶看到的是最后一个参数，并不知道这个参数长度,那么就无法通过指针偏移的方式找到首参数。

这里[https://blog.csdn.net/weichaohnu/article/details/8798581][https_blog.csdn.net_weichaohnu_article_details_8798581]

void foo(int x, int y, int z)
    {
            printf("x = %d at [%X]\n", x, &x);
            printf("y = %d at [%X]\n", y, &y);
            printf("z = %d at [%X]\n", z, &z);
    }
    int main(int argc, char *argv[])
    {
            foo(100, 200, 300);
            return 0;
    }

运行结果是：

x = 100 at \[...60\]

y = 200 at \[...64\]

z = 300 at \[...68\]

这是由于，C程序栈的内存生长方式是往低地址内存生长，这也说明为什么局部变量无法申请太大内存，因为栈内容有限。此外，这个例子说明，函数参数的入栈的顺序是从右往左的！

### MFC： ###

## 2）操作系统 ##

## 3）计算机网络 ##

## 4）图像采集TWAIN协议 ##

[https_blog.csdn.net_bitboss_article_details_62884694]: https://blog.csdn.net/bitboss/article/details/62884694
[Link 1]: https://baike.baidu.com/item/%E6%8C%87%E9%92%88/2878304
[Link 2]: https://baike.baidu.com/item/%E8%99%9A%E5%87%BD%E6%95%B0
[https_www.cnblogs.com_mrlsx_p_5411874.html]: https://www.cnblogs.com/mrlsx/p/5411874.html
[https_blog.csdn.net_happyxieqiang_article_details_50775847]: https://blog.csdn.net/happyxieqiang/article/details/50775847
[https_blog.csdn.net_u012329294_article_details_12447405]: https://blog.csdn.net/u012329294/article/details/12447405
[https_blog.csdn.net_weichaohnu_article_details_8798581]: https://blog.csdn.net/weichaohnu/article/details/8798581