1.数组

//数组：就是集合，里面存放了相同类型的数据元素
//数组中的每个数据元素都是相同的数据类型
//数组是由连续的内存位置组成的

1.1一维数组

//一维数组定义的三种方式
//1.数据类型 数组名[数组长度]；
//2.数据类型 数组名[数组长度]={值1，值2…}
//3.数据类型 数组名[]={值1，值2，…} 定义数组时，必须确定初始长度

//数组名的用途
//1.可以统计整个数组在内存中的长度 sizeof(arr) sizeof测出的单位是字节
//2.可以获取数组在内存中的首地址 元素的首地址位arr 第一个元素的地址是&arr[0]
//两个位置重合 挨着的元素的地址之间都差4个字节

//冒泡排序
//最常用的排序算法，对数组内的元素进行排序
//1.比较相邻的元素，如果第一个比第二个大，就交换他们
//2.对每一对相邻元素左右同样的工作，执行完毕后，找到第一个最大值
//3.重复以上步骤，每次比较次数-1，直到不需要比较
//将数组{4，2，8，0，17，7，1，3，15}进行升序排序
#include<iostream>
using namespace std;
int main()
{
	int arr[9] = { 4,2,8,0,17,7,1,3,15 };
	//外层循环次数 = 元素个数-1
	for (int i = 0; i < 9 - 1; i++)
	{
		//内层循环个数 = 元素个数 - 当前轮数 - 1
		for (int j = 0; j < 9-i-1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i]<<",";
	}
	cout << endl;
	system("pause");
	return 0;
}

1.2二维数组

//二维数组：就是在一维数组之上，增加一个维度
//1.数据类型 数组名[行数][列数];
//2.数据类型 数组名[行数][列数] = {{数据1，数据2}，{数据3，数据4}};
//3.数据类型 数组名[行数][列数] = {数据1，数据2，数据3，数据4};
//4.数据类型 数组名[][列数] = {数据1，数据2，数据3，数据4}; 可以通过列数确定行数

//二维数组数组名
//查看二维数组所占内存空间 sizeof(arr)
//获取二维数组首地址
//二维数组行数sizeof(arr)/sizeof(arr[0])
//二维数组列数sizeof(arr[0])/sizeof(arr[0][0])

2.函数

//函数：将一段经常使用的代码封装起来，减少重复代码
// 一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能
// 函数的定义
// 1.返回值类型 2.函数名 3.参数列表 4.函数体语句 5.return表达式

int add(int num1, int num2)//num1和num2只是形参，不是实数
{
	int sum = num1 + num2;
	return sum;
}

函数的调用：使用定义好的函数

函数值传递：函数调用时实参将数值传入形参（值传递时，如果形参发生，不会改变实参）

函数常见样式
//1.无参无返 2.无参有返 3.有参无返 4.有参有返
无返void 有返（类型）

函数的声明（声明可以有多次，但是定义只能有一次）
//在函数调用之前告诉编译器函数名称及如何调用函数，函数的实际主体可以单独定义

函数的分文件编写
//让代码结构更加清晰
//1.创建后缀名为.h的头文件 2.创建后缀名为.cpp的源文件 3.在头文件中写函数的声明
//4.在源文件中写函数的定义 都要写上include"自己所编写的头文件的名称"

3.指针：可以通过指针间接访问内存(指针记录地址）

3.1 指针的定义和使用

//定义指针的语法 数据类型 *指针变量名 int *p;
//让指针记录变量a的地址 p = &a;
//指针前 *代表解引用 *p代表所指地址的内容

3.2 指针所占用空间

//在32位操作系统下，指针是占4个字节空间大小，无论什么数据类型
//在64位操作系统下，指针是占8个字节空间大小，无论什么数据类型

3.3 空指针和野指针

//空指针：指针变量指向内存中编号为0的空间 用来初始化指针变量
// 注意：空指针指向的内存是不可以被访问的
//0~255之间的空间是系统占用的，因此不能被访问
int* p = nullptr;

//野指针：指针指向非法的内存空间

空指针和野指针都不是我们申请的空间，因此不要访问

3.4 const修饰指针

int a = 10;
int b = 10;
const int* p = &a;
常量指针：指针的指向可以改，但是指针指向的值不可以改
int* const p = &a;
指针常量：指针的指向不可以改，但是指针指向的值可以改

3.5指针和数组

指针和数组：利用指针访问数组中的元素arr就是数组首地址

3.6指针和函数

利用指针作为函数参数，可以修改实参的值

//实现两个数字进行交换
//值传递
void swap01(int num1, int num2)
{
	int temp = num1;
	num1 = num2;
	num2 = temp;
	cout << "a = " << num1 << endl;
	cout << "b = " << num2 << endl;
}
//地址传递
void swap02(int *p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
	cout << "a = " << *p1 << endl;
	cout << "b = " << *p2 << endl;
}
int main()
{
	int a = 10;
	int b = 20;
	swap01(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	swap02(&a, &b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	system("pause");
	return 0;
}

运行结果：

3.7练习（指针、数组、函数）

//指针、数组、函数
//封装一个函数，利用冒泡排序，实现对整体数组的升序排序
//例如：数组int arr[10] = {4,3,6,9,1,2,10,8,7,5}
#include<iostream>
using namespace std;
//冒泡排序函数 参数1 数组首地址  参数2 数组长度
void bubblesort(int arr[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}

}
void printfArray(int* arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i]<<" ";
	}
	cout << endl;
}
int main()
{
	//1.先创建数组
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	//2.创建函数，实现冒泡排序
	int len = sizeof(arr) / sizeof(arr[0]);
	bubblesort(arr, len);
	//3.打印排序后的数组
	printfArray(arr, len);
	system("pause");
	return 0;
}