C++基础知识学习笔记

1 C++基础

1.1hello world

示例 helloworld

#include 
using namespace std;

//main函数是程序入口，每个程序必须有且仅有一个
int main()
{
//cout打印指定字符串
cout << "hello world" << endl;

system("pause");

return 0;

}

1.2注释

单行注释语法：//注释内容
多行注释语法：/* 注释内容 */
示例 注释

#include 
using namespace std;

/*main函数是程序入口，
每个程序必须有
且仅有一个*/
int main()
{
//打印指定字符串
cout << "hello world" << endl;
system("pause");

return 0;
}

1.3变量

定义：
给一段内存命名，方便调用该段内存
语法：
数据类型 变量名 = 变量初始值;
示例 创建变量

#include 
using namespace std;

int main()
{
/*创建变量：
数据类型 变量名 = 变量初始值;*/

int a = 10;

cout <<"a = " << a << endl;

system("pause");

return 0;
}

1.4常量

定义：常量用于记录程序中不可修改的数据
c++定义常量的两种方式：
1.#define 宏常量：#define 常量名 = 常量值

通常在文件上方定义

2.const 修饰变量：const 数据类型 变量名 = 变量值

通常用在变量定义前，修饰该变量为常量，不可修改

示例 创建常量

#include 
using namespace std;

#define Day 7//定义常量Day=7

int main()
{
//1.Day为常量不可修改
cout << "一周总共有： " << Day <<" 天" << endl;

//2.const修饰month变量为常量，
const int month = 12;

cout << "一年总共有： " << month <<" 个月份" << endl;

system("pause");

return 0;
}

1.5关键字

定义：关键字是C++中预先保留的标识符，在定义常量或变量时不能使用。
示例 关键字

#include 
using namespace std;

int main ()
{
//创建变量：数据类型 变量名称 = 变量初始值

int int = 10 //不能用关键字给变量取名

system("pause");

return 0;
}

关键字表：

C++98/03中有63个关键字，其中包含红色部分——C语言中的32个关键字。
[(转载)关于C语言的关键字请看博客:]
(https://blog.csdn.net/WEIYANGBIN/article/details/115133129)
下边是对每个关键字的详解：

1. asm
   asm (指令字符串)：允许在 C++ 程序中嵌入汇编代码。
2. auto
   auto（自动，automatic）是存储类型标识符，表明变量"自动"具有本地范围，块范围的变量声明（如for循环体内的变量声明）默认为auto存储类型。
3. bool
   bool（布尔）类型，C++ 中的基本数据结构，其值可选为 true（真）或者 false（假）。C++ 中的 bool 类型可以和 int 混用，具体来说就是 0 代表 false，非 0 代表 true。bool 类型常用于条件判断和函数返回值。
4. break
   break（中断、跳出），用在switch语句或者循环语句中。程序遇到 break 后，即跳过该程序段，继续后面的语句执行。
5. case
   用于 switch 语句中，用于判断不同的条件类型。
6. catch
   catch 和 try 语句一起用于异常处理。
7. char
   char（字符，character）类型，C++ 中的基本数据结构，其值一般为 0~255 的 int。这 256 个字符对应着 256 个 ASCII 码。char 类型的数据需要用单引号 ’ 括起来。
8. class
   class（类）是 C++ 面向对象设计的基础。使用 class 关键字声明一个类。
9. const
   const（常量的，constant）所修饰的对象或变量不能被改变，修饰函数时，该函数不能改变在该函数外面声明的变量也不能调用任何非const函数。在函数的声明与定义时都要加上const，放在函数参数列表的最后一个括号后。在 C++ 中，用 const 声明一个变量，意味着该变量就是一个带类型的常量，可以代替 #define，且比 #define 多一个类型信息，且它执行内链接，可放在头文件中声明；但在 C 中，其声明则必须放在源文件（即 .C 文件）中，在 C 中 const 声明一个变量，除了不能改变其值外，它仍是一具变量。如:
   const double pi(3.14159);
   const double pi = 3.14159;
10. const_cast用法：
    const_cast (expression)
    该运算符用来修改类型的 const 或 volatile 属性。除了 const 或 volatile 修饰之外， type_id 和 expression 的类型是一样的。常量指针被转化成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。
11. continue
    continue（继续）关键字用于循环结构。它使程序跳过代码段后部的部分，与 break 不同的是，continue 不是进入代码段后的部分执行，而是重新开始新的循环。因而它是"继续循环"之意，不是 break（跳出）。
12. default
    default（默认、缺省）用于 switch 语句。当 switch 所有的 case 都不满足时，将进入 default 执行。default 只能放在 switch 语句所有的 case 之后，并且是可选的。
13. delete
    delete（删除）释放程序动态申请的内存空间。delete 后面通常是一个指针或者数组 []，并且只能 delete 通过 new 关键字申请的指针，否则会发生段错误。
14. do
    do-while是一类循环结构。与while循环不同，do-while循环保证至少要进入循环体一次。
15. double
    double（双精度）类型，C++ 中的基本数据结构，以双精度形式存储一个浮点数。
16. dynamic_cast
    dynamic_cast（动态转换），允许在运行时刻进行类型转换，从而使程序能够在一个类层次结构安全地转换类型。dynamic_cast 提供了两种转换方式，把基类指针转换成派生类指针，或者把指向基类的左值转换成派生类的引用。
17. else
    else 紧跟在 if 后面，用于对 if 不成立的情况的选择。
18. enum
    enum（枚举）类型，给出一系列固定的值，只能在这里面进行选择一个。
19. explicit
    explicit（显式的）的作用是"禁止单参数构造函数"被用于自动型别转换，其中比较典型的例子就是容器类型。在这种类型的构造函数中你可以将初始长度作为参数传递给构造函数。
20. export
    为了访问其他编译单元（如另一代码文件）中的变量或对象，对普通类型（包括基本数据类、结构和类），可以利用关键字 extern，来使用这些变量或对象时；但是对模板类型，则必须在定义这些模板类对象和模板函数时，使用标准 C++ 新增加的关键字 export（导出）。
21. extern
    extern（外部的）声明变量或函数为外部链接，即该变量或函数名在其它文件中可见。被其修饰的变量（外部变量）是静态分配空间的，即程序开始时分配，结束时释放。用其声明的变量或函数应该在别的文件或同一文件的其它地方定义（实现）。在文件内声明一个变量或函数默认为可被外部使用。在 C++ 中，还可用来指定使用另一语言进行链接，这时需要与特定的转换符一起使用。目前仅支持 C 转换标记，来支持 C 编译器链接。使用这种情况有两种形式：
    extern “C” 声明语句
    extern “C” { 声明语句块 }
22. false
    false（假的），C++ 的基本数据结构 bool 类型的值之一。等同于 int 的 0 值。
23. float
    float（浮点数），C++ 中的基本数据结构，精度小于 double。
24. for
    for 是 C++ 中的循环结构之一。
25. friend
    friend（友元）声明友元关系。友元可以访问与其有 friend 关系的类中的 private/protected 成员，通过友元直接访问类中的 private/protected 成员的主要目的是提高效率。友元包括友元函数和友元类。
26. goto
    goto（转到），用于无条件跳转到某一标号处开始执行。
27. if
    if（如果），C++ 中的条件语句之一，可以根据后面的 bool 类型的值选择进入一个分支执行。
28. inline
    inline（内联）函数的定义将在编译时在调用处展开。inline 函数一般由短小的语句组成，可以提高程序效率。
29. int
    int（整型，integer），C++ 中的基本数据结构，用于表示整数，精度小于 long。
30. long
    long（长整型，long integer），C++ 中的基本数据结构，用于表示长整数。
31. mutable
    mutable（易变的）是 C++ 中一个不常用的关键字。只能用于类的非静态和非常量数据成员。由于一个对象的状态由该对象的非静态数据成员决定，所以随着数据成员的改变，对像的状态也会随之发生变化。如果一个类的成员函数被声明为 const 类型，表示该函数不会改变对象的状态，也就是该函数不会修改类的非静态数据成员。但是有些时候需要在该类函数中对类的数据成员进行赋值，这个时候就需要用到 mutable 关键字。
32. namespace
    namespace（命名空间）用于在逻辑上组织类，是一种比类大的结构。
33. new
    new（新建）用于新建一个对象。new 运算符总是返回一个指针。由 new 创建
34. operator
    operator（操作符）用于操作符重载。这是 C++ 中的一种特殊的函数。
35. private
    private（私有的），C++ 中的访问控制符。被标明为 private 的字段只能在本类以及友元中访问。
36. protected
    protected（受保护的），C++ 中的访问控制符。被标明为 protected 的字段只能在本类以及其继承类和友元中访问。
37. public
    public（公有的），C++ 中的访问控制符。被标明为 public 的字段可以在任何类
38. register
    register（寄存器）声明的变量称着寄存器变量，在可能的情况下会直接存放在机器的寄存器中；但对 32 位编译器不起作用，当 global optimizations（全局优化）开的时候，它会做出选择是否放在自己的寄存器中；不过其它与 register 关键字有关的其它符号都对32位编译器有效。
39. reinterpret_cast
    用法：
    reinpreter_cast (expression)
    1
    type-id 必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值）。
40. return
    return（返回）用于在函数中返回值。程序在执行到 return 语句后立即返回，return 后面的语句无法执行到。
41. short
    short（短整型，short integer），C++ 中的基本数据结构，用于表示整数，精度小于 int。
42. signed
    signed（有符号），表明该类型是有符号数，和 unsigned 相反。数字类型（整型和浮点型）都可以用 signed 修饰。但默认就是 signed，所以一般不会显式使用。
43. sizeof
    由于 C++ 每种类型的大小都是由编译器自行决定的，为了增加可移植性，可以用 sizeof 运算符获得该数据类型占用的字节数。
44. static
    static（静态的）静态变量作用范围在一个文件内，程序开始时分配空间，结束时释放空间，默认初始化为 0，使用时可改变其值。静态变量或静态函数，只有本文件内的代码才可访问它，它的名字（变量名或函数名）在其它文件中不可见。因此也称为"文件作用域"。在 C++ 类的成员变量被声明为 static（称为静态成员变量），意味着它被该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见；而类的静态成员函数也只能访问静态成员（变量或函数）。类的静态成员变量必须在声明它的文件范围内进行初始化才能使用，private 类型的也不例外。
45. static_cast
    用法：
    static_cast < type-id > ( expression )
    1
    该运算符把 expression 转换为 type-id 类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：
    ① 用于类层次结构中基类和子类之间指针或引用的转换。进行上行转换（把子类的指针或引用转换成基类表示）是安全的；进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。
    ② 用于基本数据类型之间的转换，如把 int 转换成 char，把 int 转换成 enum。这种转换的安全性也要开发人员来保证。
    ③ 把空指针转换成目标类型的空指针。
    ④ 把任何类型的表达式转换成void类?
    注意 static_cast 不能转换掉 expression 的 const、volitale、或者 __unaligned 属性。
46. struct
    struct（结构）类型，类似于 class 关键字，与 C 语言兼容（class 关键字是不与 C 语言兼容的），可以实现面向对象程序设计。
47. switch
    switch（转换）类似于 if-else-if 语句，是一种多分枝语句。它提供了一种简洁的书写，并且能够生成效率更好的代码。但是，switch 后面的判断只能是int（char也可以，但char本质上也是一种int类型）。switch 语句最后的 default 分支是可选的。
48. template
    template（模板），C++ 中泛型机制的实现。
49. this
    this 返回调用者本身的指针。
50. throw
    throw（抛出）用于实现 C++ 的异常处理机制，可以通过 throw 关键字"抛出"一个异常。
51. true
    true（真的），C++ 的基本数据结构 bool 类型的值之一。等同于 int 的非 0 值。
52. try
    try（尝试）用于实现 C++ 的异常处理机制。可以在 try 中调用可能抛出异常的函数，然后在 try 后面的 catch 中捕获并进行处理。
53. typedef
    typedef（类型定义，type define），其格式为：
    typedef 类型 定义名;
    1
    类型说明定义了一个数据类型的新名字而不是定义一种新的数据类型。定义名表示这个类型的新名字。
54. typeid
    指出指针或引用指向的对象的实际派生类型。
55. typename
    typename（类型名字）关键字告诉编译器把一个特殊的名字解释成一个类型。在下列情况下必须对一个 name 使用 typename 关键字：
    1． 一个唯一的name（可以作为类型理解），它嵌套在另一个类型中的。
    2． 依赖于一个模板参数，就是说：模板参数在某种程度上包含这个name。当模板参数使编译器在指认一个类型时产生了误解。
56. union
    union（联合），类似于 enum。不同的是 enum 实质上是 int 类型的，而 union 可以用于所有类型，并且其占用空间是随着实际类型大小变化的。
57. unsigned
    unsigned（无符号），表明该类型是无符号数，和 signed 相反。
58. using
    表明使用 namespace。
59. virtual
    virtual（虚的），C++ 中用来实现多态机制。
60. void
    void（空的），可以作为函数返回值，表明不返回任何数据；可以作为参数，表明没有参数传入（C++中不是必须的）；可以作为指针使用。
61. volatile
    volatile（不稳定的）限定一个对象可被外部进程（操作系统、硬件或并发线程等）改变，声明时的语法如下：
    int volatile nVint;
    这样的声明是不能达到最高效的，因为它们的值随时会改变，系统在需要时会经常读写这个对象的值。因此常用于像中断处理程序之类的异步进程进行内存单元访问。
62. wchar_t
    wchar_t 是宽字符类型，每个 wchar_t 类型占 2 个字节，16 位宽。汉字的表示就要用到 wchar_t。
63. while
    C++中的循环结构之一，表示一种入口条件循环。

1.6标识符

标识符命名规则：

1. 不能是关键字
2. 只能由子母，数字，下划线组成
3. 只能以字母或下划线开头
4. 字母区分大小写 //尽量做到见名识意

示例 标识符命名规则

#include 
using namespace std;

int main()
{
    //1.不能是关键字
    int int = 10 //错误

    //2.只能由子母，数字，下划线组成
    int abc = 10
    int abc_123 = 10
    int _abc = 10
    
system("pause");

return 0;
}

2.数据类型

2.1整形

定义：整形表示整数类型的数据。

整形 int	占4字节	范围-2^31 ~ 2^31-1 （-2147483948~2147483947）
短整型 short	占2字节	范围-2^15 ~ 2^15-1 （-3278~32767）
长整型 long	win占4字节 Linux占4字节（32位）8字节（64位）	范围-2^31 ~ 2^31-1 （-2147483948~2147483947）
长长整形 longlong	占8字节	范围-2^63 ~ 2^63-1 （-9223372036854775808~9223372036854775809）
示例 整形数据

#include 
using namespace std;

int main()
{
    int num1 = 10;
    short num2 = 10;
    long num3 = 10;
    long long num4 = 10;

    cout << "num1=" << num1 << endl;
    cout << "num2=" << num2 << endl;
    cout << "num3=" << num3 << endl;
    cout << "num4=" << num4 << endl;

    system("pause");

    return 0;
}

2.2 Sizeof关键字

作用：可以统计数据类型所占内存大小。
语法：sizeof(数据类型/变量)
示例 sizeof关键字

#include 
using namespace std;

int main()
{
    int num1 = 10;
    short num2 = 10;
    long num3 = 10;
    long long num4 = 10;

    cout << "sizeof int = " << sizeof(int) <<" 字节"<

2.3 实型（浮点型）

作用：用于表示小数
浮点型变量分为两种：
1.单精度float
2.双精度double //默认双精度，加f转换

数据类型	占用空间	有效数字范围
float	4字节	7位有效数字
double	8字节	15-16位有效数字
示例 实型

#include 
using namespace std;

int main()
{   
    //单精度
    float f1 = 3.1415926f;
    //双精度
    double d1 = 3.1415926;
    //默认显示6位有效数字
    cout << "f1 = " << f1 <

2.4字符型

作用：字符型变量用于显示单个字符
语法：char ch = ‘a’;

• 单引号内只能有一个字符，不能定义字符串
• 字符型变量只占1个字节
• 字符变量将字符对应ASCII码放入内存储存

示例 字符型

#include 
using namespace std;

int main()
{
    char ch = 'a';

    cout << "ch =" << ch << endl;

    //显示ch的ASCII码
    cout << "ch的ASCII码为：" << (int)ch << endl;

    //可以用ASCII码直接给变量赋值
    ch = 97;

    cout << "ch ="<

ASCII码表：

ASCII值	控制字符	ASCII值	控制字符	ASCII值	控制字符	ASCII值	控制字符
0	NUT	32	(space)	64	@	96	、
1	SOH	33	！	65	A	97	a
2	STX	34	”	66	B	98	b
3	ETX	35	#	67	C	99	c
4	EOT	36	$	68	D	100	d
5	ENQ	37	%	69	E	101	e
6	ACK	38	&	70	F	102	f
7	BEL	39	,	71	G	103	g
8	BS	40	(	72	H	104	h
9	HT	41	)	73	I	105	i
10	LF	42	*	74	J	106	j
11	VT	43	+	75	K	107	k
12	FF	44	,	76	L	108	l
13	CR	45	-	77	M	109	m
14	SO	46	.	78	N	110	n
15	SI	47	/	79	O	111	o
16	DLE	48	0	80	P	112	p
17	DCI	49	1	81	Q	113	q
18	DC2	50	2	82	R	114	r
19	DC3	51	3	83	S	115	s
20	DC4	52	4	84	T	116	t
21	NAK	53	5	85	U	117	u
22	SYN	54	6	86	V	118	v
23	TB	55	7	87	W	119	w
24	CAN	56	8	88	X	120	x
25	EM	57	9	89	Y	121	y
26	SUB	58	:	90	Z	122	z
27	ESC	59	;	91	[	123	{
28	FS	60	<	92	/	124
29	GS	61	=	93	]	125	}
30	RS	62	>	94	^	126	~
31	US	63	?	95	—	127	DEL

2.5转义字符 \

作用：显示一些不能显示的ASCII字符
常用转义字符 \n \\ \t

转义字符	含义	ASCII码值（十进制）
\a	警报	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个TAB位置）	009
\v	垂直制表(VT)	011
\\	代表一个反斜线字符""	092
’	代表一个单引号（撇号）字符	039
"	代表一个双引号字符	034
?	代表一个问号	063
\0	数字0	000
\ddd	8进制转义字符，d范围0~7	3位8进制
\xhh	16进制转义字符，h范围09，af，A~F	3位16进制
示例 转义字符

#include 
using namespace std;

int main()
{
    //\n 换行符
    cout << "hello world hello world" << endl;
    cout <<  "hello world \nhello world" << endl;

    // \\ 显示\    
    
    cout <<  "\\" << endl;

    //\t 制表符
    cout << "aaa \thello world" << endl;
    cout << "aa \thello world" << endl;
    cout << "a \thello world" << endl;
    

    system("pause");

    return 0;
}

2.6字符串型

作用：用于表示一串字符

C语法：char 变量名[] = “字符串”

C++语法：string 变量名 = “字符串”
示例 字符串型

#include 
using namespace std;

//用于c++字符串函数string
#include

int main()
{
    //c语言字符串
    char str1[] = "hello world";
    cout << str1 << endl;

    //c++字符串，注意添加string头文件否则不能调用string函数
    string str2 = "hello world";
    cout << str2 << endl;

    system("pause");


    return 0;
}

2.7布尔型bool

布尔值：
true 真 本质是1
false 假 本质是0

布尔类型占1个字节

示例 布尔型

#include 
using namespace std;

int main()
{
    //定义布尔值flag1 flag2
    bool flag1 = true;
    bool flag2 = false;

    cout << flag1 << endl;
    cout << flag2 << endl;

    //查看布尔值占用空间
    cout << "布尔值占用空间为："<

2.8数据的输入cin

语法：cin >> 变量
示例 cin

#include 
using namespace std;
//用于调用string函数
#include 
int main()
{
    
    //整形数据输入
    /*int i = 0;
    cout << "请输入整型数据：" << endl;
        cin >> i;
    cout << "整形数据为："<> f;
    cout <<"浮点型数据为："<< f << endl;*/

    //字符型数据输入
    /*char ch = '0';
    cout << "请输入字符型数据：" << endl;
    cin >> ch;
    cout << "字符型数据为：" << ch << endl;*/

    //字符串型数据输入
    /*string str;
    cout << "请输入字符串型数据：" << endl;
    cin >> str;
    cout << "字符串型数据为：" << str << endl;*/

     //布尔型数据输入
    bool flag = true;
    cout << "请输入布尔型数据：" << endl;
    cin >> flag;
    cout << "布尔型数据为：" << flag << endl;

    system("pause");


    return 0;
}

3.运算符

3.1算数运算符-加减乘除

运算符作用：用于执行代码的运算
算术运算符作用：用于处理四则运算

运算符	术语	示例	结果
+	正号	+3	3
-	负号	-3	-3
+	加	10 + 5	15
-	减	10 - 5	5
*	乘	10 * 5	50
/	除	10 / 5	2
%	取模(取余)	10 % 3	1
++	前置递增	a=2; b=++a;	a=3; b=3;
++	后置递增	a=2; b=a++;	a=3; b=2;
–	前置递减	a=2; b=–a;	a=1; b=1;
–	后置递减	a=2; b=a–;	a=1; b=2;

示例: 运算符

#include
using namespace std;

int main() 
{
	//加减乘除
	int a1 = 10;
	int b1 = 2;

	cout << a1 + b1 << endl;
	cout << a1 - b1 << endl;
	cout << a1 * b1 << endl;
	//整数相除还是整数，分母不能为0
	cout << a1 / b1 << endl;

	//小数可以相除
	double a2 = 3.25;
	double b2 = 0.5;

	cout << a2 / b2 << endl;
	system("pause");

	return 0;

}

3.2算术运算符-取模

用法：数值 % 取模值（不能为0） = 余数
示例:取模

#include
using namespace std;

int main()
{
	//取模运算本质是取余数,被除数不能为0
	int a1 = 10;
	int b1 = 3;

	cout << a1 % b1 << endl;
	int a2 = 10;
	int b2 = 20;

	cout << a2 % b2 << endl;

	//两个小数不能取模

	system("pause");

	return 0;
}

3.3算术运算符-递增递减

示例:递增递减

#include
using namespace std;

int main()
{
	//前置递增
	int a = 10;
	++a;
	cout << "a = " << a<

3.4赋值运算符

作用：用于将表达式的值赋给变量

运算符	术语	示例	结果
=	赋值	a=2; b=3;	a=2; b=3;
+=	加等于	a=0; a+=2;	a=2;
-=	减等于	a=5; a-=3;	a=2;
*=	乘等于	a=2; a*=2;	a=4;
/=	除等于	a=4; a/=2;	a=2;
%=	模等于	a=3; a%2;	a=1;
示例 赋值运算符

#include
using namespace std;

int main()
{
	// =
	int a = 10;
	a = 100;
	cout << "a = " << a << endl;

	//+=
	int a1 = 10;
	a1 += 10;
	cout << "a1 += " << a1 << endl;

	//-=
	int a2 = 10;
	a2 -= 10;
	cout << "a2 -= " << a2 << endl;
	//*= 
	int a3 = 10;
	a3 *= 10;
	cout << "a3 *= " << a3 << endl;
	//=
	int a4 = 10;
	a4 /= 10;
	cout << "a4 /= " << a4 << endl;
	
	//%=
	int a5 = 10;
	a5 %= 3;
	cout << "a5 %= " << a5 << endl;

	system("pause");

	return 0;
}

3.5比较运算符

作用：用于表达式的比较，返回一个布尔值

运算符	术语	示例	结果
==	相等于	4 == 3	0
!=	不等于	4 != 3	1
<	小于	4 < 3	0
>	大于	4 > 3	1
<=	小于等于	4 <= 3	0
>=	大于等于	4 >= 1	1

示例 比较运算符

#include
using namespace std;

int main()
{
	int a = 10;
	int b = 20;
	//==等于
	cout << (a == b)//括号中表达式优先执行
		<< endl;

	//!=不等于
	cout << (a != b)<< endl;

	//<小于
	cout << (a < b) << endl;

	//>大于
	cout << (a > b) << endl;

	//<=小于等于
	cout << (a <= b) << endl;

	//>=大于等于
	cout << (a >= b) << endl;
	system("pause");

	return 0;
}

3.6逻辑运算符

作用：根据表达式的值返回布尔值

运算符	术语	示例	结果
!	非	!a	如果a为假，则!a为真； 如果a为真，则!a为假。
&&	与	a && b	如果a和b都为真，则结果为真，否则为假。
||	或	a || b	如果a和b有一个为真，则结果为真，二者都为假时，结果为假。
示例 非

#include
using namespace std;

int main()
{
	//!表示非，C++中数值除了0都为真
	int a = 10;
	cout << !a << endl;//对真取非运算
	cout << !!a << endl;//对真取非非运算
	system("pause");

	return 0;

}

示例 与

#include
using namespace std;

int main()
{	
	//C++中数值除了0都为真
	//&&表示与，都为真则为真
	int a = 10;
	int b = 20;
	cout << (a&&b) << endl;//对ab取与运算

	int a1 = 10;
	int b1 = 0;
	cout << (a1&&b1) << endl;//对ab取与运算

	int a2 = 0;
	int b2 = 0;
	cout << (a2&&b2) << endl;//对ab取与运算

	system("pause");

	return 0;

}

示例 或

#include
using namespace std;

int main()
{
	//C++中数值除了0都为真
	//||表示或，一真即为真
	int a = 10;
	int b = 20;
	cout << (a || b) << endl;//对ab取与运算

	int a1 = 10;
	int b1 = 0;
	cout << (a1 || b1) << endl;//对ab取与运算

	int a2 = 0;
	int b2 = 0;
	cout << (a2 || b2) << endl;//对ab取与运算

	system("pause");

	return 0;

}

4.程序流程结构

C/C++支持三种程序流程结构：
1.顺序结构：程序按顺序执行，不发生跳转
2.选择结构：依据条件是否满足，有选择的执行相应功能
3.循环结构：依据条件是否满足，循环多次执行某段代码

4.1选择结构

4.1.1 if语句

if 语句的三种形式：
1.单行格式if语句：
if(条件){条件满足执行语句}
2.多行格式if语句:
if(条件){条件满足执行语句}
else{条件满足执行语句}
3. 多条件的if语句:
if(条件){条件满足执行语句}
else if{条件满足执行语句}
…
else{都不满足执行语句}

if可以嵌套使用，更精确控制条件**

示例 单行if

#include
using namespace std;
int main ()
{
	//单行if语句,实现输入分数，600分以上输出考上一本
	int score = 0;
	cout << "请输入您的分数：" << endl;
	cin >> score;
	cout << "您的分数为：" < 600)
	{
		cout << "恭喜您！考上了一本！！" << endl;
	}

	system("pause");
	return 0;

}

示例 多行if

#include
using namespace std;
int main()
{
	//多行if语句,实现输入分数，高于600分输出考上一本
	//低于600分输出未考上一本大学

	int score = 0;
	cout << "请输入您的分数：" << endl;
	cin >> score;
	cout << "您的分数为：" << score << endl;
	if (score > 600)
	{
		cout << "恭喜您！考上了一本大学！！" << endl;
	}
	else
	{
		cout << "再接再厉，您未考上一本大学！" << endl;
	}

	system("pause");
	return 0;

}

示例 多条件if

#include
using namespace std;
int main()
{
	//多条件if语句,实现输入分数，高于600分输出考上一本
	//高于500分输出考上二本大学
	//高于300分输出考上三本大学
	//低于300分输出为未考上本科

	int score = 0;
	cout << "请输入您的分数：" << endl;
	cin >> score;
	cout << "您的分数为：" << score << endl;
	if (score > 600)
	{
		cout << "恭喜您！考上了一本大学！！" << endl;
	}

	else if(score>500)
	{
		cout << "您考上了二本大学！" << endl;
	}

	else if (score>300)
	{
		cout << "您考上了三本大学！" << endl;
	}

	else
	{
		cout<<"很遗憾，您未考上本科大学！"<

示例 嵌套if

#include
using namespace std;
int main()
{
	//嵌套if语句,实现输入分数，高于600分输出考上一本
		// 一本中高于700分考上清华
		// 650分考上北大
		// 600分考上浙大
	//高于500分输出考上二本大学
	//高于300分输出考上三本大学
	//低于300分输出为未考上本科

	int score = 0;
	cout << "请输入您的分数：" << endl;
	cin >> score;
	cout << "您的分数为：" << score << endl;
	if (score > 600)
	{
		cout << "恭喜您！考上了一本大学！！" << endl;

		if (score > 700)
		{
			cout<<"恭喜您!考上了清华！！"<650)
		{
			cout << "恭喜您!考上了北大！！" << endl;
		}
		else
		{
			cout << "恭喜您!考上了浙大！！" << endl;
		}
	}

	else if (score > 500)
	{
		cout << "您考上了二本大学！" << endl;
	}

	else if (score > 300)
	{
		cout << "您考上了三本大学！" << endl;
	}

	else
	{
		cout << "很遗憾，您未考上本科大学！" << endl;
	}

	system("pause");

	return 0;

}

示例 三只小猪称体重

#include
using namespace std;
int main()
{
	//三只小猪ABC选出最重一只
	//程序结构ABC比较
	/*程序设计思路：
	AB比较
	A重 
	AC比较
		A重 A最重
		C重 C最重
	B重 
	BC比较
		B重 B最重
		C重 C最重*/
	//1.输入并显示ABC体重
	int a = 0;
	int b = 0;
	int c = 0;
	cout << "请输入A体重:" << endl;
	cin >> a;
	cout << "请输入B体重:" << endl;
	cin >> b;
	cout << "请输入C体重:" << endl;
	cin >> c;
	cout << "三只小猪ABC体重为:" << "\n" < b)
	{
		if (a > c)
		{
			cout << "A最重" << endl;

		}
		else if (a < c)
		{
			cout << "C最重" << endl;
		}
	}
	else if (a < b)
	{
		if (b > c)
		{
			cout << "B最重" << endl;
		}
		else if (b < c)
		{
			cout << "C最重" << endl;
		}
	}
	
	
	//3.BC比较

	system("pause");
	return 0;

}

4.1.2三目运算符

作用：通过三目运算符实现简单判断
语法：表达式1 ? 表达式2 : 表达式3

表达式1为真，执行表达式2，返回表达式2的值
表达式1为假，执行表达式3，返回表达式3的值
示例

#include
using namespace std;
int main()
{
	int a = 30;
	int b = 20;
	int c = 0;

	//比较ab的值，将最大值赋值给c
	c = a > b ? a : b;
		cout << c << endl;
	//三目运算返回的是变量，可以继续赋值
	(a > b ? a : b) = 100;//提高三目运算优先级，否则优先赋值b=100
	cout << "a = "<

4.1.3 switch语句

作用：执行多条分支语句
语法：

switch(表达式)
{
	case 结果1：执行语句；break;
	case 结果2：执行语句；break;
	...
	default:执行语句;break;
}

只能判断整形或字符型变量，不能判断区间，执行效率优于if语句

示例

#include
using namespace std;
int main()
{
	/* stitch语句电影打分
	10-9分经典
	8-7分 非常好
	7-5分 一般
	5分以下 烂片*/
	//输入电影评分
	int score = 0;
	cout << "请输入电影评分：" << endl;
	cin >> score;
	//分析评分结果
	switch (score)
	{
		case 10:
			cout << "经典" << endl;
			break;
		case 9:
			cout << "经典" << endl; 
			break;
		case 8:
			cout << "非常好" << endl;
			break;
		case 7:
			cout << "非常好" << endl; 
			break;
		case 6:
			cout << "一般" << endl;
			break;
		case 5:
			cout << "一般" << endl; 
			break;
		default:
			cout << "烂片" << endl;
			break;
	}

	system("pause");
	return 0;

}

4.2循环结构

4.2.1 while循环语句

作用：满足循环条件（循环结果为真），执行循环语句
语法：
while(循环条件){循环语句}

必须提供循环出口，避免死循环

示例1 循环打印数字0-9

#include
using namespace std;
int main()
{	
	//循环打印数字0-9
	int a = 0;

	while (a < 10)//避免死循环
	{
		cout << a << endl;
		a++;
	}
	

	system("pause");
	return 0;

}

示例2 猜数字

#include
using namespace std;

#include

int main()
{
	//系统随机生产1-100数字并与玩家给出数字进行比较
	srand((unsigned int)time(NULL));//添加随机数种子利用系统时间生产随机数，防止每次随机数都一样
	//系统生成随机数字
	int num = rand() % 100 + 1;//rand生成（0-99）+1即随机数1-100

	//玩家猜测数字
	int value = 0;
	cout << "请输入数字：" << endl;
	
		//比较数字并给出比较结果,猜对后退出
	while (1)
	{
		cin >> value;//猜错后重新输入数值
		if (value > num)
		{
			cout << "猜测过大" << endl;
		}
		else if (value < num)
		{
			cout << "猜测过小" << endl;
		}
		else
		{
			cout << "恭喜你猜对了！" << endl;
			break;//猜对后退出循环
		}
		
	}



	system("pause");
	return 0;
}

4.2.2 do while循环语句

作用：满足循环条件执行循环语句
语法：do{循环语句}while(循环条件);

与while的区别：do while先执行一次循环语句，再判断循环条件

示例 循环打印数字

#include
using namespace std;
int main()
{
	//循环打印数字0-9
	int a = 0;
	do
	{
		cout << a << endl;
		a++;
	} while (a < 10);//避免死循环
	



	system("pause");
	return 0;

}

案例 水仙花数

#include
using namespace std;
int main()
{
	//取出所有三位水仙花数（个十百位三次方之和为该数字本身）
	// 取出所有三位数
	int num = 100;
	do
	{	//取出个十百位数字
		int g = 0;
		int s = 0;
		int b = 0;

		g = num % 10;
		s = num / 10 % 10;
		b = num / 100;

		if (g*g*g+s*s*s+b*b*b == num)//判断是否为水仙花数
		{
			cout <<"水仙花数为：" <

4.2.3 for循环

作用：满足循环条件，执行循环语句
语法：for(起始表达式；条件表达式；末尾循环体){循环语句；}
示例 循环打印数字

#include
using namespace std;

int main()
{
	//for循环打印数字0-9
	for (int i=0;i<10;i++)
	{
		cout << i << endl;
	}

	system("pause");
	return 0;

}

示例 敲桌子

#include
using namespace std;

int main()
{
	//敲桌子：1-100尾数7，，十位7，或7的背书
	//生成1-100的整数
	for (int i = 1; i < 100; i++)
	{	
		//个位7，十位7，或7的倍数
		
		if (i%7==0||i%10==7||i/10==7)
		{
			cout << "敲桌子" << endl;
		}
		else
		{
			cout << i << endl;
		}
	}

	system("pause");
	return 0;

}

4.2.4嵌套循环

语法：在循环体中再嵌套一层循环，解决一些实际问题
示例 打印星图

#include
using namespace std;
int main()
{
	//打印10*10星图
	//纵向打印10颗*
	for (int i = 0; i < 10; i++)
	{
		//横向打印10颗*
		for (int j = 0; j < 10; j++)
		{
			cout << "* ";
		}
		cout << endl;
	}
	
	system("pause");

	return 0;

}

示例 乘法口诀表

#include
using namespace std;
int main()
{
	//打印乘法口诀表
	//列数 * 行数 = 结果 且 列数<= 行数
	
	for (int h = 1;h < 10; h++)//输出行数
	{
		for (int l = 1; l <= h; l++)//输出列数
		{
			cout << l<<" * "<

4.3跳转语句

4.3.1 break语句

作用：跳出选择结构或循环结构
使用时机：

• switch语句中终止case并跳出switch
• 循环语句中跳出当前循环语句
• 嵌套循环中跳出最近内层循环语句

示例 break

#include
using namespace std;

int main()
{
	//break选择副本难度

	int select = 0;
	cout << "请选择副本难度:1 简单模式 2中等模式 3困难模式" << endl;
	cin >> select;
	switch (select)
	{
	case 1:
		cout << "你选择的是简单模式！" << endl;
		break;
	case 2:
		cout << "你选择的是中等模式！" << endl;
		break;
	case 3:
		cout << "你选择的是困难模式！" << endl;
		break;
	}

	//break出现在for循环
	for (int i = 0; i < 10; i++)
	{
		if (i == 5)
		{
			break;//退出for循环	
		}
		cout << i << endl;
	}
	//break出现在嵌套循环
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			if (j == 5)
			{
				break;//退出内层循环
			}
			cout << " * " ;
		}
		cout << endl;
	}


	system("pause");
	return 0;
}

4.3.2 continue语句

作用：在循环语句中，跳过本次循环中尚未执行的语句，继续执行下一次循环
示例

#include
using namespace std;

int main()
{
	//continue跳过偶数输出
	for (int i = 0; i < 100; i++)
	{
		if (i %2== 0)
		{
			continue;
		}
		cout << i << endl;
	}

	system("pause");
	return 0;
}

4.3.3 goto语句

作用：跳转到标记位置(慎用影响代码阅读)
语法：goto 标记位置;
示例 goto

#include
using namespace std;

int main()
{
	//goto跳转到标记位置
	goto eye;
	cout << "1.xxxxx" << endl;
	cout << "2.xxxxx" << endl;
	cout << "3.xxxxx" << endl;
	eye:
	cout << "4.xxxxx" << endl;
	cout << "5.xxxxx" << endl;
	system("pause");
	return 0;
}

5.数组

5.1概述

数组定义：数组是一个集合，里面存放相同类型的数据元素

1.数组中的数据类型相同
2.数组由连续内存位置组成

5.2一维数组

5.2.1一维数组定义方式

1.数据类型 数组名[数组长度];
2.数据类型 数组名[数组长度] = {值1,值2…};
3.数据类型 数组名[ ] = {值1,值2…};

元素下标由0开始

示例 一维数组

#include
using namespace std;

int main()
{
	//方式1:数组类型 数组名 [数组长度]；
	int arr [5];
	//数组元素赋值
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;

	//访问数据元素 cout<

5.2.2一维数组-组名

组名用途：
1.统计整个数组在内存中的长度

数组长度：sizeof(数组名)
单个元素长度：sizeof(数组名[0])
元素个数：sizeof(数组名)/sizeof(数组名[0])
末尾元素下标：sizeof(数组名)/sizeof(数组名[0])-1

2.获取数组在内存中的首地址

cout<<数组名<

3.获取元素在内存中的地址

cout<<&数组名[下标]<

示例 一维数组

#include
using namespace std;

int main()
{
	//1.查看数组长度
	int arr[5] = { 10,20,30,40,50 };
	cout <<"数组长度为：" << sizeof(arr) << endl;
	//查看单个元素长度
	cout <<"单个元素长度为： "<< sizeof(arr[0]) << endl;
	//查看元素个数
	cout << "元素个数为："<

示例 五只小猪称体重

#include
using namespace std;

int main()
{
	//五只小猪体重 int arr[]={300,350,200,400,250};选出最重的
	//1.循环输出五只小猪体重
	int arr[] = { 300,350,200,400,250 };

	int max = 0;//定义一个最体重

	for (int i = 0; i < 5; i++)
	{
		//2.找出最大值
		if (arr[i]>max)
		{
			max = arr[i];
		}
		
	}
	//3.打印最大值
	cout << "体重最大的小猪为： " << max << endl;

	system("pause");

	return 0;

}

示例 数组元素逆置

#include
using namespace std;

int main()
{
	//1.打印数组元素
	int arr[] = { 1,2,3,4,5 };
	cout << "逆置前的数组为：" << endl;
	for (int i=0; i < 5; i++) 
	{
		cout << arr[i] << endl;

	}

	//2.逆置元素
	int start = 0;//首元素下标
	int end = sizeof(arr) / sizeof(arr[0]) - 1;//尾元素下标

		while (start

5.2.3冒泡排序

作用：最常用的排序方法，对数组内元素进行排序

1.比较相邻元素，后一个比前一个大则交换元素位置
2.对该数组每一对相邻元素比较并交换，找到第一个最大值
3.重复以上步骤，每次比较次数减1直到不需要比较1

总排序轮数 = 元素个数 - 1
单轮对比交换次数 = 元素个数 - 当前排序轮数(0轮开始) - 1

示例 冒泡排序

#include
using namespace std;

int main()
{
	int arr[] = { 5,6,8,2,1,4,7,3,9 };
	cout << "初始数组为："<< endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i];
	}
	//2.重复比较至最后一轮
	for (int i = 0; i < 9-1; i++)//共比较:元素个数-1轮
	{
		//1.比较并交换相邻元素
		for (int j = 0; j < 9-i-1; j++)//交换次数为：元素个数-交换轮次（0轮起）-1轮
		{
			//比较并交换元素位置
			if (arr[j] < arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}		
	cout << "排序后的结果为：" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i];
	}

	system("pause");

	return 0;

}

##5.3二维数组
###5.3.1二维数组定义方式
语法：
1.数据类型 数组名[行数][列数];
2.数据类型 数组名[行数][列数]={{数据1，数据2},{数据3，数据4}};//更加直观，可读性好
3.数据类型 数组名[行数][列数]={数据1，数据2，数据3，数据4}；
4.数据类型 数组名[][列数]={数据1，数据2，数据3，数据4}；
示例 二维数组

#include
using namespace std;

int main()
{
	//方式1：数据类型 数组名[行数][列数] 
	int arr1[2][3];
	arr1[0][0]=1;
	arr1[0][1]=2;
	arr1[0][2]=3;
	arr1[1][0]=4;
	arr1[1][1]=5;
	arr1[1][2]=6;

	for (int i = 0; i < 2; i++)//外行循环打印行
	{
		for (int j = 0; j < 3; j++)//内行循环打印列
		{
			cout << arr1[i][j] << " ";
		}
		cout << endl;
	}

	//方式2：数据类型 数组名[行数][列数]={{数据1，数据2}，{数据3，数据4}}；
	int arr2[2][3] = 
	{	{1,2,3} ,
		{4,5,6}
	};
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr2[i][j] << " ";
		}
		cout << endl;
	}

	//方式3.数据类型 数组名[行数][列数]={{数据1，数据2},{数据3，数据4}};
	int arr3[2][3] = { 1,2,3,4,5,6 };
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr3[i][j] << " ";
		}
		cout << endl;
	}

	//方式4.数据类型 数组名[][列数]={数据1，数据2，数据3，数据4}；
	int arr4[][3] = { 1,2,3,4,5,6 };
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr4[i][j] << " ";
		}
		cout << endl;
	}

	system("pause");

	return 0;

}

5.3.2二维数组组名

作用：

• 查看二维数组占用空间：
  1.查看二维数组所占内存空间：sizeof(数组名)
  2.二维数组首（单）行占用空间：sizeof（数组名[0]）
  3.二维数组首（单）元素占用内存：sizeof[0][0]
• 计算行，列数：
  1.二维数组行数：sizeof(数组名)/sizeof（数组名[0]）
  2.二维数组列数：sizeof(数组名[0])/sizeof(数组名[0][0])
• 查看二维数组地址：
  1.二维数组首地址：cout<<数组名< 2.二维数组i行地址：cout<<数组名[i]< 3.二维数组i行j列元素首地址：cout<<&数组名[i][j]< 示例 二维数组组名

#include
using namespace std;

int main()
{
	int arr[2][3] =
	{ {1,2,3},
		{4,5,6}
	};
	//1.查看二维数组占用空间
	cout << "二维数组占用空间为： " << sizeof(arr) <<"字节" <

案例 求总分
案例描述：
有三名同学（张三，李四，王五），在一次考试中的成绩分别如下表，
请分别输出三名同学的总成绩

	语文	数学	英语
张三	100	100	100
李四	90	50	100
王五	60	70	80

#include
using namespace std;
#include

int main()
{
	//1.用二维数组存储三位同学成绩
	int scores[3][3] =
	{   {100,100,100},
		{90,50,100},
		{60,70,80}
	};

	//创建数组存储学生姓名name
	string name[3]{ "张三","李四","王五" };

	//2.循环输出三位同学成绩
	for (int i = 0; i < 3;i++ )
{
	int sum = 0;
		for (int j = 0; j < 3; j++)
		{
			//计算每位同学总分（每行分数相加）
			sum += scores[i][j];//+=求和
		}
	//3.输出三位同学成绩
	cout <

#6.函数

6.1函数的作用

函数的作用：将一段常用代码封装起来，减少重复代码

6.2 函数的定义

函数语法：

返回值类型 函数名 （参数列表）
{
函数体语句

return表达式
}
示例 定义加法函数

#include
using namespace std;

//定义函数add,实现两个数据相加
int add(int num1, int num2)
{	
	int sum = num1 + num2;
	return sum;
}

int main()
{
	

	system("pause");
		return 0;
}

6.3函数的调用

语法：函数名(参数)
函数定义时的参数为形参，函数调用时传入的参数为实参

#include
using namespace std;

//定义函数add,实现两个数据相加
int add(int num1, int num2)//num1,num2为形参
{
	int sum = num1 + num2;
	return sum;
}

int main()
{
	//调用add函数
	int a = 10;//a,b为实参
	int b = 5;
	int c = add(a, b);
		cout << c << endl;

	system("pause");
	return 0;
}

6.4值传递

定义：函数调用时实参将数值传入给形参
值传递时，如果形参发生改变并不影响实参
地址传递时，如果形参发生改变会影响实参
示例 值传递

#include
using namespace std;

//定义函数swap交换数据
void swap(int num1, int num2)//void表示函数不需要返回值
{
	cout << "返回前的值为： " << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	//交换数据num1和num2
	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "返回后的值为： " << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

}
int main()
{
	
	int a = 10;
	int b = 20;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	swap(a, b);//做值传递时形参发生改变不会影响实参
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	system("pause");
	return 0;
}

6.5函数的常见形式

常见函数形式：
1.无参无返
2.有参无返
3.无参有返
4.有参有反
示例 函数常见形式

#include
using namespace std;

//常见函数形式：
//1.无参无返
void test01()
{
	cout << "this is test01" << endl;
	}
//2.有参无返
void test02(int num1)
{
	cout << "this is test02 num1 = " << num1 << endl;
}
//3.无参有返
int test03()
{
	cout << "this is test03" << endl;
	return 1000;
}
//4.有参有反
int test04(int num1)
{
	cout << "this is test04 num1 = "<< num1<

6.6函数的声明

定义：提前告诉编译器函数的存在，可以将函数写到main函数下
声明可以写多次，定义只能写一次
示例 函数声明

#include
using namespace std;

//声明函数max
int max(int num1,int num2);

int main()
{
	int a = 5;
	int b = 10;
	cout << max(a, b) << endl;

	system("pause");
	return 0;
}
//定义函数max比较两个数字大小
int max(int num1, int num2)
{
	return num1 > num2 ? num1 : num2;
}

6.7函数的分文件编写

编写步骤：
1.创建.h头文件
2.创建.cpp源文件
3.头文件编写函数声明
4.源文件编写函数定义
示例 函数分文件编写
.h头文件

//关联C++相关头文件
#include 
using namespace std;

//swap函数声明
void swap(int num1, int num2);

.cpp源文件*

//关联swap函数头文件
#include "swap.h"//自定义文件用""引用

//swap函数定义
void swap(int num1, int num2)
{
	int temp = num1;
	num1 = num2;
	num2 = temp;
	cout << num1 << " " << num2 << endl;
}

主函数

#include
using namespace std;

//引用函数头文件
#include"swap.h"

//定义函数swap,交换num1,num2
//void swap(int num1, int num2)
//{
//	int temp = num1;
//	num1 = num2;
//	num2 = temp;
//	cout << num1<<" " << num2 << endl;
//}

int main()
{
	int a = 5;
	int b = 10;
	swap(a, b);
	
	system("pause");
	return 0;
}

7指针

7.1指针基本概念

指针的作用：可以利用指针间接访问内存

内存标号从0开始，一般为十六进制
可以利用指针变量保存地址

7.2 指针变量的定义和应用

语法：
变量类型 * 指针变量名;
获取变量地址：
变量名 = &变量名；
解引用：
*指针名//引用指向地址的实际内容
示例 指针定义和应用

#include
using namespace std;

int main()
{
	int i = 10;
	//指针p指向i
	int * p;
	p = &i;
	cout << &i << endl;
	cout << p << endl;
	//解引用
	cout << i << endl;
	cout << *p << endl;

	system("pause");

	return 0;
}

7.3指针所占空间

指针也是一种数据类型有：int * ,float ,double,char *等用于定义指针数据类型
占用空间：32位操作系统占4字节，64位操作系统占8字节
示例 指针所占空间

#include
using namespace std;

int main2()
{
	int i = 10;

	//创建指向变量i的指针p
	int* p = &i;
	//查看指针所占内存空间
	cout << "int类型指针所占空间为：" << sizeof(int *) <<"字节" << endl;
	cout << "char类型指针所占空间为：" << sizeof(char *) << "字节" << endl;
	cout << "double类型指针所占空间为：" << sizeof(double *) << "字节" << endl;
	cout << "字符类型指针所占空间为：" << sizeof(char *) << "字节" << endl;
	cout << "string类型指针所占空间为：" << sizeof(string *) << "字节" << endl;
	system("pause");

	return 0;
}

7.4空指针和野指针

空指针：指针变量指向内存中编号为0的空间，用于初始化指针变量，空指针内存不能访问
指针类型 * 指针变量 =NULL
野指针：指针变量指向非法内存空间
示例 空指针

#include
using namespace std;

int main()
{
	int i = 10;
	//定义空指针p
	int* p = NULL;

	//无法访问空指针P
	//cout << *p << endl;

	//0-255内存地址为系统占用内存无法访问
	*p = 100;
	cout << *p << endl;

	system("pause");

	return 0;
}

示例2 野指针

#include
using namespace std;

int main()
{
	//定义指针p指向非法内存空间0x1200
	int * p =(int *)0x1200;//注意转换地址类型为int *整数指针类型

	//报错，无法访问0x1200地址
	cout << *p << endl;

	system("pause");

	return 0;
}

7.5const修饰指针

1.const修饰指针-常量指针：
const 数据类型 * 指针变量 = 变量地址
指针指向可以修改，指针指向的内容不能修改
2.const修饰常量-指针常量：
数据类型 * const 指针变量 =变量地址
指针指向不能修改，指向的内容可以修改
3.修饰既修指针饰又修饰常量
const 数据类型 * const 指针变量 = 变量地址
指针指向不能修改，指针指向的内容也不能修改
示例 const修饰指针

#include
using namespace std;

int main()
{
	
	int a = 10;
	int b = 20;

	//1.常量指针
	const int * p1 = &a;
	p1 = &b;//正确，常量指针指向的地址可以修改

	//*p1 = 100;//错误，常量指针指向的内容不能修改
	
	//2.指针常量
	int * const p2 = &a;
	//p2 = &b;//错误，指针常量指向的地址不能修改

	*p2 = 100;//正确，指针常量指向的内同可以修改

	//3.const既修饰常量又修饰指针

	const int * const p3 = &a;

	/*错误,该指针指向与指向的内容均不可修改
	p3 = &b;
	*p3 = 100;*/


	system("pause");

	return 0;
}

7.6指针和数组

作用：利用指针访问数组中的元素
示例 指针和数组

#include
using namespace std;

int main()
{
	int arr[6] = { 1,2,3,4,5,6 };
	//指向
	int* p = arr;//arr为数组首地址
	for (int i = 0; i < 6; i++)
	{
		cout << *p << endl;
		p++;
	}
	


	system("pause");

	return 0;
}

7.7指针和函数

作用：利用指针做函数参数，可以修改实参的值
** 示例 指针和函数**

#include
using namespace std;

//1.创建函数swap用指针作形参
void  swap(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
int main()
{
	int a = 10;
	int b = 20;
	cout << "传递前 a = " << a << endl;
	cout << "传递前 b = " << b << endl;

	//2.用指针向函数传递参数
	swap(&a, &b);//传递变量的地址
	cout << "传递后 a = "<

7.8指针、数组、函数

案例描述：封装一个函数，利用冒泡排序实现对数组的升序排列
示例 指针、数组、函数

#include
using namespace std;

//2.创建冒泡排序函数用于排序
void bubble(int * arr, int len)
{
	for (int i = 0; i < len - 1; i++)//i为循环轮数
	{
		for (int j = 0; j < len - i - 1; j++)//排序次数=元素个数-当前循环轮数-1
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

//3.创建打印函数
void print(int * arr,int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << endl;
	}
}

int main()
{
	//1.创建数组
	int arr[] = { 2,5,8,6,7,4,9,0,3,1 };
	int len = sizeof(arr) / sizeof(arr[0]);//计算数组元素个数
	
	bubble(arr, len);//调用冒泡排序函数进行排序

	print(arr,len);//调用打印函数打印排序后的数组


	system("pause");

	return 0;
}

8结构体

8.1结构体基本概念

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

8.2结构体定义和使用

结构体定义语法：

#include
using namespace std;

struct 结构体名 
{
	数据类型 成员1；
	数据类型 成员2；
	数据类型 成员3；
	...
};

int main()
{
	system ("pause");
	return 0;
}

结构体变量定义3种语法：

定义变量时struct可以省略

1.
int main()
{
	struct 结构体名 变量名；
	变量名.成员1 = 值1；
	变量名.成员2 = 值2；
	变量名.成员3 = 值3；

	system ("pause");
	return 0;
}	

2.
int main()
{
	struct 结构体名 变量名 = {值1，值2，值3}


	system ("pause");
	return 0;
}	

3.
#include
using namespace std;

struct 结构体名 
{
	数据类型 成员1；
	数据类型 成员2；
	数据类型 成员3；
	...
} 变量名; //定义结构体时顺便定义变量名（不易读）;

int main()
{
	变量名.成员1 = 值1；
	变量名.成员2 = 值2；
	变量名.成员3 = 值3；

	system ("pause");
	return 0;
}

示例 结构体定义及使用

#include
using namespace std;
#include

struct student
{
	string name;
	int age;
	int score;
} s3;//定义结构体时顺便定义变量

int main()
{
	//方法1
	student	s1;
	s1.name = "张三";
	s1.age = 20;
	s1.score = 100;
	cout <<"姓名: "<

8.3结构体数组

定义：将自定义的结构体放入数组中方便维护
语法：

#include
using namespace std;

struct 结构体名 
{
	数据类型 成员1；
	数据类型 成员2；
	数据类型 成员3；
	...
} ; 
int main()
{
	struct 结构体名 数组名[元素个数] = 
{
	{成员1值，成员2值，成员3值，...}，
	{成员1值，成员2值，成员3值，...}，
	...
	{成员1值，成员2值，成员3值，...}
}；

	system ("pause");
	return 0;
}

示例 结构体数组

#include
using namespace std;
#include

//1.定义结构体
struct student
{
	string name;
	int age;
	int score;
};

int main()
{
	//2.定义结构体数组变量
	student arr[3] = 
	{ 
		{"张三",18,100},
		{"李四",20,30},
		{"王五",25,60}
	};

	//3.访问结构体数组
	for (int i = 0; i < 3; i++)
	{
		cout << "姓名： "<

8.4结构体指针

作用：通过指针访问结构体中的成员
利用操作符 -> 可以通过结构体指针访问结构体属性
示例 结构体指针

#include
using namespace std;
#include

//1.定义结构体
struct student
{
	string name;
	int age;
	int score;
};

int main()
{
	//1.定义结构体变量
	student s = { "张三",18,100 };

	//2.定义指针p指向结构体变量s
	student * p = &s;//指针数据类型要与结构体变量数据类型相同

	//3.通过指针访问结构体变量数据
	
	cout << "姓名： " << p->name << "年龄： " << p->age << "分数： " << p->score << endl;//指针使用->操作符调用结构体变量

	system("pause");
	return 0;
}

8.5结构体嵌套

结构体中的成员可以是另一个结构体
案例 结构体嵌套

#include
using namespace std;
#include

//1.定义结构体student
struct student
{
	string name;
	int age;
	int score;
};

//2.在另一结构体teacher中嵌套结构体student
struct teacher
{
	int id;
	string name;
	int age;
	struct student stu;//嵌套结构体student并定义变量名stu
};

int main()
{
	teacher t;
	t.id = 1;
	t.name = "老王";
	t.age = 55;
	t.stu.name = "张三";
	t.stu.age = 18;
	t.stu.score = 100;

	cout <<"教师编号为：" <

8.6结构体做函数参数

作用：将结构体作为参数向函数中传递
传递方式有：
1.值传递
2.地址传递
示例 结构体做函数参数

#include
using namespace std;
#include

//1.创建结构体student
struct student
{
	string name;
	int age;
	int score;
};

//3.值传递，函数coutstu输出结构体stu
void coutstu1(struct student stu)
{
	stu.age = 999;
	cout << "子函数-值传递\n函数学生姓名：" << stu.name<< "学生年龄：" << stu.age << "学生成绩：" << stu.score << endl;
}
//4.地址传递，函数coutstu输出结构体stu
//void coutstu2(struct student * stu)
//{
//	stu->age = 999;
//	cout << "子函数-地址传递\n函数学生姓名：" << stu->name<< "学生年龄：" << stu->age << "学生成绩：" << stu->score << endl;
//}

int main()
{
	//2.定义结构体变量
	struct student stu;
	stu.name = "张三";
	stu.age	= 18;
	stu.score = 100;


	coutstu1(stu);//值传递stu
	//coutstu2(&stu);//地址传递

	cout << "主函数\n函数学生姓名：" << stu.name << "学生年龄：" << stu.age << "学生成绩：" << stu.score << endl;

	system("pause");
	return 0;
}

8.7结构体中const使用

作用：用const防止误操作
示例 结构体中使用const

#include
using namespace std;
#include

//1.顶级结构体student
struct student
{
	string name;
	int age;
	int score;
};
//3.定义函数print输出结构体
void print( struct student  * const s)//const修饰指针*s，常量指针指向的值不可修改防止误操作
{
	//s->age = 100;
	cout <<"姓名：" <name<<"年龄" << s->age<<"分数" << s->score << endl;

} ;
int main()
{
	//2.定义结构体变量
	struct student	s;
	s.name = "张三";
	s.age = 18;
	s.score = 100;


	print(&s);
	
	cout << "主循环\n姓名：" << s.name << "年龄" << s.age << "分数" << s.score << endl;

	
	system("pause");
	return 0;
}

示例 结构体案例1
案例说明：3名老师分别带5名学生，使用现有知识输出老师姓名、学生信息（学生姓名、年龄、分数）

#include
using namespace std;
#include
#include

//1.定义student teacher结构体
struct student
{
	string sname;
	int score;
};
struct teacher
{
	string tname;
	struct student stu[5];
};
//2.创建函数allocate使用for循环向teacher结构体数组中传递变量
void allocate(struct teacher t[], int len)
{	
	string sname1 = "学生_";
	string tname1 = "教师_";
	string name = "ABCDEF";

	//外层循环输出教师姓名及对应学生信息
	for (int i = 0; i < len; i++)
	{
		t[i].tname =tname1+name[i];//向第i个tname传递name的第i个元素
		
		//内层循环输出学生信息
		for (int j = 0; j < 5; j++)
		{
			t[i].stu[j].sname =sname1+name[j];//第i名教师对应的第j名学生信息
						
			t[i].stu[j].score = rand() % 61 + 40;//随机生成0-60的整数并+40，即0-100的整数

		}

		
	}
}
//3.创建print函数输出teacher结构体数组变量
void print(struct teacher t[],int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << t[i].tname << endl;
		for (int j = 0; j < 5; j++)
		{
			cout <<"\t学生姓名： "<

示例 结构体案例2

#include
using namespace std;
#include

//1.创建英雄结构体
struct hero 
{
	string name;
	int age;
	string sex;
};
//3.冒泡排序函数按年龄排列英雄
void bubblesort(struct hero h[], int len)
{
	for (int i = 0; i < len - 1;i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			if (h[j].age > h[j + 1].age)//按年龄大小排列英雄顺序
			{
				struct hero temp = h[j];
				h[j] = h[j + 1];
				h[j + 1] = temp;

			}
		}
	}

};
void print(struct hero h[],int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "姓名： " << h[i].name << " 年龄： " << h[i].age << " 性别： " << h[i].sex << endl;
	}
};
int main()
{
	//2.创建英雄结构体数组变量
	struct  hero h[] =
	{
		{"刘备",25,"男"},
		{"关羽",24,"男"},
		{"张飞",23,"男"},
		{"赵云",28,"男"},
		{"貂蝉",18,"女"},
	};
	int len = sizeof(h) / sizeof(h[0]);

	bubblesort (h, len);
	print(h, len);

	
	//4.输出结果
	system("pause");
	return 0;
}