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;
}

数组名是一个指向数组首元素的指针

①栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

 ②堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。

：：的作用

表示作用域，和所属关系
比如
class A
{
public:
int test();
}

int A::test()//表示test是属于A的
{
return 0;
}

类似的还有其他，就不列举了
--------------------
比如
int a;

void test ()
{
int a = ::a;//用全局变量a，给本地变量a赋值
}

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

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

   return 0;
}

你也可以只给部分元素赋值，当 {} 中的元素数量少于 [] 中定义的长度的时候，只给前面部分元素赋值，后面的未指定的元素，将被赋值为 0。

#include <stdio.h>

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

借用此特性，我们可以把数组的所有元素初始化为 0

#include <stdio.h>

int main(int argc,char **argv)
{
   int a[4] = {0};
   return 0;
}

我就是要将 int 转换成 short，我们管这种转换叫做强制转换，因为在转换的时候我们写清楚了要转换的类型是什么，所以也叫做显式转换。

不会损失精度，那么在这种情况下，C++ 允许直接进行转换，由于在转换的时候没有进行指定数据类型，所以叫做隐式转换。

如果已经使用const int c=10;定义过了的话就不能在后面吧c 的值改变，因为之前的定义是在定义一个常量，不能后续把常量进行赋值。只有变量才行。

首先是 (int argc,char **argv) ，这是一个参数列表。我们可以看到，这里有两个参数，第一个参数argc表示参数个数，第二个参数argv是参数组，两个参数一起表达了这个程序的启动参数。

整型

类型名称                             数据长度（字节）

char=unsigned char          1

short=unsigned short       2

int=unsigned short           2

long=unsigned short        4

long long=unsigned L L    8

[-128,127]

[0,255]

浮点型

类型名称                             数据长度（字节）

float                                   4

double                               8

仍然以存储50个同学的成绩为例，我们要定义 存储50个学生成绩的变量，只要这样定义就可以了。

#include <stdio.h>

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

那么我们应该如何访问数组中的元素呢？这里我们要用到一个角标的概念，假如我们要给数组中第 1 个变量赋值为 98 分，我们应该这样做。

#include <stdio.h>

int main(int argc,char **argv)
{
   int a[50];

   a[0] = 98;

   return 0;
}

注意：C++ 的角标是从 0 开始的，我们日常生活中的“第一个”，对应 C++ 的数组角标实际上 0 。为了不至于混淆，也常常说“第 0 个”。

数组的内存布局

数组是一个整体，它的内存是连续的，也就是说，数组元素之间是相互挨着的，彼此之间没有一点缝隙，一个 int[5] 的数组，在内存中的布局看起来像下图一样。

数组的初始化

我们可以在声明数组的时候，就给数组赋值

#include <stdio.h>

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

如果不想指明数组的长度，可以不写，这样数组的长度就是给定的列表的长度。

#include <stdio.h>

int main(int argc,char **argv)
{
   int a[] = {0, 1, 2, 3}; // 此处数组的长度就是 4
   return 0;
}

你也可以只给部分元素赋值，当 {} 中的元素数量少于 [] 中定义的长度的时候，只给前面部分元素赋值，后面的未指定的元素，将被赋值为 0。

#include <stdio.h>

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

借用此特性，我们可以把数组的所有元素初始化为 0

#include <stdio.h>

int main(int argc,char **argv)
{
   int a[4] = {0};
   return 0;
}