类的继承

类，就像是对某一类事物的抽象模版，而在某些场景下，我们希望对抽象的内容进行扩增，或者说更加具体化。为了完成这种关系，便是继承。

class Coder : public Staff
{

};

不可重载的运算符：

.
.* ->*
::
sizeof
?:
#

拷贝构造函数

Staff(const staff  &staff);

memcpy(mem,staff.mem,20);

是C和C++使用的内存拷贝函数，函数原型为void *memcpy(void *destin, void *source, unsigned n)；函数的功能是从源内存地址的起始位置开始拷贝若干个字节到目标内存地址中，即从源source中拷贝n个字节到目标destin中。

声明函数指针

                            int(*funcP)(int a,int b)

指针指向函数

                              int(*funcP)(int a,int b)=func1;

通过指针调用函数

                             (*funcP)(5);

                             int ret=(*funcP)(5);带返回值

函数中传入函数

                             int dowork(int a,int b,int (*callback)())

                             {

                                      ......

                                  int ret=(*callback)();  

                               }

回调函数/钩子函数 ：应用到函数中插入代码/多线程中

指针声名

指针运算

                              地址  * > 内存

                              地址   &<内存

                              int*p=&a;  //变量A的地址赋值给指针P，P指向变量A

指针和数组

                              int*p=arr；(数组变量名)

                              p+1(实际上是地址+类型大小)

                              p[1]=>*(p+1)指针偏移操作

指针和结构体

                                struct S *p=&s;

                                  p->a=12;

                                  p->b=22;

大端字节序（big endian）：高位在前。在IO和网络传输方面采用方式，大端字节序又被称之为网络细节序

小端字节序（little endian）：低位在前。大部分机器采用小端字节序

7

0111

1111原码

1000反码

1001补码

#include <iostream>

#include <stdio.h>

using namespace std;

//函数指针类型创建方法

int/*返回值的类型*/(*Example)/*函数指针名称,一定要加括号*/(int a);/*传入参数,可以为空*/

//钩子函数实现方法见下文

int dowork(int a, int b, int (*doworkP)())

//创建了一个dowork函数

//并且在启动参数创建一个函数指针

{

a = a + b;

(*doworkP)();

//在dowork函数中调用函数指针

return 0;

};

int funcA()

{

cout << "fuck you" << endl;

return 0;

};

int funcB()

{

cout << "wo chao shi ni ma" << endl;

return 0;

};

int funcC()

{

cout << "we is SB" << endl;

return 0;

};

//创建了ABC三个函数,并且都有输出内容

int main(int argc, char** argv)

{

dowork(1, 2, funcA);//main函数调用dowoek函数,启动参数指针指向了funcA函数,所以启动参数中包括funcA.并且指向funcA函数的指针在dowork函数中调用实现,main调用了带有funcA函数的dowork,所以会输出funcA的内容.

dowork(1, 2, funcB);

dowork(1, 2, funcC);

return 0;

}

1. unique_ptr

   不能被多个实例共享的内存管理。将一个普通的指针封装成一个栈对象。

   std::unique_ptr<A> p1(new A());

   //初始化了一个智能指针，指向了一片A对象的内存。

   //unique_ptr 智能通过构造函数将指针传入

   std::unique_str<A> p1 = new p();//会报错

   //和普通指针不同的是，它不需要delete，会自动释放内存

2. shared_ptr

   引用计数的智能指针，可以跟踪应用同一个真实指针对象的智能指针实例的数目。

   std::shared_ptr<A> p1 = std::make_shared<A>();
   std::shared_ptr<A> p2 = p1;//p1和p2指向了同一片内存，两个指针都可以操作这片内存， 而且不用释放。

   使用make_shared来构建对象可以保留指针的关系，避免发生错误。

3. weak_ptr

   shared_ptr在循环引用是会发生错误，产生死锁。

   在相互引用时使用weak_ptr就可以防止死锁。

1. const 修饰普通变量

const int a, 则表示 a 是一个常量，你不可以在后续对其进行修改。因为 a 不可修改，所以在创建的时候就要对 a 进行赋值，不对其进行赋值则会报错。

1. const 修饰指针

• 只有一个 const，如果 const 位*左侧，表示指针所指数据是常量，不能通过解引用修改该数据；指针本身是变量，可以指向其他的内存单元。

  int const * p = &a;

• 只有一个 const，如果 const 位于*右侧，表示指针本身是常量，不能指向其他内存地址；指针所指的数据可以通过解引用修改。

  int * const p = &a;

• 两个 const，*左右各一个，表示指针和指针所指数据都不能修改

1. const修饰函数参数

    const 修饰函数参数的时候，其作用域仅仅限制在函数内部，只要在函数中保持其不变性就可以了。

2. const修饰成员函数

   const修饰的成员函数不能修改任何的成员函数，

   const修饰的成员函数不能调用非const成员函数。

3. const修饰函数返回值

   址传递，返回指针，引用。该返回值加一个const，可以防止返回值被调用。

   值传递，值传递时，返回值会复制一份，加不加const都可以。

1. 静态联编

···c

Child * obj = new Child();
Base * baseobj = (Base *)obj;
baseobj->func();
delete obj;
return 0;

再来看看这个例子，我们通过强制转换来指定 func 执行的是哪个。这个过程是在编译阶段就将函数实现和函数调用关联起来，因此静态联编也叫早绑定，在编译阶段就必须了解所有的函数或模块执行所需要检测的信息。

1. 动态联编：

   运行虚函数的实现

继承与多态

要将对象分配到堆上，需要用到另外两个关键字，new 和 delete。new 用来分配对象，delete 用来删除对象。new 会返回一个指针，在使用完毕后，要通过 delete 把这个指针指向的地址释放掉。

无法确认指向的指针，或者指向一个无效地址的指针，我们把他叫做野指针

如果想要通过指针操作变量，只需要使用解引用就可以了