#include <iosteam>

#include "Data.h"

void test1(Data data)

{

}

void test2(Data * data)

{

    //若传入空指针，加判断

    if (data == nullprt)

    {

        return;

    }

}

void test3(Data & data)//传引用不用做空指针判断

{

    //存在通过引用操作data对象的漏洞

}

void test3(const Data & data)//加上const 函数内部无法操作data对象，规避漏洞。

{

}

Data getData()

{

    Data data;//新建一个对象 == 新开一片内存

    return data;

}

int main()

{

    Data data;//创建副本

    test 1(data);//操作副本

    test 2(&data);//指针操作

    test2(nullprt);//传入空指针

    test3(data);//直接传入对象，更便捷。

    Data data = getData();//调用结束，getData 返回的data内存释放，将之拷贝至新的内存对象“=”左边的那个data。（无形之中，资源浪费）

    const Data & data = getData();

    test3(data);//调用test3() 若data为const 修饰变量，test 函数内部赋值也必须为const修饰。

    test3(getData());//简写。

    return 0;

}

引用

声明方法：

int main()

{

    int A = 200;

    int & newA = A; //引用初始化

    newA = 90;

    printf("A:%d\n",A);//A被赋值为90，操作newA 相当于操作A。

    return 0;

}

本质相同：

    int * newA = &A;//指针newA指向变量A的地址；

    int & newA = A;//引用变量newA为A的地址。

区别：

指针：A *pa = &a;

          pa->data =20;

          pa->func();

引用：A &ra = a;

          ra.data = 20;

          ra.func();

1、指针可以不初始化，或初始化为空，引用不行。

2、引用不允许二次指向。

3、非大量内存操作时（例如数组），建议使用引用。

纯虚函数的写法

class ClassA

{

    //定义

    public:

        virtual int doWork() = 0;//纯虚函数（父类不实现,由子类实现）

        virtual int doWork();//虚函数

}；

class ClassB

{

    public:

        int doWork() 

        {

            printf("ClassB::doWork() is called");

        } 

}；

调用方法：

 int main()

{

    ClassA *ca = new classB();

     ca->doWork();//调用了ClassB的doWork方法；

     return0;

}

注意点：

1、虚函数在实现时，若子类需调用析构函数，父类的析构函数在定义时需加上virtual 前缀，否则默认调用父类的析构，子类的析构无法被调用。

2、1中若构造函数中开辟了新的堆内存，有内存溢出的风险。 

• malloc函数是C语言中用于动态内存分配的标准库函数.

• 在使用malloc函数之前，需要包含stdlib.h头文件，以获得该函数的声明

• 调用malloc函数时，需要指定要分配的内存大小，参数为size_t类型，表示要分配的字节数。例如 malloc(2*sizeof(int))

0x0102转化成0x0110

0001 0010

小端字节序 little endian （低地址）0010 0001 （高地址）  大部分机器（电脑）

大端字节序 big endian （低地址）0001 0010 （高地址） IO方面（网络细节序）

&（与运算）参加运算的两个数据，按二进制位进行与运算。如果两个相应的二进制位都为１，则该位的结果值为1，否则为0。

|（或运算）两个相应的二进制位中只要有一个为1，该位的结果值为1。

^（异或）若参加运算的两个二进制位值相同则为0，否则为1。

~（取反）这是一元运算符，用于求整数的二进制反码，即分别将操作数各二进制位上的 1 变为 0，0 变为 1。

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

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

通常第一位为符号位，0代表正，1代表负

7

0111

1111 原码 （带符号位）

1000 反码（除符号位取反）

1001 补码 （反码+1，为负数（-7））

所以，只要你的编译器兼容 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位：

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