使用弱引用的智能指针weak_ptr打破这种循环引用。为了解决循环引用导致的内存泄漏，引入了weak_ptr 弱指针，weak_ptr 的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但不指向引用计数的共享内存，但是其可以检测到所管理的对象是否已经被释放，从而避免非法访问。

5.6 shared_ptr的实现

template<typenameT>classSmartPtr{private: T *ptr;//底层真实的指针int*use_count;//保存当前对象被多少指针引用计数public: SmartPtr(T *p);//SmartPtr
               
                p(new int(2));
               SmartPtr(constSmartPtr
              
               &orig);
               //SmartPtr
                
                 q(p);
                SmartPtr
               
                &
                operator=(
                constSmartPtr
                
                 &rhs);
                 //q=p~SmartPtr(); T
                 operator*();
                 //为了能把智能指针当成普通指针操作定义解引用操作T*
                 operator->();
                 //定义取成员操作T*
                 operator+(
                 inti);
                 //定义指针加一个常数
                 int
                 operator-(SmartPtr
                 
                  &t1, SmartPtr
                  
                   &t2);
                   //定义两个指针相减
                   voidgetcount(){
                   return*use_count } };
                   template<
                   typenameT>
                   intSmartPtr
                   
                    ::
                    operator-(SmartPtr
                    
                     &t1, SmartPtr
                     
                      &t2) {
                      returnt1.ptr - t2.ptr; }
                      template<
                      typenameT> SmartPtr
                      
                       ::SmartPtr(T *p) { ptr = p;
                       try{ use_count =
                       new
                       int(
                       1); }
                       catch(...) {
                       deleteptr;
                       //申请失败释放真实指针和引用计数的内存ptr =
                       nullptr;
                       deleteuse_count; use_count =
                       nullptr; } }
                       template<
                       typenameT> SmartPtr
                       
                        ::SmartPtr(
                        constSmartPtr
                        
                         &orig)
                         //复制构造函数{ use_count = orig.use_count;
                         //引用计数保存在一块内存，所有的 SmarPtr 对象的引用计数都指向这里
                         this->ptr = orig.ptr; ++(*use_count);
                         //当前对象的引用计数加 1}
                         template<
                         typenameT> SmartPtr
                         
                          & SmartPtr
                          
                           ::
                           operator=(
                           constSmartPtr
                           
                            &rhs) {
                            //重载=运算符，例如 SmartPtr
                             
                              p,q; p=q;这个语句中，首先给 q 指向的对象的引用计数加1，因为 p 重新指向了 q 所指的对象，所以 p 需要先给原来的对象的引用计数减 1，如果减一后为 0，先释放掉 p 原来指向的内存，然后讲 q 指向的对象的引用计数加 1 后赋值给 p
                             ++*(rhs.use_count);
                            if((--*(use_count)) ==
                            0) {
                            deleteptr; ptr =
                            nullptr;
                            deleteuse_count; use_count =
                            nullptr; } ptr = rhs.ptr; *use_count = *(rhs.use_count);
                            return*
                            this; }
                            template<
                            typenameT> SmartPtr
                            
                             ::~SmartPtr() { getcount();
                             if(--(*use_count) ==
                             0)
                             //SmartPtr 的对象会在其生命周期结束的时候调用其析构函数，在析构函数中检测当前对象的引用计数是不是只有正在结束生命周期的这个 SmartPtr 引用，如果是，就释放掉，如果不是，就还有其他的 SmartPtr 引用当前对象，就等待其他的 SmartPtr对象在其生命周期结束的时候调用析构函数释放掉{ getcount();
                             deleteptr; ptr =
                             nullptr;
                             deleteuse_count; use_count =
                             nullptr; } }
                             template<
                             typenameT> T SmartPtr
                             
                              ::
                              operator*() {
                              return*ptr; }
                              template<
                              typenameT> T* SmartPtr
                              
                               ::
                               operator->() {
                               returnptr; }
                               template<
                               typenameT> T* SmartPtr
                               
                                ::
                                operator+(
                                inti) { T *temp = ptr + i;
                                returntemp; }
                                
                               
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              

6 数组和指针

7 野指针

野指针就是指向一个已删除的对象或者未申请访问受限内存区域的指针

8 函数指针

8.1 定义

函数指针是指向函数的指针变量。

函数指针本身首先是一个指针变量，该指针变量指向一个具体的函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。

C 在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是大体一致的。

8.2 用途：

调用函数和做函数的参数，比如回调函数。

8.3 示例：

char*fun(char* p){…}// 函数 funchar* (*pf)(char* p);// 函数指针 pfpf = fun;// 函数指针 pf 指向函数 funpf(p);// 通过函数指针 pf 调用函数 fun

9 fork函数

Fork：创建一个和当前进程映像一样的进程可以通过 fork( )系统调用：

#include
                #include
                pid_tfork(void);

成功调用 fork( )会创建一个新的进程，它几乎与调用 fork( )的进程一模一样，这两个进程都会继续运行。在子进程中，成功的 fork( )调用会返回 0。在父进程中 fork( )返回子进程的 pid。如果出现错误，fork( )返回一个负值。

最常见的 fork( )用法是创建一个新的进程，然后使用 **exec( )**载入二进制映像，替换当前进程的映像。这种情况下，派生（fork）了新的进程，而这个子进程会执行一个新的二进制可执行文件的映像。这种“派生加执行”的方式是很常见的。

在早期的 Unix 系统中，创建进程比较原始。当调用 fork 时，内核会把所有的内部数据结构复制一份，复制进程的页表项，然后把父进程的地址空间中的内容逐页的复制到子进程的地址空间中。但从内核角度来说，逐页的复制方式是十分耗时的。现代的 Unix 系统采取了更多的优化，例如Linux，采用了写时复制的方法，而不是对父进程空间进程整体复制。

10 析构函数

析构函数与构造函数对应，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统会自动执行析构函数。

析构函数名也应与类名相同，只是在函数名前面加一个位取反符~，例如~stud( )，以区别于构造函数。它不能带任何参数，也没有返回值（包括 void 类型）。只能有一个析构函数，不能重载。

如果用户没有编写析构函数，编译系统会自动生成一个缺省的析构函数（即使自定义了析构函数，编译器也总是会为我们合成一个析构函数，并且如果自定义了析构函数，编译器在执行时会先调用自定义的析构函数再调用合成的析构函数），它也不进行任何操作。所以许多简单的类中没有用显式的析构函数。

如果一个类中有指针，且在使用的过程中动态的申请了内存，那么最好显示构造析构函数在销毁类之前，释放掉申请的内存空间，避免内存泄漏。

10.1 类析构顺序

1. 派生类本身的析构函数
2. 对象成员析构函数
3. 基类析构函数

因为析构函数没有参数，所以包含成员对象的类的析构函数形式上并无特殊之处。但在撤销该类对象的时候，会首先调用自己的析构函数，再调用成员对象的析构函数，调用次序与初始化时的次序相反。

11 虚函数和多态

多态的实现主要分为静态多态和动态多态，静态多态主要是重载，在编译的时候就已经确定；动态多态是用虚函数机制实现的，在运行期间动态绑定。例如：一个父类类型的指针指向一个子类对象时候，使用父类的指针去调用子类中重写了的父类中的虚函数的时候，会调用子类重写过后的函数，在父类中声明为加了 virtual 关键字的函数，在子类中重写时候不需要加 virtual也是虚函数。

虚函数的实现：在有虚函数的类中，类的最开始部分是一个虚函数表的指针，这个指针指向一个虚函数表，表中放了虚函数的地址，实际的虚函数在代码段(.text)中。当子类继承了父类的时候也会继承其虚函数表，当子类重写父类中虚函数时候，会将其继承到的虚函数表中的地址替换为重新写的函数地址。使用了虚函数，会增加访问内存开销，降低效率。

12 析构函数与虚函数

析构函数必须是虚函数，因为将可能会被继承的父类的析构函数设置为虚函数，可以保证当我们 new 一个子类，然后使用基类指针指向该子类对象，释放基类指针时可以释放掉子类的空间，防止内存泄漏。

C++默认的析构函数不是虚函数是因为虚函数需要额外的虚函数表和虚表指针，占用额外的内存。而对于不会被继承的类来说，其析构函数如果是虚函数，就会浪费内存。因此 C++默认的析构函数不是虚函数，而是只有当需要当作父类时，设置虚函数。

13 静态函数和虚函数

静态函数在编译的时候就已经确定运行时机，虚函数在运行的时候动态绑定。虚函数因为用了虚函数表机制，调用的时候会增加一次内存开销。

13.1 静态函数

用static修饰的函数，限定在本源码文件中使用，不能被本源码文件以外的代码文件调用。 普通的函数，默认是extern的，也就是说，可以被其它代码文件调用该函数。

13.2 虚函数表

当一个类中包含被virtual 关键字修饰的成员函数时，该成员函数就成为了一个虚函数。头一个含有虚函数的类所实例化出来的对象都拥有同一个虚函数表，在对象中含有一个*虚函数指针_vptr，该指针指向该类的虚函数表，虚函数表保存的是类中虚函数的地址（一个类可能有多个虚函数）。

13.3 虚函数作用

当一个子类继承了一个含有虚函数的基类，并重写了该基类中的一个虚函数，我们就说这两个类构成多态。子类继承基类的同时，基类的虚函数表也被子类继承，不同的是被子类重写的虚函数将会替代原来虚函数表中对应的基类的虚函数的地址。从而基类与子类调用同名的虚函数时，所调用的就不是同一个函数，从而体现了多态和虚函数表的作用。

13.4 静态函数与虚函数的区别

我们知道类的静态函数是没有this指针的，调用它时不需要创建对象，通过：类名 ：：函数名（参数）的形式直接调用。静态函数只有唯一的一份，因此它的地址是固定不变的， 所以编译的时候但凡遇到调用该静态函数的时候就知道调用的是哪一个函数，因此说静态函数在编译的时候就已经确定运行时机。而虚函数则不然，看下面的代码：

classA{public:virtualvoidfun(){cout<<"i am A <
               
                I am B
                " <
                 
                  fun(); return 0; }
                 
                
               

类A与类B构成多态，创建了 A类指针pb指向 B类对象，当程序编译的时候只对语法等进行检测，该语句没有什么问题，但是编译器此时无法确定调用的是哪一个 fun() 函数，因为类A类B中都含有fun函数，因此只能是在程序运行的时候通过 pb指针查看对象的虚函数表（访问虚函数表就是所谓的访问内存）才能确定该函数的地址，即确定调用的是哪一个函数。这就解释了所说的“虚函数在运行的时候动态绑定。虚函数因为用了虚函数表机制，调用的时候会增加一次内存开销。”

14 重载和覆盖

14.1 重载

两个函数名相同，但是参数列表不同（个数，类型），返回值类型没有要求，在同一作用域中。

14.2 重写

子类继承了父类，父类中的函数是虚函数，在子类中重新定义了这个虚函数，这种情况是重写，是一种同名覆盖。

15 在main函数前先运行的函数

1.test0：__attribute((constructor))是gcc扩展，标记这个函数应当在main函数之前执行。同样有一个__attribute((destructor))，标记函数应当在程序结束之前（main结束之后，或者调用了exit后）执行。

2.test1：全局static变量的初始化在程序初始阶段，先于main函数的执行。

#include
                usingnamespacestd; __attribute((constructor))voidtest0(){printf("before main 0\\n"); }inttest1(){cout<<"before main 1"<<endl;return54; }staticinti = test1();intmain(intargc,char** argv){cout<<"main function."<<endl;return0; }

在leetcode里经常见到static，在main之前关闭cin与stdin的同步来“加快”速度的黑科技。

staticint_ = []{cin.sync_with_stdio(false);return0; }();

16 内存管理

在 C++ 中，虚拟内存分为代码段、数据段、BSS 段、堆区、文件映射区以及栈区六部分。

1. 栈(stack)：程序自动分配，使用栈空间存储函数的返回地址、参数、局部变量、返回值。
2. 堆(heap)：

• 堆：调用malloc在堆区动态分配内存，调用free来手动释放。堆是操作系统所维护的一块特殊内存，它提供了动态分配的功能。
• 自由存储区：由new分配内存，用来delete手动释放。和堆类似，通过new来申请的内存区域可称为自由存储区。

3. 静态/全局区：在 C++ 里面没有区分bss和data。

• bss段：存储未初始化的全局变量和静态变量（局部+全局），以及所有被初始化为0的全局变量和静态变量，Block Started by Symbol。
• data段：存储程序中已初始化的全局变量和静态变量。

4. 代码区（code segment 或 text segment）：

• 代码段：存放函数体的二进制代码，text段。
• 常量区：只读数据，比如字符串常量，程序结束时由系统释放。rodata段，read only。

init段：程序初始化入口代码，在main() 之前运行。

17 常量const

常量是固定值，在程序执行期间不会改变。常量可以是任何的基本数据类型，可分为int、float、char、string和bool。常量定义必须初始化。

17.1 存储区域

1. 局部常量，存放在栈区；
2. static/全局常量，存放在静态/全局存储区；
3. 字面值常量，其值一望而知，存放在常量区。

17.2 const修饰成员函数

const 修饰的成员函数表明函数调用不会对对象做出任何更改，事实上，如果确认不会对对象做更改，就应该为函数加上 const 限定，这样无论 const 对象还是普通对象都可以调用该函数

若同时定义了两个函数，一个带 const，一个不带，这相当于函数的重载。

18 代码解析

18.1 strcpy和strlen

strcpy 是字符串拷贝函数，原型：

char*strcpy(char* dest,constchar*src);

从 src逐字节拷贝到 dest，直到遇到'\\0'结束，因为没有指定长度，可能会导致拷贝越界，造成缓冲区溢出漏洞,安全版本是 strncpy 函数。

strlen 函数是计算字符串长度的函数，返回从开始到'\\0'之间的字符个数。

18.2 ++i和i++

++i 实现：

int&int::operator++（） { *this+=1；return*this； }

i++ 实现：

constintint::operator（int） {intoldValue = *this； ++（*this）；returnoldValue； }

18.3 代码的区别

（1）字符串 123 保存在常量区，const 本来是修饰 arr 指向的值，不能通过 arr 去修改，但是字符串“123”在常量区，本来就不能改变，所以加不加 const 效果都一样：

constchar* arr ="123";

（2）字符串 123 保存在常量区，这个 和arr 指针指向的是同一个位置，同样不能通过 brr 去修改"123"的值：

char* brr ="123";

（3）这里 123 本来是在栈上的，但是编译器可能会做某些优化，将其放到常量区：

constcharcrr[] ="123";

（4）字符串 123 保存在栈区，可以通过 drr 去修改：

chardrr[] ="123";

19 编程题

19.1 点是在三角形内

给定三角形ABC和一点P(x,y,z)，判断点P是否在ABC内。

根据面积法，如果P在三角形ABC内，那么三角形ABP的面积+三角形BCP的面积+三角形ACP的面积应该等于三角形ABC的面积。

S=(x_1y_2+x_2y_3+x_3y_1-x_1y_3-x_2y_1-x_3y_2)/2

代码如下：

#include
                #include
                usingnamespacestd;#defineABS_FLOAT_0 0.0001structpoint_float{floatx;floaty; };floatGetTriangleSquar(constpoint_float pt0,constpoint_float pt1,constpoint_float pt2)// 计算三角形面积{ point_float AB, BC; AB.x = pt1.x - pt0.x; AB.y = pt1.y - pt0.y; BC.x = pt2.x - pt1.x; BC.y = pt2.y - pt1.y;returnfabs((AB.x * BC.y - AB.y * BC.x)) /2.0f; }boolIsInTriangle(constpoint_float A,constpoint_float B,constpoint_float C,constpoint_float D)// 判断给定一点是否在三角形内或边上{floatSABC, SADB, SBDC, SADC; SABC = GetTriangleSquar(A, B, C); SADB = GetTriangleSquar(A, D, B); SBDC = GetTriangleSquar(B, D, C); SADC = GetTriangleSquar(A, D, C);floatSumSuqar = SADB + SBDC + SADC;if((-ABS_FLOAT_0 < (SABC - SumSuqar)) && ((SABC - SumSuqar) < ABS_FLOAT_0))returntrue;elsereturnfalse; }

19.2 判断一个数是二的倍数

判断一个数是不是二的倍数，即判断该数二进制末位是不是 0：

a %2==0a &0x0001==0// 两种办法都可

19.3 一个数中有几个1

可以直接逐位除十取余判断：

intfun(long x){ int _count =0;while(x) {if(x %10==1) ++_count; x /=10; }return_count; } int main() { cout <<fun(123321)<< endl;return0; }

审核编辑：汤梓红