实用指南：Day 04 C++入门之 数组 + 函数

Day 04 C++入门之数组 + 函数

一、数组

1.1 概述

数组，就是一个集合里面存放了相同类型的数据元素。包含两个特点：

• 数组中每个数据元素都是相同的数据类型；
• 数组存放于连续的内存位置。

数组从0开始进行索引，叫下标，可以通过下标访问数组中的元素。比如 a[0]，访问数组a中的第一个元素。

1.2 一维数组

1.2.1 一维数组的定义方式

• 数据类型 数组名[数组长度]；

int A[5];//申明并写出数组中元素个数
A[0] = 7;// 数组下标从0开始索引
A[1] = 6;
A[2] = 5;
A[3] = 3;
A[4] = 1;
cout << A[0] << endl; // 访问第一个数组元素

• **数据类型 数组名[数组长度] = {值1， 值2…}；**若给出的值没有数组长度多，那会自动以 0 补足

int B[5] = {7,9,6,5,1};
for(int i=0;i<5;i++)
{
    cout << B[i] <

• **数据类型 数组名[] = {值1， 值2…}；**直接指定值，会自己找到数组长度是多少

int C[] = {9,7,8,6,2,1};//大括号里面由6个，所以数组长度是6

这种写法，大括号里面一定要有数值，否则报错。

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

1.2.2一维数组的数组名

数组名命名规范与变量名命名规范一样，不要与变量名重名。

数组名用途：

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

// 统计整个数组在内存中的长度
int C[] = {9,7,8,6,2,1};
int a = 0;
a = sizeof(C);
// 一个元素在内存中占多长
int b = 0;
b = sizeof(A[0]);
// 查看首地址
cout << "数组首地址为" << C << endl;
cout << "数组首地址为" << （int）C << endl;// 切换为十进制进行查看
//查看第一个元素的首地址
cout << "第一个元素的首地址" << (int)&C[0] << endl;//注意取地址符号不要忘
cout << "第一个元素的首地址" << (int)&C[0] << endl;
cout << "第二个元素的首地址" << (int)&C[1] << endl;

数组名是常量，不可以进行赋值操作

例子1：

五只小猪称体重，一个数组中记录了五只小猪的体重，如A[5] = {100,200,150,300,350}；找出并打印最重的小猪的体重。

int A[5] = {100,200,150,300,350};
int max = 0;
int b = 0;
for(int i=0;i<5;i++){
    if(A[i] > max)
    {
        max = A[i];
        b = i+1;
    }
}
cout << "第" << b <<"只小猪最重，体重为" << max << endl;

例子2：

数组元素逆置。声明一个5个元素的数组，并且将其逆置，原始元素为12345，逆置后为54321。

int A[5] = { 1,2,3,4,5 };
int n = 0;
n = sizeof(A) / sizeof(A[0]);
cout << "逆置前：" << endl;
for (int i = 0; i < n; i++)
{
    cout << A[i] << endl;
 }
for (int i = 0; i < n/2; i++)
{
    int temp = 0;
    temp = A[i];
    A[i] = A[n - i - 1];
    A[n - i - 1] = temp;
}
cout << "逆置后：" << endl;
for (int i = 0; i < n; i++)
{
    cout << A[i] << endl;
}

应用：冒泡排序

作用：最常用的排序算法，对数组内的元素进行排序。操作步骤（升序）：

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

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

int A[9] = {4,2,8,0,5,7,1,3,9};
for(int i = 0; i<(9-1);i++)
{
    for(int j = 0;j<(9-i-1);j++)
    {
       if(A[j]>A[j+1])
       {
        int temp = 0;
        temp = A[j];
        A[j] = A[j+1];
        A[j+1] = temp;
       }
    }
}

外层循环：排序总轮数 = 元素个数 - 1；

内层循环：每轮对比次数 = 元素个数 - 排序轮数 - 1

1.3 二维数组

1.3.1 二维数组的定义方式：

• 数据类型 数组名 [行数] [列数]；

• 数据类型 数组名 [行数] [列数] = { {数据1，数据2…}，{数据3，数据4…}…}；（推荐使用）

• 数据类型 数组名 [行数] [列数] ={数1，数2，数3…}；

  一行一行的去赋值，一行会被分满才会去下一行，不足补0，若不足会有0行

• 数据类型 数组名 [ ] [列数] = {数1，数2，数3…}；

  一行一行的去划分，直到分为为止，不会有0行，但一行有值但不满时补0

// 数据类型 数组名 [行数] [列数]；
int A[6][7];//定义6行7列的二维数组
// 数据类型 数组名 [行数] [列数] = { {数据1，数据2...}，{数据3，数据4...}...}；
int A[6][7] = {{1,2,3},{4,5,6}};//不足补0
// 数据类型 数组名 [行数] [列数] ={数1，数2，数3...}；
int A[6][7] = {1,2,3,4,5,6};//没有划分，一行一行的去赋值，一行会被分满才会去下一行，不足补0，若不足会有0行
// 数据类型 数组名 [  ] [列数]  = {数1，数2，数3...}；
int A[][7] = {1,2,3,4,5,6};//一行一行的去划分，直到分为为止，不会有0行，但一行有值但不满时补0

行数可以省，但列数不可以省

1.3.2 二维数组的数组名用途

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

//所占内存空间
int A[2][3];
cout << "整个所占空间" << sizeof(A) <

二维数组在内存空间的存储实际上是一个一维数组，一行一行的存一个一个的存

例子3：

考试成绩统计，有三名同学，在一次考试中成绩如下表，请分别输出三名同学的总成绩

名字/成绩	语文	数学	英语
张三	100	100	100
李四	90	50	100
王五	60	70	80

#include //使用字符串必须包含这个头文件
int A[3][3] = {{100,100,100},{90,50,100},{60,70,80}};
string name[3] = {"张三","李四","王五"};
for(int i = 0;i<3;i++){
    int sum = 0;
    for(int j= 0;j<3;j++)
    {
        sum += A[i][j];
    }
    cout << name[i]<<"的成绩总和为" <

二、函数

2.1 概述

作用：将一段经常用的一定功能的代码封装起来，减少重复代码。一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

2.2 函数的定义

函数的定义一般分为5个步骤：

1. 确定返回值类型；
2. 函数名；
3. 参数列表；
4. 函数体语句；
5. return 表达式。

语法：

返回值类型 函数名（参数列表）
{
    函数体语句；
        ...
    return表达式；
}

例子4：

输入两个值，返回最大值

//返回值类型为int，函数名max，参数列表a，b；函数体语句（判断）；return max；
int Max(int a,int b)
{
    int max = 0;
    if(a > b)
    {
        max = a;
    }
    else
    {
        max = b;
    }
    return max;
}

例子5：

输入两个值，输出两个值的和，加法

int Add(int num1,int num2)//定义时，num1,num2没有实际的数据，为形参
{
    int sum = 0;
    sum = num1 + num2;
    return sum;
}

2.3 函数的调用

使用定义好的函数。语法：函数名（参数）

int a =1;
int b =1;
//这里的a，b为实参
int c = Add(a,b);

调用函数的时候，实参的值会传递给形参

2.4 值传递

函数调用时，实参将数值传递给形参。当值传递时，如果形参发生变化（在定义的函数内部发生变化），并不会影响实参

int Add(int num1,int num2)//定义时，num1,num2没有实际的数据，为形参
{
    int sum = 0;
    //这里发生的变化并不影响下面的实参a、b
    num1 = num1*2;
    num2 = num1+num2;
    sum = num1 + num2;
    return sum;
}
int a =1;
int b =1;
//这里的a，b为实参
int c = Add(a,b);

当调用函数时，实际上是将实参的值进行复制，在内存中重新开了两个空间分别赋值，在这两个新开辟的空间进行操作，所以形参的改变不影响原来的实参。

2.5 函数的常见样式

常见样式有4种：

1. 无参无返。不传参数，没有返回值
2. 有参无返。有参数，但没有返回值
3. **无参有返。**没有参数，有返回值
4. 有参有返。有参数，也有返回值

// 1. 无参无返
void test1()
{
    cout << "你好" << endl;
}
// 2. 有参无返
void test2(int a)
{
    cout << "你输入的数是" << a  << endl;
}
// 3. 无参有返
int test3()
{
    cout << "你好" << endl;
    return 100;
}
// 4. 有参有返
int test4(int num1,int num2)//定义时，num1,num2没有实际的数据，为形参
{
    int sum = 0;
    sum = num1 + num2;
    return sum;
}

2.6 函数的声明

作用：告诉编译器函数的名称以及如何调用函数，告诉编译器函数存在（不要报错），函数的实际主体可以单独定义；函数的声明可以多次，但是函数的定义只能有一次。

声明语法：返回值类型 函数名（参数列表）；

正常在编写函数时，函数的定义必须在调用函数之前（否则会报错），但是函数声明之后，函数的定义可以写在函数调用之后。

//函数的声明
int Add(int num1,int num2);
int a =1;
int b =1;
int c = Add(a,b);
int Add(int num1,int num2)
{
    int sum = 0;
    sum = num1 + num2;
    return sum;
}

2.7 函数的分文件编写

作用：让代码结构更加清晰。函数分文件编写一般有4个步骤：

1. 创建后缀名为 .h 的头文件；

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

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

   #include
   using namespace std;
   int Add(int num1,int num2);

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

#include "test.h"
int Add(int num1, int num2)
{
    int sum = 0;
    sum = num1 + num2;
    return sum;
}

5. 调用

//主函数中，主文件中
#include
using namespace std;
#include "test.h"
int main()
{
    int a=1;
    int b = 1;
    Add(a,b);
	system("pause");
	return 0;
}