C++之函数指针与动态内存分配

const int * p = &i;     //常指针
int * const p = &i;     //指针常量()

所有的单目运算符自右向左运算
*p++;

NULL    nullptr (c++11)空指针，修改了NULL与int之间的关系

返回值为指针的函数不能返回局部变量的地址
    局部变量的生存期结束，地址失效
    返回值为野指针

    char *Strcpy(char *dest, const char * src)
    {
        char *ret = dest;
        while (*src != '\0')
        {
            *dest++ = *src++;
        }
        *dest = '\0';
        return ret;
    }

    示例：函数的引用返回值
    int &fn(void)     //错误
    {
        int i = 0;
        return i;
    }

    int &fn(int &ref)
    {
        return ref;
    }
    int main()
    {
        int i = 0;
        fn(i) = 10;
        cout << i << endl;
        return 0;
    }    //i = 10;

函数指针：利用指针变量调用函数
    int fn(int a, int b)
    {
        return a + b;
    }
    int (*p)(int, int) = fn;

cpp11：函数指针类型别名
    匿名函数：lambda    [capture](argument){body}
    lambda 闭包：可以使用[]捕获外部变量
                [i] 捕获外部变量不能被修改
                [&i] 捕获外部变量可以被修改
                [=] 捕获外部全部变量
                [&] 引用捕获外部全部变量，可修改
            如果未捕获任何变量，则可作为函数指针
函数指针作用：解耦合（举例通过回调函数）

函数库中的qsort函数：解耦合
    int (*p)(const void *, const void *)
    qsort(arr, n, sizeof(int), p);

    int cmp(const void *a, const void *b)
    {
        return *(int *)a - *(int *)b;
    }
    

    int main()
    {
        int arr[] = {1, 3, 5, 2, 4};
       int n = sizeof(arr) / sizeof(arr[0]);
       qsort(arr, n, sizeof(int), cmp);
   }

=================================================
动态内存分配：
    c语言：Clock *p = malloc(sizeof(Clock));    //malloc返回的是void*
          free(p);
          使用malloc创建的对象，并不是真正意义上的创建对象，未调用构造和析构函数。
    cpp语言：以上编译出错
        Clock *p = reinterpret_cast<Clock *>(malloc(sizeof(Clock)));;
        free(p);

    创建：new
        Clock *p = new Clock;
        p->SetTime(1, 2, 3);
        delete p;

    malloc与new的区别：
        1、malloc返回的是void*，new返回的是对象指针
        2、malloc和free是函数，而new和delete是运算符
        3、malloc和free不调构造和析构函数
    
    创建数组：
        int *p = new int[10];
        delete[] p;

        int *p = new int;
        int *p = new int(10);
        delete p;

深复制和浅复制：
    浅复制：
        Clock *p = new Clock;
        Clock *q = p;       //q和p指向同一块内存
        delete p;           //p释放了内存，q指向的内存失效
        delete q;           //q释放了内存，程序出错

    深复制：
        Clock *p = new Clock;
        Clock *q = new Clock(*p);      //q和p指向不同的内存

    移动复制构造函数: