（1）数组（一维、二维）、函数（调用、声明、值传递）

数组

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

特点：

数组中每个数据元素都是相同的数据类型

数组是由连续的内存位置组成的

一维数组

定义的三种方式：

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

注：数组下标从0开始索引的，可通过下标访问数组中元素，下标0对应第一个元素。

       定义数组时，必须有初始长度

       数组名命名规范与变量名命名规范一致，不要和变量重名

int arr[5];//定义
arr[0] = 1;//赋值，第一个元素为1
cout << arr[0] << endl;//访问元素

int arr2[5] = {1,2,3};//定义
for(int i = 0; i < 5; i++)//利用循环输出元素
{
   cout << arr2[i] << endl;//输出时第四、五个元素为0，因为在初始化时没有全部填写完，会用0来填充剩余数据
}

int arr3[] = {1,2,3,4,5,6,7,8,9};//填充数据后系统会自己推测数组长度。定义数组时，必须有初始长度
for(int i = 0; i < 9; i++) 
{
   cout << arr3[i] << endl; //输出数组
}

一维数组名称的用途：

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

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 << "数组首地址为：" << (int)arr << endl;//一般会输出16进制，加(int)将16进制输出时强转为10进制
cout << "数组中第一个元素地址为：" << (int)&arr[0] << endl;// & 为取址符号，获取具体元素的首地址。与首地址重合
cout << "数组中第二个元素地址为：" << (int)&arr[1] << endl;

案例1：5只小猪称体重，在数组中找到最大值

一个数组中记录了五只小猪的体重，找出并打印最重的小猪体重。

int arr[5] = {300,350,200,400,250};//创建5只小猪体重数组
int max = 0;//认定最大值为0
for (int i = 0; i < 5; i++)
{
   if(arr[i] > max)//如果访问的数组中的元素比我认定的最大值还要大，更新最大值
   {
       max = arr[i];
   }
}
cout << "最重的小猪体重：" << max << endl;

案例2：数组元素逆置

int arr[5] = {1,3,2,5,4};
cout << "逆置前：" << endl;
for(int i = 0; i < 5; i++)
{
   cout << arr[i] << endl;
}
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--;
}
cout << "逆置后：" << endl;
for(int i = 0; i < 5; i++)
{
   cout << arr[i] << endl;
}

冒泡排序

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

比较相邻的元素。如果第一个比第二个大，就交换两个元素的位置；

对每一对相邻的元素做同样的工作，执行完毕后，找到一个最大值；

重复以上步骤，每次比较次数-1，直到不需要比较。

例：将数组{4,2,8,0,5,7,1,3,9}

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;
for(int i = 0; i < 9 - 1; i++)//总共排序轮数 = 元素个数 - 1
{
   for(int j = 0; j < 9 - i - 1; j++)//内层循环对比次数 = 元素个数 - 当前轮数 - 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] << " ";
}
cout << endl;

二维数组

四种定义方式：

• 数据类型  数组名[ 行数 ][ 列数 ];
• 数据类型  数组名[ 行数 ][ 列数 ] = { {数据1，数据2} , {数据3，数据4} };
• 数据类型  数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4 };
• 数据类型  数组名[         ][ 列数 ] = { 数据1，数据2，数据3，数据4 };

建议：第二种更加直观，提高代码可读性

打印：嵌套循环输出

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

案例：考试成绩统计

张三、李四、王五的语文、数学、英语成绩分别为：100,100,100；90,50,100；60,70,80。

#include<iostream>
using namespace std;
#include<string>
int scores[3][3] = { {100,100,100},{90,50,100},{60,70,80} };
string names[3] = { "张三","李四","王五"};
for(int i = 0; i < 3; i++)
{
   int sum = 0;
   for(int j = 0; j < 3; j++)
   {
      sum += scores[i][j];
   }
   cout << names[i] << "的总分为：" << sum << endl;
}

函数

将一段经常使用的代码封装起来，减少重复代码。

定义：

1.返回值类型：一个函数可以返回一个值

2.函数名：函数名称

3.参数列表：使用函数时传入的数据

4.函数体语句：花括号内的代码，函数内需要执行的语句

5.return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

语法：

返回值类型 函数名 (参数列表)
{
   函数体语句
   return表达式
}
int add(int num1, int num2)//例：两整型之和函数
{
   int sum = num1 + num2;
   return sum;
}

函数的调用

语法：函数名(参数)

//例：两整型之和函数
int add(int num1, int num2)//num1和num2并没有真实数据，只是一个形式上的参数，简称形参
{
   int sum = num1 + num2;
   return sum;
}
int main(){
   int a = 10;
   int b = 20;
   int c = add(a, b);// a 和 b 称为实际参数，简称实参。当调用函数时，实参的值会传递给形参
   cout << "c = " << c << endl;
   return 0;
}

值传递

如果函数不需要返回值，声明时可以写void

void swap(int num1, num2)
{
   cout << "交换前：" << endl;
   cout << "num1 = " << num1 << endl;
   cout << "num2 = " << num1 << endl;
   int temp = num1;
   num1 = num2;
   num2 = temp;
   cout << "交换后：" << endl;
   cout << "num1 = " << num1 << endl;
   cout << "num2 = " << num1 << endl;
}
int main(){
   int a = 10;
   int b = 20;
   swap(a, b);//当值传递时，函数形参发生变化，并不会影响实参
}

函数的常见样式：无参无返、有参无返、无参有返、有参有返

void test01()//无参无返
{
   cout << "this is test01 " << endl;
}
void test02(int a)//有参无返
{
   cout << "this is test02 a =  " << a << endl;
}
int test03()//无参有返
{
   cout << "this is test03 " << endl;
   return 1000;
}
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;
}

函数的声明

告诉编译器函数名称以及如何调用函数。函数的实际主体可单独定义。

注：声明可以多次，但定义只能有一次。

返回值类型 函数名 （形参列表）；（不需要写执行程序）

函数的分文件编写

作用：让代码结构更加清晰

函数分文件编写一般有4个步骤：
1.创建后缀名为.h的头文件

2.创建后缀名为.cpp的源文件

3.在头文件中写函数的声明

4.在源文件中写函数的定义