C/C++

C/C++面试题汇总

Joe.Zhao

 

​关注他

17 人赞同了该文章

下面github中的内容有空看一下

https://github.com/huihut/interview

复习《C++程序设计》笔记

第八章知识点 类和对象

class 访问属性

• private：私有成员，只有本类内的成员函数可以访问
• public：共有成员，类作用域中的所有函数都可以访问
• protected：受保护的成员，类外不可以访问，派生类可以访问

inline成员函数

函数的调用设计到堆栈的操作，时间开销远远大于顺序执行小规模的程序，如果在class内定义的成员函数中不包含循环等控制结构，C++编译器会把它们当作内置函数(inline)来处理

class成员函数的存储方式

类class定义一个对象object，编译系统会为每一个对象分配存储空间，每一个object的数据成员空间独立的，而所有objcet的成员函数共用存储空间，不同的对象使用的是同一段代码空间，为区分不同对象的数据成员，使用this指针来实现区分

第九章 类和对象进一步

this 指针

每一个成员函数中都包含一个特殊的指针，这个指针叫做this指针，指向本类对象的指针，他的数值是当前被调用的成员函数所在对象的起始地址

this指针是隐式的，它作为参数传递给成员函数的，例如定义类Box的成员函数volume时候

int Box::volume()
{
    return (height * width * length);
}

C++ 编译器会把它处理为，在行参列表中增加了一个this指针

int Box::volume(Box *this)
{
    return (this->height * this->width * this->length);
}

在调用a.volume()时候，实际是调用的a.volume(&a)

共用数据的保护

P282，const等等挺不好理解的，现在先不看了

常对象：Time const t1(10, 12, 13)对象中所有的数据成员的值不能被修改，参考https://github.com/huihut/interview中const介绍

// 类
class A
{
private:
    const int a;                // 常对象成员，只能在初始化列表赋值

public:
    // 构造函数
    A() : a(0) { };
    A(int x) : a(x) { };        // 初始化列表

    // const可用于对重载函数的区分
    int getValue();             // 普通成员函数
    int getValue() const;       // 常成员函数，不得修改类中的任何数据成员的值
};

void function()
{
    // 对象
    A b;                        // 普通对象，可以调用全部成员函数、更新常成员变量
    const A a;                  // 常对象，只能调用常成员函数
    const A *p = &a;            // 常指针
    const A &q = a;             // 常引用

    // 指针
    char greeting[] = "Hello";
    char* p1 = greeting;                // 指针变量，指向字符数组变量
    const char* p2 = greeting;          // 指针变量，指向字符数组常量
    char* const p3 = greeting;          // 常指针，指向字符数组变量
    const char* const p4 = greeting;    // 常指针，指向字符数组常量
}

// 函数
void function1(const int Var);           // 传递过来的参数在函数内不可变
void function2(const char* Var);         // 参数指针所指内容为常量
void function3(char* const Var);         // 参数指针为常指针
void function4(const int& Var);          // 引用参数在函数内为常量

// 函数返回值
const int function5();      // 返回一个常数
const int* function6();     // 返回一个指向常量的指针变量，使用：const int *p = function6();
int* const function7();     // 返回一个指向变量的常指针，使用：int* const p = function7();

第11 章知识点 继承和派生

11.1 继承方式

• public共用继承：基类的公用成员和保护成员在派生类中保持原有的访问属性，私有成员仍然为基类的私有
• private私有继承：基类的公用成员和保护成员在派生类中成了私有成员，私有成员仍然为基类私有
• protected保护继承：基类的公用成员和保护成员在派生类中成了保护成员，私有成员仍然为基类私有

11.2 派生类的构造函数和析构函数

执行顺序：派生类构造函数先会调用基类的构造函数，然后再执行派生类自己的构造函数，析构顺序相反

11.3 多层派生时候的构造函数

Student(int n, string nam)
Student1(int n,string nam, int a):Student(n, nam)
Student2(int n,string nam, int a, int s):Student1(n, nam, a)

每一层派生类的构造函数，只需要写上一层派生类的构造函数即可

11.4 多重继承

多重继承会引起二义性的问题：一个派生类有多个直接基类，而这些直接基类又有一个共同的基类，那么在最终的派生类中会保留该间接共同基类数据成员的多份同名成员。

C++提供了虚基类的方法，使得继承间接共同基类的时候只保留一份成员

11.5 虚函数

用同一种方法去调用同一类族中不同类的所有同名函数，可以把基类中的函数前面加上virtual来声明

虚函数的使用方法：

1. 在基类用virtual声明成员函数为虚函数，这样就可以在派生类中重新定义此函数，为它赋予新的功能，方便调用
2. 在派生类中重新定义该函数，要求函数名，函数类型，函数参数个数和类型全部和基类要一致（当一个成员函数被声明为虚函数后，其派生类中的所有同名函数都自动称为虚函数）
3. 定义一个指向基类对象的指针变量，并使得它指向同一类族中的某一个对象
4. 通过该指针变量调用该虚函数，此时调用的就是指针变量指向的对象的同名函数

 

 

static

1. 修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在 main 函数运行前就分配了空间，如果有初始值就用初始值初始化它，如果没有初始值系统用默认值初始化它。
2. 修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命名空间里的函数重名，可以将函数定位为 static。
3. 修饰成员变量，修饰成员变量使所有的对象只保存一个该变量，而且不需要生成对象就可以访问该成员。
4. 修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在 static 函数内不能访问非静态成员。

this 指针

1. this 指针是一个隐含于每一个非静态成员函数中的特殊指针。它指向调用该成员函数的那个对象。
2. 当对一个对象调用成员函数时，编译程序先将对象的地址赋给 this 指针，然后调用成员函数，每次成员函数存取数据成员时，都隐式使用 this 指针。
3. 当一个成员函数被调用时，自动向它传递一个隐含的参数，该参数是一个指向这个成员函数所在的对象的指针。
4. this 指针被隐含地声明为: ClassName *const this，这意味着不能给 this 指针赋值；在 ClassName 类的 const 成员函数中，this 指针的类型为：const ClassName* const，这说明不能对 this 指针所指向的这种对象是不可修改的（即不能对这种对象的数据成员进行赋值操作）；
5. this 并不是一个常规变量，而是个右值，所以不能取得 this 的地址（不能 &this）。
6. 在以下场景中，经常需要显式引用 this 指针：
1. 为实现对象的链式引用；
2. 为避免对同一对象进行赋值操作；
3. 在实现一些数据结构时，如 list

inline内联函数

1. 相当于把内联函数里面的内容写在调用内联函数处；
2. 相当于不用执行进入函数的步骤，直接执行函数体；
3. 相当于宏，却比宏多了类型检查，真正具有函数特性；
4. 编译器一般不内联包含循环、递归、switch 等复杂操作的内联函数；
5. 在类声明中定义的函数，除了虚函数的其他函数都会自动隐式地当成内联函数。

// 声明1（加 inline，建议使用）
inline int functionName(int first, int second,...);

// 声明2（不加 inline）
int functionName(int first, int second,...);

// 定义
inline int functionName(int first, int second,...) {/****/};

// 类内定义，隐式内联
class A {
    int doA() { return 0; }         // 隐式内联
}

// 类外定义，需要显式内联
class A {
    int doA();
}
inline int A::doA() { return 0; }   // 需要显式内联

编译器对 inline 函数的处理步骤

1. 将 inline 函数体复制到 inline 函数调用点处；
2. 为所用 inline 函数中的局部变量分配内存空间；
3. 将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
4. 如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）

优缺点

优点

1. 内联函数同宏函数一样将在被调用处进行代码展开，省去了参数压栈、栈帧开辟与回收，结果返回等，从而提高程序运行速度。
2. 内联函数相比宏函数来说，在代码展开时，会做安全检查或自动类型转换（同普通函数），而宏定义则不会。
3. 在类中声明同时定义的成员函数，自动转化为内联函数，因此内联函数可以访问类的成员变量，宏定义则不能。
4. 内联函数在运行时可调试，而宏定义不可以。

缺点

1. 代码膨胀。内联是以代码膨胀（复制）为代价，消除函数调用带来的开销。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
2. inline 函数无法随着函数库升级而升级。inline函数的改变需要重新编译，不像 non-inline 可以直接链接。
3. 是否内联，程序员不可控。内联函数只是对编译器的建议，是否对函数内联，决定权在于编译器。

volatile

volatile int i = 10;

• volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素（操作系统、硬件、其它线程等）更改。所以使用 volatile 告诉编译器不应对这样的对象进行优化。
• volatile 关键字声明的变量，每次访问时都必须从内存中取出值（没有被 volatile 修饰的变量，可能由于编译器的优化，从 CPU 寄存器中取值）
• const 可以是 volatile （如只读的状态寄存器）
• 指针可以是 volatile

assert()

断言，是宏，而非函数。assert 宏的原型定义在 <assert.h>（C）、<cassert>（C++）中，其作用是如果它的条件返回错误，则终止程序执行。可以通过定义 NDEBUG 来关闭 assert，但是需要在源代码的开头，include <assert.h> 之前。

assert() 使用

#define NDEBUG          // 加上这行，则 assert 不可用
#include <assert.h>

assert( p != NULL );    // assert 不可用

sizeof()

• sizeof 对数组，得到整个数组所占空间大小
• sizeof 对指针，得到指针本身所占空间大小

位域

Bit mode: 2;    // mode 占 2 位

类可以将其（非静态）数据成员定义为位域（bit-field），在一个位域中含有一定数量的二进制位。当一个程序需要向其他程序或硬件设备传递二进制数据时，通常会用到位域。

• 位域在内存中的布局是与机器有关的
• 位域的类型必须是整型或枚举类型，带符号类型中的位域的行为将因具体实现而定
• 取地址运算符（&）不能作用于位域，任何指针都无法指向类的位域

extern "C"

• 被 extern 限定的函数或变量是 extern 类型的
• 被 extern "C" 修饰的变量和函数是按照 C 语言方式编译和链接的

extern "C" 的作用是让 C++ 编译器将 extern "C" 声明的代码当作 C 语言代码处理，可以避免 C++ 因符号修饰导致代码不能和C语言库中的符号进行链接的问题。

extern "C" 使用

#ifdef __cplusplus
extern "C" {
#endif

void *memset(void *, int, size_t);

#ifdef __cplusplus
}

C++ 中 struct 和 class

总的来说，struct 更适合看成是一个数据结构的实现体，class 更适合看成是一个对象的实现体。

区别

• 最本质的一个区别就是默认的访问控制

1. 默认的继承访问权限。struct 是 public 的，class 是 private 的。
2. struct 作为数据结构的实现体，它默认的数据访问控制是 public 的，而 class 作为对象的实现体，它默认的成员变量访问控制是 private 的。

union 联合

联合（union）是一种节省空间的特殊的类，一个 union 可以有多个数据成员，但是在任意时刻只有一个数据成员可以有值。当某个成员被赋值后其他成员变为未定义状态。联合有如下特点：

• 默认访问控制符为 public
• 可以含有构造函数、析构函数
• 不能含有引用类型的成员
• 不能继承自其他类，不能作为基类
• 不能含有虚函数
• 匿名 union 在定义所在作用域可直接访问 union 成员
• 匿名 union 不能包含 protected 成员或 private 成员
• 全局匿名联合必须是静态（static）的

union 使用

#include<iostream>

union UnionTest {
    UnionTest() : i(10) {};
    int i;
    double d;
};

static union {
    int i;
    double d;
};

int main() {
    UnionTest u;

    union {
        int i;
        double d;
    };

    std::cout << u.i << std::endl;  // 输出 UnionTest 联合的 10

    ::i = 20;
    std::cout << ::i << std::endl;  // 输出全局静态匿名联合的 20

    i = 30;
    std::cout << i << std::endl;    // 输出局部匿名联合的 30

    return 0;
}

面向对象

面向对象程序设计（Object-oriented programming，OOP）是种具有对象概念的程序编程典范，同时也是一种程序开发的抽象方针。

 

 

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

封装

把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。关键字：public, protected, private。不写默认为 private。

• public 成员：可以被任意实体访问
• protected 成员：只允许被子类及本类的成员函数访问
• private 成员：只允许被本类的成员函数、友元类或友元函数访问

继承

• 基类（父类）——> 派生类（子类）

多态

• 多态，即多种状态（形态）。简单来说，我们可以将多态定义为消息以多种形式显示的能力。
• 多态是以封装和继承为基础的。
• C++ 多态分类及实现：

1. 重载多态（Ad-hoc Polymorphism，编译期）：函数重载、运算符重载
2. 子类型多态（Subtype Polymorphism，运行期）：虚函数
3. 参数多态性（Parametric Polymorphism，编译期）：类模板、函数模板
4. 强制多态（Coercion Polymorphism，编译期/运行期）：基本类型转换、自定义类型转换

 

C和C++区别

• C面向过程，代码中通过定义大量不同函数实现不同功能
• C++面向对象，代码中通过定义Class来实现功能，面向对象的程序语言具有封装、继承和多态特点
• 封装，指通过定义class实现属性和方法的集合
• 继承，指可以定义子类，在继承父类的属性和方法基础上，还可以定义属于自己的属性和方法，从而实现代码复用
• 多态，“一个接口，多种实现”，通过派生类重写父类的虚函数，实现了接口的重用

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

• 预编译：头文件替换，宏定义等预处理命令替换
• 编译：C++编译成汇编代码
• 汇编：把汇编代码翻译成目标机器指令
• 链接：链接目标代码生成可执行程序

堆和栈的区别

栈 stack：存放函数的参数值、局部变量，由编译器自动分配释放

堆 heap：

• 是由new分配的内存块，由应用程序控制，需要程序员手动利用delete释放，如果没有，程序结束后，操作系统自动回收
• 因为堆的分配需要使用频繁的new/delete，造成内存空间的不连续，会有大量的碎片

堆的生长空间向上，地址越大，栈的生长空间向下，地址越小

不能被子类继承的函数

构造函数（包括拷贝构造）、析构函数、赋值运算符重载函数

基类的析构函数为什么要用virtual虚析构函数

防止内存泄露，delete p（基类）的时候，它很机智的先执行了派生类的析构函数，然后执行了基类的析构函数。

如果基类的析构函数不是虚函数，在delete p（基类）时，调用析构函数时，只会看指针的数据类型，而不会去看赋值的对象，这样就会造成内存泄露

Const Static区别

static 静态变量，指类的静态成员函数、静态成员变量是和类相关的，而不是和类的具体对象相关的。即使没有具体对象，也能调用类的静态成员函数和成员变量。一般类的静态函数几乎就是一个全局函数，只不过它的作用域限于包含它的文件中

在C++中，static静态成员变量不能在类的内部初始化。在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化，如：double Account::Rate = 2.25;static关键字只能用于类定义体内部的声明中，定义时不能标示为static

在C++中，const成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数。

const数据成员 只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类的声明中初始化const数据成员，因为类的对象没被创建时，编译器不知道const数据成员的值是什么。

关键字static

函数体内： static 修饰的局部变量作用范围为该函数体，不同于auto变量，其内存只被分配一次，因此其值在下次调用的时候维持了上次的值

模块内：static修饰全局变量或全局函数，可以被模块内的所有函数访问，但是不能被模块外的其他函数访问，使用范围限制在声明它的模块内

类中：修饰成员变量，表示该变量属于整个类所有，对类的所有对象只有一份拷贝

类中：修饰成员函数，表示该函数属于整个类所有，不接受this指针，只能访问类中的static成员变量

注意和const的区别！！！const强调值不能被修改，而static强调唯一的拷贝，对所有类的对象

#define const

• define定义的常量没有类型，const定义的常量有类型，存储在静态存储区
• 处理阶段不一样，define是在预处理阶段进行替换，可能有多个拷贝，const所定义的变量在编译时确定其值，只有一个拷贝。
• define定义的常量是不可以用指针去指向，const定义的常量可以用指针去指向该常量的地址
• define可以定义简单的函数，const不可以定义函数

Const

• 定义只读变量，即常量
• 修饰函数的参数和函数的返回值
• 修饰函数的定义体，这里的函数为类的成员函数，被const修饰的成员函数代表不修改成员变量的值

Struct 和Union区别

结构体：将不同类型的数据组合成一个整体，是自定义类型; 共同体：不同类型的几个变量共同占用一段内存

• 结构体中的每个成员都有自己独立的地址，它们是同时存在的； 共同体中的所有成员占用同一段内存，它们不能同时存在
• sizeof(struct)是内存对齐后所有成员长度的总和，sizeof(union)是内存对齐后最长数据成员的长度

数组和指针的区别

数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块

修改内容上的差别：

char a[] = "hello";
a[0] = 'X';
char *p = "world"; // 注意p 指向常量字符串
p[0] = 'X'; // 编译器不能发现该错误，运行时错误

用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12 字节
cout<< sizeof(p) << endl; // 4 字节
//计算数组和指针的内存容量
void Func(char a[100])
{
cout<< sizeof(a) << endl; // 4 字节而不是100 字节
}

引用和指针的区别

• 引用是变量的一个别名，内部实现是只读指针
• 引用只能在初始化时被赋值，其他时候值不能被改变，指针的值可以在任何时候被改变
• 引用不能为NULL，指针可以为NULL
• 引用变量内存单元保存的是被引用变量的地址
• “sizeof 引用" = 指向变量的大小 ， "sizeof 指针"= 指针本身的大小
• 引用可以取地址操作，返回的是被引用变量本身所在的内存单元地址
• 引用使用在源代码级相当于普通的变量一样使用，做函数参数时，内部传递的实际是变量地址

new、delete、malloc、free

• delete会调用对象的析构函数，new调用构造函数。
• malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。
• 对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。
• 由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。
• 因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。

vector内存分配方式

先申请一定的大小的数组, 当数组填满之后,另外申请一块原数组两倍大的新数组, 然后把原数组的数据拷贝到新数组, 最后释放原数组的大小

STL库的容器和算法

STL（Standard Template Library，标准模板库）

从根本上说，STL是一些“容器”的集合，这些“容器”有list,vector,set,map等，STL也是算法和其他一些组件的集合

STL包括两部分内容：容器和算法。

容器即存放数据的地方，比如array, vector，分为两类，序列式容器和关联式容器

• 序列式容器：其中的元素不一定有序，但是都可以被排序，比如vector,list,queue,stack，heap, priority-queue, slist
• 关联式容器：内部结构是一个平衡二叉树，每个元素都有一个键值和一个实值，比如map, set, hashtable, hash_set

算法有排序，复制等，以及各个容器特定的算法

迭代器是STL的精髓，迭代器提供了一种方法，使得它能够按照顺序访问某个容器所含的各个元素，但无需暴露该容器的内部结构，它将容器和算法分开，让二者独立设计。

Vector List

vector数据结构

vector和数组类似，拥有一段连续的内存空间，并且起始地址不变。

因此能高效的进行随机存取，时间复杂度为o(1);

但因为内存空间是连续的，所以在进行插入和删除操作时，会造成内存块的拷贝，时间复杂度为o(n)。

另外，当数组中内存空间不够时，会重新申请一块内存空间并进行内存拷贝

list数据结构

list是由双向链表实现的，因此内存空间是不连续的。

只能通过指针访问数据，所以list的随机存取非常没有效率，时间复杂度为o(n);

但由于链表的特点，能高效地进行插入和删除

vector和list的区别

我们看一个简单的vector和list使用示例：

#include<iostream>
#include<vector>
#include<list>
using namespace std;
int main()
{
    vector<int> v;
    list<int> l;
    for(int i=0;i<8;i++) ////往v和l中分别添加元素
    {
        v.push_back(i);
        l.push_back(i);
    }
    cout<<"v[2]="<<v[2]<<endl;
    //cout<<"l[2]="<<l[2]<<endl;  //编译错误,list没有重载[]
    cout<<(v.begin()<v.end())<<endl; 
    //cout<<(l.begin()<l.end())<<endl; /编译错误,list::iterator没有重载<或>
    cout<<*(v.begin()+1)<<endl;
    //cout<<*(l.begin()+1)<<endl; //编译错误,list::iterator没有重载+
    vector<int>::iterator itv=v.begin();
    list<int>::iterator itl=l.begin();
    itv = itv+2;
    //itl=itl+2; //编译错误,list::iterator没有重载+
    itl++; //list::iterator中重载了++，只能使用++进行迭代访问。
    itl++;
    cout<<*itv<<endl;
    cout<<*itl<<endl;
    getchar();
    return 0;
}

vector拥有一段连续的内存空间，能很好的支持随机存取，
因此vector<int>::iterator支持“+”，“+=”，“<”等操作符。

list的内存空间可以是不连续，它不支持随机访问，
因此list<int>::iterator则不支持“+”、“+=”、“<”等

vector<int>::iterator和list<int>::iterator都重载了“++”运算符。

总之，如果需要高效的随机存取，而不在乎插入和删除的效率，使用vector;
如果需要大量的插入和删除，而不关心随机存取，则应使用list

内存分配的方式

1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。

2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。

3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。

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

进程间通信方式：

• 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
• 信号量( semophore ) ： 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
• 消息队列( message queue ) ： 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
• 共享内存( shared memory ) ：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。
• 套接字( socket ) ： 套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。

线程间通信方式：

• 全局变量；
• Messages消息机制；
• CEvent对象（MFC中的一种线程通信对象，通过其触发状态的改变实现同步与通信）。

 

 

哪些函数不能声明成虚函数?

多态，虚函数，纯虚函数?

 

 

 

 

 

 

参考文档

时海：C/C++面试题大全​zhuanlan.zhihu.com