C++基础一（概念——循环）

第一章：了解c++

C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。

c++是一种高级语言

c++面向对象开发的特征：封装，抽象，继承，多态

c++是C语言的拓展，C语言是面向过程的语言，c++既可以面向对象也可以面向过程

c++的编译过程：编辑，预处理，编译，汇编，链接，运行

• 编辑：写入代码
• 预处理：在预处理阶段，会进行宏替换，条件编译，头文件展开，去掉注释
• 编译：会进行语法语义检错，无错后转化为汇编文件
• 汇编：把汇编文件转换成可执行的机器指令
• 链接：把所有的目标文件以及我们所依赖的库文件链接到一起生成可执行程序

编译型语言：程序在执行之前需要一个专门的编译过程，把程序编译成 为机器语言的文件，运行时不需要重新翻译，直接使用编译的结果就行了。程序执行效率高，依赖编译器，跨平台性差些。（C/C++、Pascal/Object Pascal（Delphi），go）

解释型语言：解释性语言编写的程序不进行预先编译，以文本方式存储程序代码。在发布程序时，看起来省了道编译工序。但是，在运行程序的时候，解释性语言必须先解释再运行。

（Java、JavaScript、VBScript、Perl、Python、Ruby、MATLAB 等等） 

程序： 

程序是指令的集合

计算机硬件系统可识别的二进制指令组成机器语言

汇编语言：将机器指令映射为可以被人理解的助记符

c++的文件：

C++程序有多种后缀格式：

常用的 C++ 的头文件后缀有 .h、.hpp 和 .hxx，

常用的 C++ 的源文件的后缀有 .cpp、 .cc、.cxx、.C 和 .c++。

计算机中常用的进制：

• 二进制
• 八进制
• 十六进制
• 十进制

 进制转换：

X进制转化为十进制：数字与权相乘然后相加

101（2）=1*2^0+0*2^1+1*2^2=5

A589（16）=9*16^0+8*16^1+5*16^2+10*16^3

十进制转化为r进制

1. 整数换整数：用十进制数除以 r 余数为相应的系数   ：除R取余法
2. 十进制小数转化r进制小数：可连续的乘R 得到的整数即为R进制的数   乘R取整

//二进制转八进制
1010101101（2） 
1 010 101 101  从右往左数 3个为一组
 1255（8）

//二进制转十六进制
10 1010 1101  从右往左数 4个为一组    
2ad（16）

信息存储：

1. 位 bit     度量数据最小单位 表示一个二进制信息
2. 字节 Byte  1Byte = 8 bit
3. 字  字是位的集合  常用固定字长 8位 16位 32位等
4. 机器字长  一般是指 参加运算的寄存器所含有的二进制的位数 代表机器的精度 32位 64位等

 二进制编码：

二进制编码有两部分组成：

1. 符号位  1代表负数  0 代表正数
2. 数据位

 A:+1011011       B:-1011011

机器表示为：

A:0 1011011       B:1 1011011

原码，反码，补码： 

原码：

X1= +10101010   [X1]原= 010101010

X2= -10101010    [X2]原= 110101010

反码：

正数的反码和原码相同

负数的反码的符号位不变 其余取反

X：-11011011    X原：111011011    X反：100100100

补码：两数相加时用补码进行操作

正数的补码和原码相同

负数的补码码的符号位不变 其余取反  +1

补码的表示方法：对于二进制负数 其  模数+真数

X= -0110    X补 2^4+(-0110)=1010   ==  0110取反 +1

X=-0.1011  X补 2+(-0.1011)=1.0101  ==  0.1011取反+0.001

 第二章：数据类型

变量：变量其实只不过是程序可操作的存储区的名称

 

 注释：

单行注释：  //

多行注释：/**/

注意：行注释可以嵌套在多行注释里 ,但多行注释不可以嵌套多行注释

/* /* */ */这样是违法的

#include<iostream>
using namespace std;
int main()
{
    int a1=1;//单行注释
    int a2=1;
    int a3=1;
/* //多行注释
    int a4=1;
    int a5=1;//单行注释
    int a6=1;
    int a7=1;
*/
    int a8=1;
    int a9=1;
    system("pause");
    return 0;
}

基本数据类型：

类型	关键字
布尔型	bool
字符型	char
整型	int
浮点型	float
双浮点型	double
无类型	void

 修饰关键词：

unsigned （修饰整数）	无符号
signed	有符号
long	长类型
short	短类型

类型	位	范围
char	1 个字节	-128 到 127 或者 0 到 255
unsigned char	1 个字节	0 到 255
signed char	1 个字节	-128 到 127
int	4 个字节	-2147483648 到 2147483647
unsigned int	4 个字节	0 到 4294967295
signed int	4 个字节	-2147483648 到 2147483647
short int	2 个字节	-32768 到 32767
unsigned short int	2 个字节	0 到 65,535
signed short int	2 个字节	-32768 到 32767
long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
signed long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long int	8 个字节	0 to 18,446,744,073,709,551,615
float	4 个字节	+/- 3.4e +/- 38 (~7 个数字)
double	8 个字节	+/- 1.7e +/- 308 (~15 个数字)
long double	16 个字节	+/- 1.7e +/- 308 (~15 个数字)

有符号和无符号大小比较：

 有符号数会转化为无符号数进行比较

所以 ：int x=-1； unsigned int =2       x > y

x的无符号数为4,294,967,295 >2

 起别名：

 typedef    数据类型   别名

变量的定义：

• 单个定义
• 多个一起定义，用逗号隔开

int p；//单个定义
int a,bc,;//连续定义相同类型 用逗号隔开

typedef  int  p

p  a=10；//用p替代了int 
p  b=20;

 c++中变量声明：extern

使用 extern 关键字在任何地方声明一个变量。虽然您可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。 

#include <iostream>
using namespace std;

// 变量声明
extern int a, b;
extern int c;
extern float f;

int main ()
{
  // 变量定义
  int a, b;
  int c;
  float f;

  // 实际初始化
  a = 10;
  b = 20;
  c = a + b;
}

注意：

声明:不分配内存

定义:是在变量声明后，给它分配内存，可以看成"定义 = 声明+内存分配“

初始化和赋值：

初始化的概念：声明变量的时候同时赋值，叫初始化

• int b=20;
• int b(20);

赋值的概念：对象已经有值，擦除对象的当前值，并使用新值代替

int a=20;//初始化
int d(30);//初始化
int b;
b=20;//赋值
a=60//赋值

 c++变量作用域：

内存分区的作用：把不同的数据 存放在不同的区中，使得由不同的生存周期，使编程更加灵活

代码区

全局区

栈区

堆区

BSS段：通常是指用来存放程序中未初始化的全局变量的一块内存区域；

数据段：通常是指用来存放程序中 已初始化 的 全局变量 的一块内存区域，static意味着在数据段中存放变量；

代码段：通常是指用来存放 程序执行代码 的一块内存区域；

堆：存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减，这一块在程序运行前就已经确定了；

栈：栈又称堆栈， 存放程序的 局部变量 （不包括static声明的变量）。除此以外，在函数被调用时，栈用来传递参数和返回值。

在程序编译后：会生成exe可执行文件

未执行该程序前：

代码区：

1. 存放cpu执行的机器指令
2. 代码区是共享的，多次使用的程序，只由一份代码
3. 代码区是只读的，防止修改指令

全局区：

1. 存放全局变量和静态变量和各种常量（字符串常量，全局常量）
2. 程序结束后，由系统释放 

#include<iostream>
#include<string>
using namespace std;
//全局变量
int a;
int b;
//const修饰的全局常量
const int e = 0;
const int f = 0;
int main()
{
	//静态变量
	static int c;
	static int d;
	cout << "以下是他们的地址" << endl;
	cout <<"全局变量a:"<< (int)&a << endl;
	cout <<"全局变量b:"<< (int)&b << endl;
	cout << "静态变量c:" << (int)&c << endl;
	cout << "静态变量d:" << (int)&d << endl;
	//const 修饰的全局常量
	cout << "全局常量e:" << (int)&e << endl;
	cout << "全局常量f:" << (int)&f << endl;
	//字符串常量
	cout << "字符串常量g:" <<(int)&"pppp" << endl;
	cout << "字符串常量h:" <<(int)& "qqqq" << endl;
	system("pause");
	return 0;
}

 栈区：

1. 由编译器自动分配释放，存放函数的参数值，局部变量
2. 不要返回局部变量的地址
3. 栈区开辟的数据由编译器自动释放
4. 局部变量使用前必须初始化：因为局部变量是从内存堆中分配的，用完就还给内存堆，所以被分配的局部变量并不一定是0，而很可能是其他地方用过的一个值，因此在使用这个变量之前，要对它进行显示初始化

int* text()
{
	int a = 5;
	return &a;//返回局部变量地址
}
int main()
{
	int *p = text();
	cout << *p << endl;//第一次由于编译器保留了结果，输出正确
	cout << *p << endl;//输出错误
	return 0;
}

void text(int a)
{
	a = 10;
	cout << "  形参a：" << (int)&a << endl;
}
int main()
{
	//局部变量
	int op = 10;
	//局部常量
	const int lp = 10;
	cout << "局部变量op：" << (int)&op << endl;
	cout << "局部常量lp：" << (int)&op << endl;
	int b=0;
	text(b);
	return 0;
}

 堆区：

1. 由程序员开辟和释放 ，程序员未释放，由系统回收
2. c++一般用new开辟

	//在堆区开辟空间 并赋值 10
	int *p = new int(10);
	cout << *p << endl;
	//释放空间
	//不主动释放的话系统会自动释放
	delete p;
	return 0;

常量：

• const 修饰
• #define 定义

1.const修饰时必须初始化

2.最好使用const ，用const的优点：会进行类型安全检查。而define没有安全检查，且可能会产生意料不到的错误。

整数常量： 

数据前加上0   ：表示八进制

数据前加上0x ：表示十六进制

数据后加U/u：表示无符号整数

数据后加L/l：  表示长整数

注意：使用时不能重复

 浮点常量:

浮点数的表示方式：

浮点型数据有两种表达方式：

• 十进制小数：可以缺省小数点前后的数，比如 1.和.1也是合法的表达；
• 指数型 aEn ：其中a是一个十进制小数，诸如1.0  .123456或者1.都是合法的，中间的E和e也都合法，不区分大小写，最后一个n只能是整型常量，不能是表达式。a和n都不能缺省。

合法的有：
1.12   .12   2e4   12.34    1e+5    0.1E12   0.2e2    12345.

不合法的有：
1e3.5      //e后面不能为小数，只能为整数
e5         //e之前必须有数字
5.0e（1+4）//e后面不能为表达式

float和double的区别：

（浮点数计算不准确）

• float精度低 ：小数点后7位
• double精度高：小数点后16位

一个小数 默认为 double 

在小数后加f 表示float类型

3.141592  //默认为double类型
3.141592f //float类型

布尔常量：

• true   结果为真    相当于 1
• false  结果为假    相当于 0

字符常量 ：

字符的用法：

char a='b';
char b=96;

转义序列	含义
\	\ 字符
'	' 字符
"	" 字符
?	? 字符
\a	警报铃声
\b	退格键
\f	换页符
\n	换行符
\r	回车
\t	水平制表符
\v	垂直制表符
\ooo	一到三位的八进制数
\xhh . . .	一个或多个数字的十六进制数

 字符串常量：

" abcdefg"

C++ 中的类型限定符

类型限定符提供了变量的额外信息。

限定符	含义
const	const 类型的对象在程序执行期间不能被修改改变。
volatile	修饰符 volatile 告诉编译器不需要优化volatile声明的变量，让程序可以直接从内存中读取变量。对于一般的变量编译器会对变量进行优化，将内存中的变量值放在寄存器中以加快读写效率。
restrict	由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict。

数据类型转换：

隐式类型转换：（大类型转小类型）编译器自动完成

显示类型转换：（小类型转大类型）

表 1 数据类型排名

long double

double

float

unsigned long long int

long long int

unsigned long int

long int

unsigned int

int

double b=2.12;
int a=b;//结果为2  （范围大转化为范围小的）丢失精度

double c;
int b=20;
c=(double)b; //结果为 20.000000

c++存储类型：

从 C++ 11 开始，auto 关键字不再是 C++ 存储类说明符，且 register 关键字被弃用。

C++98标准中auto关键字用于自动变量的声明，但由于使用极少且多余，在C++11中已删除这一用法。

auto ：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符

register：存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

static：存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

extern：存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 'extern' 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。 extern 是用来在另一个文件中声明一个全局变量或函数

mutable：mutable 成员可以通过 const 成员函数修改。 

thread_local ： 使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 每个线程都有其自己的变量副本。thread_local 说明符可以与 static 或 extern 合并。可以thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义。

运算符 ：

左右值：

左值：占用了一定内存，且拥有可辨认的地址的对象（可放置在运算符左右边）

1. 变量
2. 指针
3. 实例化对象 等

class person
{
public:
	int a;
};
int main()
{
	int x = 5;//变量
	int *p = &x;//指针
	person p1;
	p1.a = 10;//对象

	x = 10;//可以放置在表达式左边
	int y;
	y = x;//也可放置在表达式右边

	return 0;
}

右值：不可修改的数据（只能放置在运算符右边）

1. 常量
2. 临时对象
3. 函数的返回值 等

	int x;
	x = 10;//10就是临时的对象
	x = x + 10;//x+10也是临时对象（表达式）
	const int p = 10;//固定的一个常量
	x = p;
	p = 10；//报错，常量不能被赋值，不能放置在左值

	//这些返回值都是临时值  只能做右值
	int text(int *a)
	{
		return *a;
	}
	int text()
	{
		return 10;
	}
	int text(int a)
	{
		return a + 10;
	}

算术运算符：

运算符	描述
+	把两个操作数相加
-	从第一个操作数中减去第二个操作数
*	把两个操作数相乘
/	分子除以分母
%	取模运算符，整除后的余数（只能用于整数）
++	自增运算符，整数值增加 1
--	自减运算符，整数值减少 1

++a 和 a++的区别：（--也适用）

• ++a 是a+1之后的数 
• a++ 是a+1之后的数
• 两个表达式运行完a都会+1

//++a 和 a++的区别
int a=1;
int b;
int c;
b=++a;  // b=2,a=2 //b得到的是a+1之后的数为2  a自身加1为2
c=a++;  // c=2,a=3 //c得到的是a+1之前的数为2  a自身加1为3

重点：++和-- 左右值分析

• a++和a-- 得到的是临时的值（只能当右值）
• ++a和--a 得到的是有地址的值（可以当左右值）

总结：a++和a--不能被  ++或--修饰  

因为++需要传入一个&a ，传入不了一个临时值

++a和a++底层分析： 

++（a++）和++（++a）的区别 ：（--也相同）

#include<iostream>
using namespace std;
int main() {
	int a = 10;
	++(a++);//报错 原因是没有可修改左值
	++(++a);
	--(a--);//报错 原因是没有可修改左值
	--(--a);

	(a++)++;//报错 原因是没有可修改左值
	(++a)++;
	(--a)--;
	(a--)--;//报错 原因是没有可修改左值
	return 0;
}

 关系运算符：

运算符	描述
==	检查两个操作数的值是否相等，如果相等则条件为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。

逻辑运算符： 

运算符	描述
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。
||	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。

重点： &&和|| 采用短路原则

&&  ：当左边为false时，表达式为false，右边则不会执行

||     ：当左边为true时，表达式为true，右边则不会执行

 位运算符：

运算符	描述
&	如果同时存在于两个操作数中，二进制 与运算符复制一位到结果中。
|	如果存在于任一操作数中，二进制 或 运算符复制一位到结果中。
^	如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。
~	二进制补码运算符是一元运算符，相当于取反具有"翻转"位效果，即0变成1，1变成0。
<<	二进制左移运算符。左操作数的值向左移动右操作数指定的位数。左移一位相当于*2
>>	二进制右移运算符。左操作数的值向右移动右操作数指定的位数。右移一位相当于/2

位运算常用的用法：

1. 求是否为2的幂：n&(n-1)==0
2. 是否为4的幂：n&n-1)==0 && ( n& 0xaaaaaaaa)==0
3. x&(x-1)统计1的个数，
4. x|(x+1)统计0的个数 

 赋值运算符：

=	简单的赋值运算符，把右边操作数的值赋给左边操作数
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数
<<=	左移且赋值运算符
>>=	右移且赋值运算符
&=	按位与且赋值运算符
^=	按位异或且赋值运算符
|=	按位或且赋值运算符

其他运算符：

运算符	描述
sizeof	返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。
Condition ? X : Y	如果 Condition 为真 ? 则值为 X : 否则值为 Y。
,	会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。
.（点）和 ->（箭头）	用于引用类、结构和共用体的成员。
Cast	把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。
&	返回变量的地址。例如 &a; 将给出变量的实际地址。
*	指向一个变量。例如，*var; 将指向变量 var。

优先级： 

类别	运算符	结合性
后缀	() [] -> . ++ - -	从左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	从右到左
乘除	* / %	从左到右
加减	+ -	从左到右
移位	<< >>	从左到右
关系	< <= > >=	从左到右
相等	== !=	从左到右
位与 AND	&	从左到右
位异或 XOR	^	从左到右
位或 OR	|	从左到右
逻辑与 AND	&&	从左到右
逻辑或 OR	||	从左到右
条件	?:	从右到左
赋值	= += -= *= /= %=>>= <<= &= ^= |=	从右到左
逗号	,

 循环：

for循环：

for (循环初始; 循环条件; 循环控制) { 循环体; }

• 三个表达式可部分或全部省略，但两个分号不能省略（死循环）
• 可以只留循环条件，其他两个不写

while循环：

 while（循环条件）{循环体；}

do while循环 ：

do {循环体；}while（循环条件）

while和 do while 的区别：

• while 先判断再循环 ，do while 先循环再判断
• while 判断语句比循环语句多运行一次
• do while 判断语句和循环语句运行次数相同

循环控制语句：

continue	结束本次循环
break（跳出最靠近的一个循环）	跳出循环
goto(一般不要使用)	跳转

goto的格式：   标识：   .....   goto 标识 

int main(){
for(int i=0;i<20;i++)
{
    if(i=5)
    goto P;
}
P:
  cout<<"end"<<endl;
  system("pause");
  return 0;
}

常用的死循环：

1. for（；；） 
2. for(；1；）
3. while（1）

 条件语句：

关键词	描述
if	一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。
if ...else	一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
嵌套if	您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。
switch	一个 switch 语句允许测试一个变量等于多个值时的情况。
嵌套swtch	您可以在一个 switch 语句内使用另一个 switch 语句。

if注意事项：

• 当内容只有一句时 {}可以省略
• 嵌套循环时，else匹配离else最近且未匹配的if

switch注意事项：

•  swithc 语句括号里面必须为：整型、字符型或枚举型
• case语句括号里面必须为：常量表达式
• case匹配成功的话，会一直运行到遇到break
• case都未匹配，执行default
• default 可以放在任意位置
• case和default 后面都跟有：
• 如果需要在switch-case里面定义局部变量，case的语句需要加大括号

int main()
{
	int a = 10;
	switch (a)
	{
	case 1: {   //C/C++中用大括号{}括起的语句块，可以认为是一段完全独立的代码
        int b = 20;
		break;
	}	
	case 10:
		break;
	default:
		break;
	}
	system("pause");
	return 0;
}

匹配成功后会一直往下直到遇到bread 

int main()
{
	int a=0;
    cout << "请输入数据：";
	cin >> a;
	switch (a)
	{
	default:
		cout << 100 <<endl;
	case 5:
		cout << 50<<endl;
	case 6:
		cout << 60<<endl;
	}
	system("pause");
	return 0;
}

 

 三元运算符：

(关系表达式) ? 表达式1 : 表达式2;

true     返回表达式1

false    返回表达式2

枚举类型：

枚举类型：是一种派生数据类型，是由用户定义的若干枚举常量的集合

enum  <类型名>{<枚举常量表>}

枚举常量表示方法 ：

1. 枚举常量只能以标识符形式表示
2. 枚举常量不能是整型、字符型等文字常量

枚举的声明：

有效声明：
enum weekday{sun,mou,tue,wed,thu,fri,sat};
enum weekday{s1,m1,t1,w1,t1,f1,s1};
enum weekday{_sun,_mou,_tue,_wed,_thu,_fri,_sat};

无效声明：
enum weekday{"sun","mou","tue","wed","thu","fri","sat"};
enum weekday{1,2,3,4,5,6,6};

枚举值的计算：

• 没规定 默认从0开始计算
• 给出初始值的话，前面的数从0开始计算，后面的数依次+1

//没规定 默认从0开始计算
enum weekday{sun,mou,tue,wed,thu,fri,sat};
sum=0 mon=1 tue=2 wed=3 thu=4 fri=5 sat=6

//给出初始值的话，前面的数从0开始计算，后面的数依次+1  
enum weekday{sun,mou,tue=1,wed,thu,fri,sat};
sum=0 mon=1 tue=1 wed=2 thu=3 fri=4 sat=5

enum weekday{sun,mou,tue=7,wed,thu=3,fri,sat};
sum=0 mon=1 tue=7 wed=8 thu=3 fri=4 sat=5

枚举的定义：

1. 直接在大括号尾部添加；
2. 删除类型名，然后在大括号尾部添加；
3. 先声明完，然后再定义

//方法一
enum weekday { sun, mou, tue=7, wed, thu=3, fri, sat }a,b,c;
//方法二
enum { sun, mou, tue=7, wed, thu=3, fri, sat }a,b,c;
//方法三
enum weekday { sun, mou, tue=7, wed, thu=3, fri, sat };
enum weekday a,b,c; 或 weekday a,b,c;

枚举占用的内存： 

枚举占用内存的大小与整型数相同（int）

与枚举常量的个数无关 是一个固定值

enum weekday { sun, mou, tue=7, wed, thu=3, fri, sat };
weekday p;
cout << sizeof(p) << endl;//结果为4

enum weekday { sun, mou};
weekday p;
cout << sizeof(p) << endl;//结果为4

枚举常量的赋值操作：

 相同类型下：

1. 枚举变量可以赋值给枚举变量
2. 枚举常量可以赋值给枚举变量
3. 枚举变量和常量都可以赋值给整形变量  

enum weekday { sun, mou };
	weekday p,p1;
	p = sun;//枚举常量可以赋值给枚举变量
	p1 = p; //枚举变量可以赋值给枚举变量
	int a;
	int b;
	a = p; //枚举变量可以赋值给整形变量 
	b = sun;//枚举常量可以赋值给整形变量 

注意事项：枚举相当于是常量 ，不可修改

参考文献：

课程列表_牛客网 (nowcoder.com)

C++ 枚举类型详解 | 菜鸟教程 (runoob.com)