C++必掌握知识点

1.new、delete、malloc、free关系
delete会调用对象的析构函数,和new对应，free只会释放内存，new调用构造函数。malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。
2.delete与 delete []区别
delete只会调用一次析构函数，而delete[]会调用每一个成员的析构函数。在More Effective C++中有更为详细的解释：“当delete操作符用于数组时，它为每个数组元素调用析构函数，然后调用operator delete来释放内存。”delete与new配套，delete []与new []配套
对于内建简单数据类型，delete和delete[]功能是相同的。对于自定义的复杂数据类型，delete和delete[]不能互用。delete[]删除一个数组，delete删除一个指针。简单来说，用new分配的内存用delete删除；用new[]分配的内存用delete[]删除。
3.C++有哪些性质（面向对象特点）
封装，继承和多态。
4.子类析构时要调用父类的析构函数吗？
析构函数调用的次序是先派生类的析构后基类的析构，也就是说在基类的的析构调用的时候,派生类的信息已经全部销毁了。定义一个对象时先调用基类的构造函数、然后调用派生类的构造函数；析构的时候恰好相反：先调用派生类的析构函数、然后调用基类的析构函数。
5.多态，虚函数，纯虚函数
多态的分类：
多态可以分为静态多态和动态多态。静态多态里包括函数重载和泛型编程；动态多态主要体现在虚函数。

早期绑定和晚绑定：
（1）C++编译器在编译时，会确定每个对象调用函数（非虚函数）的地址，这叫做早期绑定（也叫做静态绑定）
（2）当我们将函数声明为virtual时，编译器不会在编译时就确定对象要调用的函数的地址，而是在运行时再去确定要调用的函数的地址，这就是晚绑定（也叫做动态绑定）
多态：是对于不同对象接收相同消息时产生不同的动作。C++的多态性具体体现在运行和编译两个方面：在程序运行时的多态性通过继承和虚函数来体现；
virtual的背后到底发生了什么？
（1）编译器在编译的时候，发现Father类中有虚函数，此时编译器会为每个包含虚函数的类创建一个虚表（即vtable），该表是一个一维数组，在这个数组中存放每个虚函数的地址。
（2）那么如何定位虚表呢？编译器另外还为每个对象提供了一个虚表指针（即vptr），这个指针指向了对象所属类的虚表。
（3）在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向了所属类的虚表，从而在调用虚函数的时候，能够找到正确的函数。
（4）由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了，在虚表指针没有正确初始化之前，我们不能够去调用虚函数。
（5）那么虚表指针是在什么地方初始化的呢？是在构造函数中进行虚表的创建和虚表指针的初始化。在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否还有继承者，它初始化父类对象的虚表指针，该虚表指针指向父类的虚表，当执行子类的构造函数时，子类对象的虚表指针被初始化，指向自身的虚表。

多态总结
（1）C++的多态性是通过晚绑定（动态绑定）技术实现的
（2）含有虚函数的类都有虚表
（3）当子类对父类的虚函数没有重写时，子类的虚表指针保存的是父类的虚表；当子类对父类的虚表重写时，子类的虚表指针保存的是子类的虚表；当子类中有自己的虚函数时，在虚表中将此虚函数地址添加在后面。
具体多态原理如还是不懂，可参考原文链接（讲的很经典）：https://blog.csdn.net/weixin_38952721/article/details/100130983

在程序编译时多态性体现在函数和运算符的重载上；
虚函数：在基类中冠以关键字 virtual 的成员函数。它提供了一种接口界面。允许在派生类中对基类的虚函数重新定义。
纯虚函数的作用：在基类中为其派生类保留一个函数的名字，以便派生类根据需要对它进行定义。作为接口而存在纯虚函数不具备函数的功能，一般不能直接被调用。
从基类继承来的纯虚函数，在派生类中仍是虚函数。如果一个类中至少有一个纯虚函数，那么这个类被称为抽象类（abstract class）。
抽象类中不仅包括纯虚函数，也可包括虚函数。抽象类必须用作派生其他类的基类，而不能用于直接创建对象实例。但仍可使用指向抽象类的指针支持运行时多态性。

x&(x-1)统计1的个数，x|(x+1)统计0的个数

7.什么是“引用”？声明和使用“引用”要注意哪些问题？
答：引用就是某个目标变量的“别名”(alias)，对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。
8.将“引用”作为函数参数有哪些特点？
（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。
（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。
（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。
9.在什么时候需要使用“常引用”？　
如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：const 类型标识符 &引用名=目标变量名；引用型参数应该在能被定义为const的情况下，尽量定义为const 。
10.将“引用”作为函数返回值类型的格式、好处和需要遵守的规则?

格式：类型标识符 &函数名（形参列表及类型说明）{ //函数体 }
好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error!
注意事项：
（1）不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。
（2）不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。
（3）可以返回类成员的引用，但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。

const 有什么用途
主要有三点：
1：定义只读变量，即常量
2：修饰函数的参数和函数的返回值
3：修饰函数的定义体，这里的函数为类的成员函数，被const修饰的成员函数代表不修改成员变量的值

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

几种常见容器比较和分析 map, vector, list .
List顺序容器，支持快速的插入和删除，但是查找费时;
Vector顺序容器，支持快速的查找，但是插入费时。
Map关联容器，map就是从键（key）到值（value）的映射，key值唯一，查找的时间复杂度是对数的，这几乎是最快的，hash也是对数的。

引用总结
　　（1）在引用的使用中，单纯给某个变量取个别名是毫无意义的，引用的目的主要用于在函数参数传递中，解决大块数据或对象的传递效率和空间不如意的问题。
　　（2）用引用传递函数的参数，能保证参数传递中不产生副本，提高传递的效率，且通过const的使用，保证了引用传递的安全性。
　　（3）引用与指针的区别是，指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。
　　（4）使用引用的时机。流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。
11、结构与联合有和区别？

(1). 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。
(2). 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。

13.重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？
常考的题目。从定义上来说：
重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
重写：是指子类重新定义父类虚函数的方法。
从实现原理上来说：
重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！
重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。
14.有哪几种情况只能用初始化列表而不能用构造函数?
答案：当类中含有const限定的常量成员、成员变量为引用类型时,都需要初始化表。
15. C++是不是类型安全的？
答案：不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。C#是类型安全的。
16. main 函数执行以前，还会执行什么代码？
答案：全局对象的构造函数会在main 函数之前执行。
17. 描述内存分配方式以及它们的区别?
一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）― 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap） ― 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）―，全局变量和静态变量的存储是放在一块的，
初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放
4、文字常量区 ―常量字符串就是放在这里的。程序结束后由系统释放
5、程序代码区―存放函数体的二进制代码。

18.分别写出BOOL,int,float,指针类型的变量a 与“零”的比较语句。
答案：
BOOL : if ( !a ) or if(a)
int : if ( a == 0)
float : const EXPRESSION EXP = 0.000001
if ( a < EXP && a >-EXP)
pointer : if ( a != NULL) or if(a == NULL)
19.请说出const与#define 相比，有何优点？
答案：
const作用：定义常量、修饰函数参数、修饰函数返回值三个作用。被Const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
2）有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。
20.简述数组与指针的区别？
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。
(1)修改内容上的差别
char a[] = “hello”;
a[0] = ‘X’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 编译器不能发现该错误，运行时错误
(2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof§,p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。
char a[] = “hello world”;
char *p = a;
cout<< sizeof(a) << endl; // 12 字节
cout<< sizeof§ << endl; // 4 字节
计算数组和指针的内存容量
void Func(char a[100])
{
cout<< sizeof(a) << endl; // 4 字节而不是100 字节
}
21题： int (*s[10])(int) 表示的是什么？
int (*s[10])(int) 函数指针数组，每个指针指向一个int func(int param)的函数。
25题：引用与指针有什么区别？

【参考答案】

引用必须被初始化，指针不必。
引用初始化以后不能被改变，指针可以改变所指的对象。
不存在指向空值的引用，但是存在指向空值的指针。
26题：const 与 #define 的比较，const有什么优点?

【参考答案】
（1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误（边际效应）。
（2）有些集成化的调试工具可以对 const 常量进行调试，但是不能对宏常量进行调试。
29题：基类的析构函数不是虚函数，会带来什么问题？
【参考答案】派生类的析构函数用不上，会造成资源的泄漏。
30题：全局变量和局部变量有什么区别？是怎么实现的？操作系统和编译器是怎么知道的？
【参考答案】
生命周期不同：
全局变量随主程序创建和创建，随主程序销毁而销毁；局部变量在局部函数内部，甚至局部循环体等内部存在，退出就不存在；
使用方式不同：通过声明后全局变量程序的各个部分都可以用到；局部变量只能在局部使用；分配在栈区。
操作系统和编译器通过内存分配的位置来知道的，全局变量分配在全局数据段并且在程序开始运行的时候被加载。局部变量则分配在堆栈里面。
人一定要靠自己

atoi
　　C语言库函数名: atoi
　　功能: 把字符串转换成整型数
itoa函数
功能: 把整形数转换成字符串

构造函数和析构函数作用：
构造函数：通俗的讲，在类中，函数名和类名相同的函数称为构造函数。它的作用是在建立一个对象时，作某些初始化的工作（例如对数据赋予初值）。C++允许同名函数，也就允许在一个类中有多个构造函数。如果一个都没有，编译器将为该类产生一个默认的构造函数。

析构函数：当一个类的对象离开作用域时，析构函数将被调用(系统自动调用)。析构函数的名字和类名一样，不过要在前面加上 ~ 。对一个类来说，只能允许一个析构函数，析构函数不能有参数，并且也没有返回值。析构函数的作用是完成一个清理工作，如释放从堆中分配的内存。
一个类中可以有多个构造函数，但析构函数只能有一个。对象被析构的顺序，与其建立时的顺序相反，即后构造的对象先析构。

子字符串查找之字符串数组strstr
　　返回待查找字符串中子字符串的首字符地址。如果子字符串不存在则返回空指针。

子字符串查找之字符串string的find方法
string头文件中find函数就是在主字符串中查找子字符串的索引。

const 有什么用途
主要有三点：
1：定义只读变量，即常量
2：修饰函数的参数和函数的返回值
3：修饰函数的定义体，这里的函数为类的成员函数，被const修饰的成员函数代表不修改成员变量的值
如何避免内存泄漏

总结了好些规律：要成对使用,保证malloc/new和free/delete匹配，free掉的内存指针要置空，在尽量少的函数中申请和释放内存，等等
采取动STL组件的态数组代替手工分配对象内存的方式也是一种办法；

在什么情况下系统会调用拷贝构造函数：（三种情况）
（1）用类的一个对象去初始化另一个对象时
（2）当函数的形参是类的对象时（也就是值传递时），如果是引用传递则不会调用
（3）当函数的返回值是类的对象或引用时

一个指针free之后，必须置空，不然会产生野指针，如果不小心调用会出现错误。

sizeof（）和strlen（）
一、sizeof
sizeof(…)是运算符，在头文件中typedef为unsigned int，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。
它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。
由于在编译时计算，因此sizeof不能用来返回动态分配的内存空间的大小。实际上，用sizeof来返回类型以及静态分配的对象、结构或数组所占的空间，返回值跟对象、结构、数组所存储的内容没有关系。
二、strlen
strlen(…)是函数，要在运行时才能计算。参数必须是字符型指针（char*）。当数组名作为参数传入时，实际上数组就退化成指针了。
它的功能是：返回字符串的长度。该字符串可能是自己定义的，也可能是内存中随机的，该函数实际完成的功能是从代表该字符串的第一个地址开始遍历，直到遇到结束符NULL。返回的长度大小不包括NULL。char str[20]=“0123456789”;
int a1=strlen(str); //a=10;
int b1=sizeof(str); //而b=20;

char str1[]="0123456789";
int a2=strlen(str1); //a=10;
int b2=sizeof(str1); //而b=11;

char *str3="0123456789";
int a3=strlen(str3); //a=10;
int b3=sizeof(str3); //而b=4;

浅拷贝与深拷贝
浅拷贝：系统默认的拷贝构造函数，只默认的复制构造函数，逐个复制非静态成员（成员的复制成为浅复制）值，复制的是成员的值，同一个类的多个对象，内存排布是一样的，地址不同，所以直接复制。
深拷贝：指针成员不能直接赋值，要用内存拷贝，memcpy,strcpyd等
简单的来说就是，在有指针的情况下，浅拷贝只是增加了一个指针指向已经存在的内存，而深拷贝就是增加一个指针并且申请一个新的内存，使这个增加的指针指向这个新的内存，采用深拷贝的情况下，释放内存的时候就不会出现在浅拷贝时重复释放同一内存的错误！

Inline和#define区别：

宏是代码处不加任何验证的简单替代，而内联函数是将代码直接插入调用处，而减少了普通函数调用时的资源消耗。
宏不是函数，只是在编译前预处理阶段将程序中有关字符串替换成宏体。
inline是函数，但在编译中不单独产生代码，而是将有关代码嵌入到调用处。
总结如下：
　　对于一般常量，最好用const和enum替换#define；
　　对于类似函数的宏，最好改用inline函数替换#define。

虚析构
多态中，如果释放父类指针，只会调用父类的析构函数，所以加了虚析构，就会子类父类都调用了。delete哪个类型的指针，就调用谁的析构函数
Base* p1 = new Derived; // 父类的指针指向子类的对象
delete p1;
因为这里子类的析构函数重写了父类的析构函数，虽然子类和父类的析构函数名不一样，
但是编译器对析构函数做了特殊的处理，在内部子类和父类的析构函数名是一样的。
所以如果不把父类的析构函数定义成虚函数，就不构成多态，由于父类的析构函数隐藏了子类的析构函数，所以只能调到父类的析构函数。
但是若把父类的析构函数定义成虚函数，那么调用时就会直接调用子类的析构函数，
由于子类析构先要去析构父类，在析构子类，这样就把子类和继承的父类都析构了

什么是MVC (模型视图控制器)?
MVC是一个架构模式，它分离了表现与交互。它被分为三个核心部件：模型、视图、控制器。下面是每一个部件的分工：
• 视图是用户看到并与之交互的界面。
• 模型表示业务数据，并提供数据给视图。
• 控制器接受用户的输入并调用模型和视图去完成用户的需求。

MVC（模型、视图、控制器）架构的控制流程：
• 所有的终端用户请求被发送到控制器。
• 控制器依赖请求去选择加载哪个模型，并把模型附加到对应的视图。
• 附加了模型数据的最终视图做为响应发送给终端用户。

MVC优缺点：
优点，可移值性高，变更起来容易，代码逻辑比较清晰，缺点是，运行效率低一些

c++设计模式：
简单工厂模式
工厂模式有一种非常形象的描述，建立对象的类就如一个工厂，而需要被建立的对象就是一个个产品；在工厂中加工产品，使用产品的人，不用在乎产品是如何生产出来的。
使用情景：
在不确定会有多少个处理操作时应该考虑使用简单工厂模式，如针对同样的接收到的数据，处理的逻辑可能会不同，可能以后还会增加新的操作。
案例：
如果实现计算器的功能时，对于同样的输入数据，可能执行加、减、乘、除，甚至其他的功能。因此可以抽象出一个操作的抽象类或是接口，提供一个统一的处理方法(此处为process)，然后每种操作创建出一个子类出来。而判断具体使用哪个具体的实现类是在工厂类中进行判断的(将存放操作的变量传递给工厂的生产方法)。工厂类始终返回的是这个抽象类，这样如果对原有功能进行更改或是新添加新的功能，也不会对原来的其他类做修改，只编译修改的那个类或是新的类就可以了。
这样就做到了把耦合降到最低，同时也便于维护。

简单工厂：针对同样的数据，不同的操作用同一个接口
工厂方法：针对同样的数据，不同的操作用不同的接口
抽象工厂：针对不同的数据，不同的操作用不同的接口

单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式(不能让一个程序打开两次如：不能同时打开2个迅雷迅雷用的单例模式)

观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。(QT的信号机制，Windows的消息机制都应用了观察者模式，还有订阅邮件，邮件到了就会给你发邮件)

建造者模式：使得产品内部表象可以独立地变化，客户不必知道产品内部组成的细节。可以强制实行一种分步骤进行的建造过程。用一个接口完成不同的操作，需要对客户的需求进行把握。(如：登陆QQ，自动选择所在地的服务器)

命令模式：把发出命令的责任和执行命令的责任分割开，委派给不同的对象允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是怎么被执行的。(命令模式在客户端与服务器之间用的最多 (C/S架构))

等等等==

单例模式实现：
#include <stdio.h>
#include <stdlib.h>
#include
using namespace std;
class CFather
{
public:
static bool nFlag;
protected:
private:
CFather()
{
}
~CFather()
{
nFlag = true;
}
public:
static CFather * CreatObject()
{
if (nFlag)
{
nFlag = false;
return (new CFather);
}
else
{
return NULL;
}
}
};
bool CFather::nFlag = true;
int main()
{
CFather *p = CFather::CreatObject();
return 0;
}

创建一个线程：
#include <Windows.h>
#include
using namespace std;
DWORD WINAPI fun(void* g)
{
while(1) // 线程调用fun函数，内部一直打印
{
Sleep(1000);
cout << (char*)g << endl;
}
return 0;
}
int main()
{
char* a = “abcd”;
::CreateThread(0, 0, fun, a, 0, 0); // 建立线程，线程调用fun函数
Sleep(300);
while(1) // 主函数一直打印
{
Sleep(1000);
cout << “print main” << endl;
}
return 0;
}

C++必掌握知识点

猜你喜欢