学习笔记：黑马程序员C++从0到1（5~6）

黑马程序员C++从0到1入门编程

• 5 数组
• • 5.1 概述
  • 5.2 一维数组
  • • 5.1.1 一维数组定义方式
    • 5.1.2 一维数组-数组名
    • • 5.1.2.1 一维数组案例-五只小猪称体重
      • 5.1.2.2 一维数组案例-元素逆置
    • 5.1.3 冒泡排序
  • 5.2 二维数组
  • • 5.2.1 二维数组定义方式
    • 5.2.2 二维数组-数组名
    • 5.2.2 二维数组案例-考试成绩统计
• 6 函数
• • 6.1 概述
  • 6.2 函数的定义
  • 6.3 函数的调用
  • 6.4 值传递
  • 6.5 函数的常见样式
  • 6.6 函数的声明
  • 6.7 函数的分文件编写

黑马程序员从0到1——数组
黑马程序员从0到1——函数

5 数组 5.1 概述

所谓数组，就是一个集合，里面存放了相同类型的数据元素

• 特点1： 数组中的每个数据元素都是相同的数据类型
• 特点2： 数组是由连续的内存位置组成的

5.2 一维数组 5.1.1 一维数组定义方式

一维数组定义的三种方式：

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

示例：

#include
using namespace std;

int main()
{
	//数组

	

	//1.数据类型 数组名[数组长度];
	int arr[5];
	//给数组中的元素进行赋值
	//数组元素的下标是从0开始索引的
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
    arr[3] = 40; 
	arr[4] = 50;
	//访问数据元素
	cout << arr[0] << endl;
	cout << arr[1] << endl;
	cout << arr[2] << endl;
	cout << arr[3] << endl;
	cout << arr[4] << endl;

	//2.数据类型 数组名[数组长度] = { 值1，值2，... };
	//如果在初始化数据的时候，没有全部填写完，会用0来填补剩余数据
	int arr2[5] = { 10, 20, 30, 40, 50 };
	cout << arr2[0] << endl;
	cout << arr2[1] << endl;
	cout << arr2[2] << endl;
	cout << arr2[3] << endl;
	cout << arr2[4] << endl;
	//利用循环输出数组中的元素
	for (int i = 0; i < 5; i++)
	{
		cout << arr2[i] << endl;
	}
	//3.数据类型 数组名[] = { 值1，值2，... };
	//定义数组的时候必须有初始长度
	int arr3[] = { 90,80,70,60,50,40,30,20,10 };
	for (int i = 0; i < 9; i++)
	{
		cout << arr3[i] << endl;
	}

	system("pause");

	return 0;
}

总结1：数组名的命名规范与变量名命名规范一致，不要和变量重名

总结2：数组中下标是从0开始索引

5.1.2 一维数组-数组名

一维数组名称的用途：

1. 可以统计整个数组在内存中的长度
2. 可以获取数组在内存中的首地址

示例：

#include
using namespace std;

int main() {

	//数组名用途
	//1、可以获取整个数组占用内存空间大小
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
	cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
	cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl;

	cout << "n" << endl;

	//2、可以通过数组名获取到数组首地址
	cout << "数组首地址为： " << arr << endl;//16进制显示
	cout << "数组首地址为： " << (int)arr << endl;//十进制
	cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl;
	cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl;//元素之间相差4字节

	//数组名是常量，因此不可以赋值
	//arr = 100; 

	system("pause");

	return 0;
}

总结1：直接打印数组名，可以查看数组所占内存的首地址

总结2：对数组名进行sizeof，可以获取整个数组占内存空间的大小

5.1.2.1 一维数组案例-五只小猪称体重

案例描述：
在一个数组中记录了五只小猪的体重，如：int arr[5] = {300,350,200,400,250};
找出并打印最重的小猪体重
分析——访问数组中每个元素，如果这个元素比我认定的最大值还要大，更新最大值
示例：

#include 
using namespace std;


int main() {

	//1.创建5只小猪的体重数组
	int arr[5] = { 300,350,200,400,250 };

	//2.从数组中找到最大值
	int max = 0;//先认定一个最大值为0
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;
		//如果访问的数组中的元素比我们认定的最大值还要大，更新最大值
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}

	//3.打印最大值
	cout << "最重的小猪体重为：" << max << endl;

	system("pause");

	return 0;
}

5.1.2.2 一维数组案例-元素逆置

案例描述： 请声明一个5个元素的数组，并且将元素逆置.
(如原数组元素为：1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);

示例 :

#include
using namespace std;

int main()
{
	//实现数组元素逆置

	//1.创建一个数组
	int arr[5] = { 1,3,2,5,4 };
	cout << "数组元素逆置前：" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;
	}

	//2.实现逆置
	//2.1记录起始下标的位置
	//2.2记录结束下标的位置
	//2.3起始下标与结束下标的元素互换
	//2.4起始位置++  ；结束位置--
	//2.5循环执行2.1操作，直到起始位置>=结束位置
	int start = 0;//起始下表，先给 数组排序
	int end = sizeof(arr) / sizeof(arr[0]) - 1;//结束下标

	while (start < end)
	{
		//实现元素互唤
		int temp = arr[start];
	    arr[start] = arr[end];
	    arr[end] = temp;

	    //下标更新
	    start++;
	    end--;

	}
	//3.打印逆置后的数组
	cout << "数组元素逆置后" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;

	system("pause");

	return 0;
}

5.1.3 冒泡排序

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

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
3. 重复以上的步骤，每次比较次数-1，直到不需要比较

将数组 { 4,2,8,0,5,7,1,3,9 } 进行升序排序

排序轮数										对比次数
	4	2	8	0	5	7	1	3	9
0	2	4	0	5	7	1	3	8	9	8
1	2	0	4	5	1	3	7	8		7
2	0	2	4	1	3	5	7			6
3	0	2	1	3	4	5				5
4	0	1	2	3	4					4
5	0	1	2	3						3
6	0	1	2							2
7	0	1								1

排序的轮数 = 元素的个数 - 1
每轮对比次数 = 元素个数 - 排序轮数

示例：

#include 
using namespace std;

int main() {

	int arr[9] = { 4,2,8,0,5,7,1,3,9 };

	//利用打印排序前的数字
	cout << "排序前" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << "  ";
	}
	cout << endl;


	//开始冒泡排序
	//总共排序轮次 = 元素个数 - 1
	for (int i = 0; i < 9 - 1; i++)
	{
		//内层循环对比，次数 = 元素个数 - 当前轮次 - 1
		for (int j = 0; j < 9 - 1 - i; j++)
		{
			//如果第一个数字比第二个数字大，交换两个数字
			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] << "  ";
	}
	cout << endl;

	system("pause");

	return 0;
}

5.2 二维数组

二维数组就是在一维数组上，多加一个维度

5.2.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 arr[2][3];
	arr[0][0] = 1;
	arr[0][1] = 2;
	arr[0][2] = 3;
	arr[1][0] = 4;
	arr[1][1] = 5;
	arr[1][2] = 6;

	cout << arr[0][0] << endl;
	cout << arr[0][1] << endl;
	cout << arr[0][2] << endl;
	cout << arr[1][0] << endl;
	cout << arr[1][1] << endl;
	cout << arr[1][2] << endl;

	//外层循坏打印行数，内层循坏打印列数
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << 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 << arr2[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 << arr2[i][j] << " ";
		}
		cout << endl;
	}

	system("pause");

	return 0;
}

总结：在定义二维数组时，如果初始化了数据，可以省略行数

5.2.2 二维数组-数组名

• 查看二维数组所占内存空间
• 获取二维数组首地址

示例：

#include
using namespace std;

int main()
{
	//二维数组名称用途

	//1.可以查看占用内存大小
	int arr[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};
	cout << "二维数组所占内存空间为：" << sizeof(arr) << endl;
	cout << "二维数组第一行占用内存空间为：" << sizeof(arr[0]) << endl;
	cout << "二维数组第一个元素占用内存为：" << sizeof(arr[0][0]) << endl;

	cout << "二维数组的行数为：" << sizeof(arr) / sizeof(arr[0]) << endl;
	cout << "二维数组的列数为：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
	
	//2.可以查看二维数组的首地址
	cout << "二维数组首地址：" << (int)arr << endl;
	cout << "二维数组第一行地址：" << (int)arr[0] << endl;
	cout << "二维数组第二行地址：" << (int)arr[1] << endl;

	cout << "二维数组第一个元素地址：" << (int)&arr[0][0] << endl;//&取址符
	cout << "二维数组第二个元素地址：" << (int)&arr[0][1] << endl;
	
	system("pause");

	return 0;
}

总结1：二维数组名就是这个数组的首地址

总结2：对二维数组名进行sizeof时，可以获取整个二维数组占用的内存空间大小

5.2.2 二维数组案例-考试成绩统计

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

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

示例：

#include 
using namespace std;

int main() {

	//二维数组案例-考试成绩统计

	//1.创建二维数组
	int scores[3][3] =
	{
		{100,100,100},
		{90,50,100},
		{60,70,80}
	};

	string names[3] = { "张三","李四","王五" };

	//2.统计每个人的总和分数
	for (int i = 0; i < 3; i++)
	{
		int sum = 0;//统计分数总和变量
		for (int j = 0; j < 3; j++)//列
		{
			sum += scores[i][j];
			//cout << scores[i][j] << " ";
		}
		//cout << "第" << i + 1 << "个人的总分为：" << sum << endl;
		cout < 
6 函数 
6.1 概述 
**作用：**将一段经常使用的代码封装起来，减少重复代码
 一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。
 
6.2 函数的定义 
函数的定义一般主要有5个步骤：
 1、返回值类型
 2、函数名
 3、参数表列
 4、函数体语句
 5、return 表达式
 语法：
 
返回值类型  函数名 （参数列表）
{
       函数体语句

       return表达式
}

 
返回值类型 ：一个函数可以返回一个值。在函数定义中
函数名：给函数起个名称
参数列表：使用该函数时，传入的数据
函数体语句：花括号内的代码，函数内需要执行的语句
return表达式： 和返回值类型挂钩，函数执行完后，返回相应的数据
 
示例：
 定义一个加法函数，实现两个数相加
 
#include
using namespace std;



 //加法函数，实现两个整形相加，并且将相加的结果进行返回
int add(int num1, int num2)
{
	int sum = num1 + num2;
	return sum;
}
 
6.3 函数的调用 
功能： 使用定义好的函数
 
语法： 函数名（参数）
 
示例：
 
#include
using namespace std;

//定义加法函数
//函数定义的时候，num1和num2并没有真实的数据
//它只是一个形式上的参数，简称形参
int add(int num1, int num2)
{
	int sum = num1 + num2;
	return sum;
}

int main()
{
	//main函数中调用add函数
	int a = 10;
	int b = 20;

	//函数调用语法：函数名称（参数）
	//a和b称为实际参数，简称实参
	//当调用函数时候，实参的值会传递给形参
	int c = add(a, b);

	cout << "c=" << c << endl;

	a = 100;
	b = 500;

	c = add(a, b);
	
	cout << "c=" << c << endl;

	system("pause");
	
	return 0;
}
 
 
 
总结：函数定义里小括号内称为形参，函数调用时传入的参数称为实参
 
 
6.4 值传递 
所谓值传递，就是函数调用时实参将数值传入给形参
值传递时，如果形参发生，并不会影响实参
 
示例：
 
#include
using namespace std;

//值传递
//定义函数，实现两个数字进行交换函数

//如果函数不需要返回值，声明的时候可以写void
void swap(int num1, int num2)
{
	cout << "交换前：" << endl;
	cout << "num1=" << num1 << endl;
	cout << "num2 =" << num2 << endl;
	cout << endl;

	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换后：" << endl;
	cout << "num1=" << num1 << endl;
	cout << "num2 =" << num2 << endl;

	//return;返回值不需要的时候，可以不写return
}

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 函数的常见样式 
常见的函数样式有4种
 
无参无返
有参无返
无参有返
有参有返
 
示例：
 
#include
using namespace std;

//函数常见样式
//1、 无参无返
void test01()
{
	//void a = 10; //无类型不可以创建变量,原因无法分配内存
	cout << "this is test01" << endl;
	//test01(); 函数调用
}

//2、 有参无返
void test02(int a)
{
	cout << "this is test02 a =" << a << endl;
}

//3、无参有返
int test03()
{
	cout << "this is test03 " << endl;
	return 1000;
}

//4、有参有返
int test04(int a)
{
	cout << "this is test04 a = " << endl;

	return a;
}

int main()
{
	//无参无返函数调用
	test01();

	//有参无返函数调用
	test02(100);
	
	//无参有返函数调用
	int num1 = test03();
	cout << "num1 = " << num1 << endl;


	//有参有返函数调用
	int num2 = test04(10000);
	cout << "num2 = " << num2 << endl;

	system("pause");

    return 0;
}

 
6.6 函数的声明 
作用： 告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
 
函数的声明可以多次，但是函数的定义只能有一次
 
示例：
 
#include
using namespace std;

//函数的声明
//比较函数，实现两个整形数字进行比较，返回较大的值

//若要把main函数提前：应提前告诉编译器函数的存在，可以利用函数的声明

//声明可以写多次，但是定义只能写一次

//函数的声明
int max(int a, int b);
int max(int a, int b);

//定义
int max(int a, int b)
{
	return a > b ? a : b;
}

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

	cout << max(a, b) << endl;

	system("pause");

	return 0;
}
 
6.7 函数的分文件编写 
作用： 让代码结构更加清晰
 
函数分文件编写一般有4个步骤：
 
创建后缀名为.h的头文件
创建后缀名为.cpp的源文件
在头文件中写函数的声明
在源文件中写函数的定义
 
示例：
 
头文件_声明
 
#include
using namespace std;

//函数得声明
void swap(int a, int b);
 
源文件_函数定义
 
#include"swap.h"

//函数的定义
void swap(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
	cout << "a =" << a << endl;
	cout << "b =" << b << endl;
}
 
主函数_调用
 
#include
using namespace std;
#include"swap.h"

//函数的分文件编写
//实现两个数字进行交换的函数

//函数得声明
//void swap(int a, int b);

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

//1. 创建后缀名为.h的头文件
//2. 创建后缀名为.cpp的源文件
//3. 在头文件中写函数的声明
//4. 在源文件中写函数的定义

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

	swap(a, b);

	system("pause");

	return 0;
}