堆上管理指针变量 需要手动分配内存大小 介绍后手动释放销毁

栈 先进后出 用于作用域内的内存释放 自动管理

指针变量存放的是地址

我们在定义数组的时候，常常这样定义，int arr[5];

在 C++ 中，数组表示的是一段连续的内存存储空间

如上图，每个元素之间是没有空隙的，这样每个元素的内存地址，其实也是有规律可循的。可以写这样一个程序，来验证我们的想法：

include <stdio.h>

int main(int argc,char **argv)
{
   int array[5];
   printf("array[0]: %p\n", &array[0]); // %p 用来打印数组的地址
   printf("array[1]: %p\n", &array[1]);
   printf("array[2]: %p\n", &array[2]);
   printf("array[3]: %p\n", &array[3]);
   printf("array[4]: %p\n", &array[4]);

   return 0;
}

程序运行结果如下：

array[0]: 0x7ffee9d81490
array[1]: 0x7ffee9d81494
array[2]: 0x7ffee9d81498
array[3]: 0x7ffee9d8149c
array[4]: 0x7ffee9d814a0

指针的地址以16进制的方式输出，可以看出，这几个地址中，每两个相邻的地址都相差 4 ，而每一个元素都是 int类型，int 占 4 个字节大小，说明他们确实是紧密相连的。

验证了数组的地址之后，再来看看数组是如何访问数组中的元素的。假设我们想要访问第 2 个元素（从 0 开始）

array[1];

那么 C++ 在碰到这行代码的时候，是先拿到第 2 个元素的地址，然后通过地址去访问元素，那么如何拿到第二个元素的地址呢？刚刚的实验证明，数组中元素的地址都是等差的，所以只要拿到第一个元素的地址，再加上相应元素的偏差，就可以拿到第二个元素的地址了。

那么，对于数组来说，第一个元素的地址是什么的？答案是数组名。

我们再尝试写一个测试程序

#include <stdio.h>

int main(int argc,char **argv)
{
   int array[5];
   printf("array: %p\n", array);
   printf("array[0]: %p\n", &array[0]); // %p 用来打印数组的地址
   printf("array[1]: %p\n", &array[1]);
   printf("array[2]: %p\n", &array[2]);
   printf("array[3]: %p\n", &array[3]);
   printf("array[4]: %p\n", &array[4]);

   return 0;
}

程序运行结果如下：

array: 0x7ffeefa29490
array[0]: 0x7ffeefa29490
array[1]: 0x7ffeefa29494
array[2]: 0x7ffeefa29498
array[3]: 0x7ffeefa2949c
array[4]: 0x7ffeefa294a0

我们发现，直接输出 array 和首元素的地址，是一模一样的，那么就可以得出一个结论：数组名是一个指向数组首元素的指针

但是这个指针和我们常见的指针有一些不一样的地方，这个指针是一个常量，所以我们是不可以对其进行修改的。也就是说，我们不能对其进行 array = p 或者 array++ 这样包含重新赋值的操作，但是我们仍然可以用指针的用法来操作他。

例如，使用指针的加减法来访问对应的元素

#include <stdio.h>

int main(int argc,char **argv)
{
   int array[5];
   *(array + 2) = 1;

   return 0;
}

代码中的 *(array + 2) = 1; 就等价于 array[2] = 1;

指针篇

我们在前面讲过 malloc 分配内存的用法。来看一个例子

#include <stdio.h>

int main(int argc,char **argv)
{
   int * p = (int *)malloc(5 * sizeof(int));

   free(p);
   return 0;
}

在上面的程序中，我们分配出来了一个 5 个 int 大小的储存空间：

在这块储存空间内，可以存放 5 个 int 类型的数字，假如想要访问第 3 个数字，我们可以把指针向后移动两个元素的位置，写成 *(p + 2)

那么指针可不可以按照数组的访问方式去访问呢？p[2]

其实也是可以的，p[2]和*(p + 2)在这里是等价的。

enum 枚举类型 枚举类型函数里面 每个枚举的量都是用"，"隔开的。

enum Week 
{
    Mon, // 星期一
    Tue, // 星期二
    Wed, // 星期三
    Thu, // 星期四
    Fri, // 星期五
    Sat, // 星期六
    Sun, // 星期日
};

int main(int argc,char **argv)
{
    Week week = Week::Fri;

    return 0;
}在这段程序里，week 这个枚举变量，只能是定义好的 7 个值，不能是其他的值，而且在赋值的时候，你可以直接看出来这个值是什么，而不用再去和数字进行对应。这样就可以最大限度得减少出错的可能性了。对于例如星期，季节，性别之类的概念，我们应该优先使用枚举类型。

#include<stdio.h>

#include<iostream>

struct Student

{

    int math;

    int english;

};

int main(int argc,char **argv)

{

    struct Student stu[50];

    //其中一个学号为：21的学生成绩赋值

    stu[20].math = 100;

    stu[20].english = 98;

}

那么布尔类型和关系运算符有什么联系呢？我们都知道，关系运算用来计算的是两个量之间的关系的，这种关系，其实就是布尔类型。也就是说，关系运算的结果，就是布尔类型。

需要注意的是，在早期的 C++ 中是没有 bool 类型的，在没有 bool 类型的年代，人们常用普通的整型来表示二值化语义，即 0 表示 false，非 0 表示 true。后来这种使用习惯被传承到今天，因此，有时候也会用普通的整型代替 bool 类型。

我们把焦点放到这个 int a; 上面。在 C++ 中，我们通常管这行代码叫做声明了一个变量，这个变量的名字叫做 a，而前面的 int，表示这个变量可以存放一个整型的数据类型，整型的意思就是整数。这里的变量，虽然和我们数学中的变量不完全相同，但是却是非常相近的概念。

#include <stdio.h>

int main(int argc,char **argv)
{
   int a;
   return 0;
}

可以看到，声明常量和声明一个变量非常像，不一样的地方就是在前面加了一个 const。这个 const 代表的就是不可变的。
#include <stdio.h>

int main(int argc,char **argv)
{
   const int c = 10;
   return 0;
}

break 跳出循环；continue 如果符合条件执行了continue，那么continue后的循环指令不再执行；而是从新一轮的下一个循环重新开始。

switch 接受了一个变量s；之后用case分情况， case后接的括号里只能是常量。 case（常量）

都不符合所列的若干case，用default表示不符合上述所有的情况。