所以，只要你的编译器兼容 C++11 标准，那么你应该使用 nullptr。

将父类的析构函数声明为虚函数，作用是用父类的指针删除一个派生类对象时，派生类对象的析构函数会被调用。

此时如果析构函数不加 virtual，那么 delete 父类指针的时候，子类的析构就不会被调用，某些情况下会导致内存泄漏。

我们之前讲述了什么是多态，还用了一个例子，将一个指针的类型做成强转，然后调用 func 函数，就会发现， func 函数会随着被强转的类型的变换而变换，这种函数的关联过程称为编联。按照联编所进行的阶段不同，可分为两种不同的联编方法：静态联编和动态联编。

我们其实可以把一个员工强行转化成程序员，但是这就有可能出问题，就如同我们把 long long 转成 int 就有可能出现问题。

int main(int argc,char **argv)
{
   Coder * coder = new Coder();

   Staff * staff = coder; // 隐式转换就可以
   Coder * coder = (Coder *)staff; // 必须显式转换

   return 0;
}

我们之前已经讲过，可以为成员变量和成员函数设置权限修饰符来设置权限。但是这在继承的时候就会产生一个问题：子类中是否要保持对父类成员的权限，而 C++ 将这个选择权交给了程序员。

在 C++ 中，对父类成员的权限，子类中可以进行重新的定义，这个定义就是通过继承时候写的public 来实现的。

可以看到，我们在上述程序中使用了 public 修饰符，那么父类中的成员函数和成员变量将会保持父类的权限。这种是使用最广泛的继承方式，我们把它叫做公有继承。

private

用来指定私有成员。一个类的私有成员，不论是成员变量还是成员函数，都只能在该类的内部才能被访问

int main(int argc,char **argv)
{
   A a;
   a.a = 15; // 会报错，因为成员变量是 private 的
   return 0;
}

public

用来指定公有成员。一个类的公有成员在任何地方都可以被访问。

int main(int argc,char **argv)
{
   A a;
   a.a = 15; // 不会报错，因为成员变量是 public 的
   return 0;
}

protected

用来指定保护成员。一般是允许在子类中访问

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

#include "Staff.h"

int main(int argc,char **argv)
{
   // 我们就这样实例化了三个员工
   Staff * st1 = new Staff();
   Staff * st2 = new Staff();
   Staff * st3 = new Staff();

   // 记得释放
   delete st1;
   delete st2;
   delete st3;

   return 0;
}

但是我们需要思考的是，什么情况下我们要返回一个指针，返回指针的时候需要我们注意些什么？

通常情况下，我们是希望为函数外提供一片内存，例如，我们可以给函数外面提供一个数组。

int * func()
{
   int arr[] = {1, 2, 3, 4};
   return arr;
}

但是这样写得话，程序会崩溃掉。原因是，arr 数组是一个局部变量，在 func 结束之后，其内存就被销毁掉了。此时在函数外面对其进行操作，自然会出问题。所以，要完成这类操作，我们需要把内存分配到堆内存上面。

int * func()
{
   int * arr = (int *)malloc(4 * sizeof(int));
   return arr;
}

这样就没有问题了，当然，既然是分配在了堆内存上，就要记得手动销毁。

int main(int argc,char **argv)
{
   int * p = func();
   free(p);
   return 0;
}

字节序，就是 大于一个字节类型的数据在内存中的存放顺序。

计算机硬件有两种储存数据的方式：大端字节序（big endian）和小端字节序（little endian）。

我们现在有一个整数是258。用16进制表示是0x0102，然后我们把这个整数拆分成两个字节，第一个字节为 0000 0001，第二个字节为 0000 0010。

如果在一个使用大端字节序的电脑上，这个整数会被这样存放：

如果一个使用小端字节序的电脑上，这个整数的高字节就会存放在高地址上：

现在大部分的机器，都采用了小端字节序。但是在 IO 方面，则大部分使用大端字节序。例如，你要使用网络发送一个 int 类型的变量，要先把 int 转换成大端字节序，然后通过网络发送。

大端字节序又被称之为网络细节序。

<< 左移

各位全部左移若干位，高位丢弃，低位补 0 。

>> 右移

各二进位全部右移若干位，对无符号数，高位补 0 ，有符号数，各编译器处理方法不一样，有的补符号位，有的补 0 。

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

int main(int  argc,char ** argv)

{

    char source[20]={'a'};

    char* originP= source;

    *(originP+15)='c';

    *(originP+16)='d';

    *(originP+17)='e';

    *(originP+18)='f';

    *(originP+19)='g';

    char target[5]={'b','b','b','b','b'};

    char* targetP=target;

     std::cout <<"origin value:"<<  target[1] <<','<<target[1] <<std::endl;

    memcpy(targetP,originP+15,5);

    std::cout << "new value:"<<target[0] << ","<< target[1] <<std::endl;

    return 0;

}

#include <iostream>
#include <stdio.h>
using namespace std;

int main()
{
    int a;
    cin>>a;
    cout<<a;



    return 0;
}

将指针指向数组，不需要使用取址符&，并且表示的是指针执行数组第一个元素的地址：

int * p = arr 与 int * p = &arr[0]是相同的操作。

指针的加减法：

1. 想要让指针p指向第二个元素，只需要p+1就可以了。 

注意：p+1的操作实际上是指针存放的地址+指针类型的大小。如果指针是一个int*的类型，则p+1就是向后移动4个字节的位置，如果是char*的类型，p+1则是向后移动2个字节的位置。

2. 指针支持p++、p--的操作

指针除了可以指向数组外，还可以指向一个结构体。

计算机中小数表示方法：

定点数容易造成空间浪费，

使用浮动的小数点：

 浮点数按照 IEEE754标准存放的，符号位1位，指数8位，尾数23位：

浮点数存在精度问题，当场景中对精度要求较高，则不能使用浮点数存储。