test

a是int型变量a的地址

(char *)将int型指针（指向4个字节）转换成char型指针（指向一个字节）

char *p声明一个char型指针变回量，答接受转换的地址。

#include <stdio.h>

int main()
{
   int i = 0x1122;
   char * p = (char *)&i;
   if (p[0] == 0x22 && p[1] == 0x11) {
       printf("Little Endian\n");
   }
   else if (p[0] == 0x11 && p[1] == 0x22) {
       printf("Big Endian\n");
   }
}

运算符重载

RMB.h

class RMB { public:     RMB(int _yuan, int _jiao, int _fen);     ~RMB(); private:     int yuan = 0;     int jiao = 0;     int fen = 0; };

RMB.cpp

#include "RMB.h" RMB::RMB(int _yuan, int _jiao, int _fen) {     yuan = _yuan;     jiao = _jiao;     fen = _fen; } RMB::~RMB() { }

为这个类写了些必要的部分之后，我们要完成一个功能，加法功能，1块9毛加2块3毛，用程序应该怎么写呢？我们可以添加一个 Add 函数，如下：

RMB.h

class RMB { public:     RMB(int _yuan, int _jiao, int _fen);     ~RMB();     RMB Add(const RMB & rmb); private:     int yuan = 0;     int jiao = 0;     int fen = 0; };

RMB.cpp

#include "RMB.h" RMB::RMB(int _yuan, int _jiao, int _fen) {     yuan = _yuan;     jiao = _jiao;     fen = _fen; } RMB::~RMB() { } RMB RMB::Add(const RMB & rmb) {     RMB rmbRes(0, 0, 0);     // 分     int f = rmb.fen + fen;     int f_ = f / 10;     rmbRes.fen = f % 10;     // 角     int j = rmb.jiao + jiao + f_;     int j_ = j / 10;     rmbRes.jiao = j % 10;     // 元     int y = rmb.yuan + yuan + j_;     int y_ = y / 10;     rmbRes.yuan = y % 10;     return rmbRes; }

这样，我们就实现了一个 Add 函数，如果想要把两个人民币加起来，就可以这样用：

int main(int argc,char **argv) {     RMB rmbA(1, 9, 0);     RMB rmbB(2, 5, 0);     RMB rmbC = rmbA.Add(rmbB);     return 0; }

但是这样看上去好像有点别扭，事实上，在很多不支持运算符重载的语言里，我们都是这样干的。但是在 C++ 里，有一种更好的方式，可以把 + 号进行重载。

我们可以把这个 Add 函数修改成 + 号的重载：

RMB.h

class RMB { public:     RMB(int _yuan, int _jiao, int _fen);     ~RMB();     // RMB & Add(const RMB & rmb);     RMB operator + (const RMB & rmb); private:     int yuan = 0;     int jiao = 0;     int fen = 0; };

RMB.cpp

#include "RMB.h" RMB::RMB(int _yuan, int _jiao, int _fen) {     yuan = _yuan;     jiao = _jiao;     fen = _fen; } RMB::~RMB() { } // RMB & RMB::Add(const RMB & rmb) RMB RMB::operator + (const RMB & rmb) {     RMB rmbRes(0, 0, 0);     // 分     int f = rmb.fen + fen;     int f_ = f / 10;     rmbRes.fen = f % 10;     // 角     int j = rmb.jiao + jiao + f_;     int j_ = j / 10;     rmbRes.jiao = j % 10;     // 元     int y = rmb.yuan + yuan + j_;     int y_ = y / 10;     rmbRes.yuan = y % 10;     return rmbRes; }

在这样修改之后，使用的时候，我们就可以写出来更优雅的代码了。

int main(int argc,char **argv) {     RMB rmbA(1, 9, 0);     RMB rmbB(2, 5, 0);     RMB rmbC = rmbA + rmbB;     return 0; }

可以看到我们直接把两个对象用 + 号加了起来，这比之前使用函数看起来会好得多。

在 C++ 中，有很多符号都可以重载，也有一些不能被重载。

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

const int arrLength = 20;   // 数组长度

double* getStusGrade()

{

    // 学生成绩数组

    double gradeArr[arrLength] = {

    60.5, 62.5, 67.5, 40, 50, 60, 70, 80, 90, 100,

    90.5, 12, 13.5, 84, 65, 76, 87, 88, 99, 20.5

    };

    // 堆内存上分配160个字节的内存空间 20×8个字节

    double* arrP = (double*)malloc(arrLength * sizeof(double));

    // 将栈内存上的数组数据添加到堆内存空间中

    for (int index = 0; index < arrLength; index++)

    {

        arrP[index] = gradeArr[index];

    }

    return arrP;

}

int main(int argc, char** argv)

{

    double* ptr = getStusGrade();

    // 输出学生成绩

    for (int index = 0; index < arrLength; index++)

    {

        std::cout << "学生" << index + 1 << "的数学成绩是：" << ptr[index] << std::endl;

    }

    free(ptr);

    ptr = nullptr;

    return 0;

}

Staff(const Staff & staff);//k拷贝一份类中某函数地址

*在不同地方的含义

1、在定义指针中时，*为指针定义符

2、在可执行语句指针之前，*为指针引用符

3、别忘了还有运算符的作用

&在不同地方的含义

1、在定义变量中，&为引用定义符，且必须初始化引用。

2、在可执行语句中，&为取址符

如以上描述有误，欢迎批评指针！！！

内存管理

资源获得初始化原则（RAII）

构造函数　　创建资源

析构函数　　销毁资源

+

virtual int work(); 虚函数 该staff 类里也可实现

virtual int  work()=0;纯虚函数，只声明，不实现。

虚函数不能实例化对象。

纯虚函数的类只能被继承，不能被实例化

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

  Staff * st1 = new Staff();
  // 记得释放
  delete st1;

栈上实例化：

  Staff st1;

函数指针funcp指向函数funcl;

int (*funcP)(int a)=funcl;

int 函数返回值类型

funcP 指针名

int a 函数输入值

funcl  指针指向的函数

int ret=(*funcP)(5);

通过指针调用函数,将返回值赋给ret

#include <stdio.h>

int main(int argc,char **argv)
{
    int arr[] = {1, 2, 3, 4};
    int * p = arr;
    return 0;
}

*(p+2)

等价于

arr[2]

普通变量用点，指针用箭头

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

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

要通过基类（父类）释放子类的对象，必须将父类的析构函数设置为virtual.

static int a

定义静态变量