韵动代码：C++数组实践与应用之路

4.1 一维数组

4.1.1 问题的提出

在许多实际应用中，我们需要同时处理一组数据。比如，在班级管理系统中，我们需要存储和处理每个学生的成绩。这时，一维数组就成为一个非常有用的工具。

【例4-1】处理班级学生成绩假设有一个班级，其中有10个学生，需要记录他们的成绩，并进行一些操作，比如计算平均分，找出最高分等等。

#include 
int main()
{
    const int numOfStudents = 10;
    int scores[numOfStudents];
    int sum = 0;  // 输入学生成绩
    for (int i = 0; i < numOfStudents; i++)
    {
        std::cout << "请输入第 " << i + 1 << " 个学生的成绩：";
        std::cin >> scores[i];
        sum += scores[i];
    }             // 计算平均分
    float average = (float)sum / numOfStudents;
    std::cout << "班级平均分为：" << average;
    return 0;
}

程序运行结果如下

请输入第 1 个学生的成绩：66
请输入第 2 个学生的成绩：77
请输入第 3 个学生的成绩：88
请输入第 4 个学生的成绩：99
请输入第 5 个学生的成绩：55
请输入第 6 个学生的成绩：77
请输入第 7 个学生的成绩：66
请输入第 8 个学生的成绩：88
请输入第 9 个学生的成绩：55
请输入第 10 个学生的成绩：99
班级平均分为：77

4.1.2 一维数组的定义和引用

一维数组是一组连续存储的相同类型的数据。我们可以使用方括号和数组名来定义和引用一维数组中的元素。一维数组的定义方式为：

数据类型 数组名[数组大小];

例如，定义一个整型的一维数组a，包含5个元素的方式为：

int a[5];

一维数组的元素可以通过索引来引用和操作。数组的索引从0开始，最大索引为数组大小减1。例如，引用数组a的第一个元素可以使用a[0]，引用数组的第二个元素可以使用a[1]，以此类推。

【例4-2】一维数组的引用

#include 
int main()
{
    int nums[5] = { 1, 2, 3, 4, 5 };   // 输出数组中的元素
    for (int i = 0; i < 5; i++)
    {
        std::cout << "nums[" << i << "] = " << nums[i] << std::endl;
    }
    return 0;
}

程序运行结果如下

nums[0] = 1
nums[1] = 2
nums[2] = 3
nums[3] = 4
nums[4] = 5

在这个例子中，我们演示了如何引用一维数组的元素。假设有一个包含5个元素的一维数组a，我们可以通过循环遍历数组，并输出每个元素的值。

4.1.3 一维数组的初始化

一维数组可以在定义时进行初始化。可以通过在花括号中提供初始值来初始化数组。

【例4-3】一维数组的初始化

#include 
int main()
{
    int nums[5] = { 1, 2, 3, 4, 5 };
    return 0;
}

在这个部分，通过初始化列表，我们可以直接给数组的每个元素赋初始值。

4.1.4 一维数组应用实例

一维数组在实际应用中有着广泛的应用。以下是两个使用一维数组的实例。

【例4-4】用一维数组处理斐波那契数列，斐波那契数列是一个数列，每个数都是前两个数之和。斐波那契数列是一个经典的数学问题，定义如下：前两个数为1，从第三个数开始，每个数是前两个数之和。在这个例子中，我们将使用一维数组来处理斐波那契数列。

#include 
int main()
{
    const int numOfTerms = 10;
    int fib[numOfTerms]; 
    fib[0] = 0;
    fib[1] = 1;  
    for (int i = 2; i < numOfTerms; i++)
    {
        fib[i] = fib[i-1] + fib[i-2];
    }  // 输出斐波那契数列
    for (int i = 0; i < numOfTerms; i++)
    {
        std::cout << fib[i] << " ";
    } 
    return 0;
}

程序运行结果如下

0 1 1 2 3 5 8 13 21 34

【例4-5】冒泡排序法
冒泡排序法是一种简单的排序算法，通过多次比较和交换来实现。

#include 
void bubbleSort(int arr[], int size)
{
    for (int i = 0; i < size - 1; i++)
    {
        for (int j = 0; j < size - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main()
{
    const int size = 5;
    int nums[size] = { 5, 3, 1, 2, 4 };
    bubbleSort(nums, size);   // 输出排序结果
    for (int i = 0; i < size; i++)
    {
        std::cout << nums[i] << " ";
    }
    return 0;
}

程序运行结果如下

1 2 3 4 5

冒泡排序法是一种简单直观的排序算法。它重复地遍历要排序的数组，一次比较两个元素，并按照大小交换它们的位置，直到整个数组排序完毕。在这个例子中，我们使用一维数组和冒泡排序法来对数组进行排序。

4.2 二维数组

二维数组是一种特殊的数组，它可以理解为元素为一维数组的数组。在C++中，通过使用两个方括号表示，如array[row][column]，来访问和操作二维数组的元素。

4.2.1 问题的提出

在实际的编程中，我们经常需要处理类似于班级多门成绩的问题，即需要同时处理多个学生和多门课程的成绩。二维数组提供了一种灵活的方式来存储和处理这些数据。

【例4-6】处理班级多门成绩
假设一个班级有n个学生，m门课程，需要统计每个学生的总分和平均分，并输出。

#include 
using namespace std;

int main() 
{
    const int n = 3; // 假设班级有3个学生
    const int m = 4; // 假设有4门课程
    int scores[n][m]; // 定义一个二维数组保存学生的成绩
    // 输入学生的成绩
    for (int i = 0; i < n; i++) 
    {
        cout << "请输入第" << i + 1 << "个学生的成绩：" << endl;
        for (int j = 0; j < m; j++) 
        {
            cin >> scores[i][j];
        }
    }
    // 计算每个学生的总分和平均分，并输出
    for (int i = 0; i < n; i++) 
    {
        int sum = 0;
        for (int j = 0; j < m; j++) 
        {
            sum += scores[i][j];
        }
        double average = sum / (double)m;
        cout << "第" << i + 1 << "个学生的总分为：" << sum << endl;
        cout << "第" << i + 1 << "个学生的平均分为：" << average <<endl;
    }
    return 0;
}

程序运行结果如下

请输入第1个学生的成绩：
66
66
66
66
请输入第2个学生的成绩：
89
89
89
89
请输入第3个学生的成绩：
75
75
75
75
第1个学生的总分为：264
第1个学生的平均分为：66
第2个学生的总分为：356
第2个学生的平均分为：89
第3个学生的总分为：75
第3个学生的平均分为：300

在上面的例子中，我们定义了一个3行4列的二维数组scores，其中行表示学生，列表示课程。我们使用两个嵌套的循环来输入学生的成绩，并使用另外两个嵌套的循环来计算每个学生的总分和平均分，并输出结果。

4.2.2 二维数组的定义与引用

二维数组是一种特殊的数组，可以看做是元素为一维数组的数组。在C++中，可以通过两种方式定义二维数组。

【例4-7】二维数组的引用
使用数组名加上下标的方式引用二维数组中的元素。

#include 
using namespace std;
int main() 
{
    const int N = 3;
    const int M = 4;
    int array[N][M];
    // 初始化数组
    for (int i = 0; i < N; i++) 
    {
        for (int j = 0; j < M; j++) 
        {
            array[i][j] = i * M + j;
        }
    }
    // 输出数组元素
    for (int i = 0; i < N; i++) 
    {
        for (int j = 0; j < M; j++) 
        {
            cout << array[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

程序运行结果如下

0 1 2 3
4 5 6 7
8 9 10 11

在上面的例子中，我们定义了一个3行4列的二维数组array，并使用两个嵌套的循环初始化该数组。然后，我们使用两个嵌套的循环来输出数组元素。

4.2.3 二维数组的初始化

二维数组的初始化可以通过多种方式进行，可以手动赋值，也可以使用循环进行初始化。

【例4-8】二维数组的初始化
手动赋值方式初始化二维数组。

#include 
using namespace std;
int main() 
{
    int array[2][3] = {{1, 2, 3}, {4, 5, 6}};
    // 输出数组元素
    for (int i = 0; i < 2; i++) 
    {
        for (int j = 0; j < 3; j++) 
        {
            cout << array[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

程序运行结果如下

1 2 3
4 5 6

在上面的例子中，我们定义了一个2行3列的二维数组array，并使用初始化列表来给数组元素赋值。然后，我们使用两个嵌套的循环来输出数组元素。

4.2.4 二维数组应用实例

【例4-9】矩阵相加
给定两个相同大小的二维矩阵，计算它们的和，并输出结果。

#include 
using namespace std;
const int N = 3;
const int M = 3;
void matrixAddition(int a[][M], int b[][M], int result[][M]) 
{
    for (int i = 0; i < N; i++) 
    {
        for (int j = 0; j < M; j++) 
        {
            result[i][j] = a[i][j] + b[i][j];
        }
    }
}

int main() 
{
    int a[N][M] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int b[N][M] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
    int result[N][M];
    matrixAddition(a, b, result);
    // 输出结果
    for (int i = 0; i < N; i++) 
    {
        for (int j = 0; j < M; j++) 
        {
            cout << result[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

程序运行结果如下

10 10 10
10 10 10
10 10 10

在上面的例子中，我们定义了两个3行3列的二维数组a和b，表示两个矩阵。然后，我们定义了一个函数matrixAddition来计算矩阵a和b的和，并将结果保存在一个新的二维数组result中。最后，我们输出结果。

【例4-10】求矩阵中对角线的最大值
给定一个N×N的方阵，求方阵中对角线的最大值。

#include 
using namespace std;
const int N = 3;
int findMaxOnDiagonal(int matrix[][N]) 
{
    int max = matrix[0][0];
    for (int i = 1; i < N; i++) 
    {
        if (matrix[i][i] > max) 
        {
            max = matrix[i][i];
        }
    }
    return max;
}

int main() 
{
    int matrix[N][N] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
    int max = findMaxOnDiagonal(matrix);
    cout << "方阵中对角线的最大值为：" << max << endl;
    return 0;
}

程序运行结果如下

方阵中对角线的最大值为：9

在上面的例子中，我们定义了一个3行3列的方阵matrix，并编写了一个函数findMaxOnDiagonal来找到方阵中对角线的最大值。最后，我们输出结果。
C++学习笔记 - 字符数组

4.3 字符数组

字符数组是一种特殊的数组，其中的元素是字符。它可以用于存储和处理字符串。

4.3.1 字符数组的定义

在C++中，字符数组是一种特殊类型的数组，用于存储字符串。字符数组可以用来存储字符序列，以及用于处理字符串相关的操作。

示例代码：

#include 
using namespace std;
int main() 
{
    char name[10];
    cout << "请输入您的名字：";
    cin >> name;
    cout << "您好，" << name << "！" << endl;
    return 0;
}

程序运行结果如下

请输入您的名字：肯德德兄弟麦当当
您好，肯德德兄弟麦当当！

4.3.2 字符数组的初始化

字符数组可以通过多种方式进行初始化，包括直接赋值、使用字符串常量等。

示例代码：

#include 
using namespace std;
int main() 
{
    char greeting[6] = "Hello";
    cout << "Greeting message: " << greeting << endl;
    return 0;
}

程序运行结果如下

Greeting message: Hello

4.3.3 字符数组的引用

通过下标可以访问和修改字符数组中的单个字符。字符数组的引用可以用于获取字符数组中特定位置的字符，并进行相关操作。

【例4-11】字符数组的引用：

#include 
using namespace std;
int main() 
{
   char str[6] = "Hello";
   cout << "第一个字符：" << str[0] << endl;
   cout << "最后一个字符：" << str[4] << endl;
   return 0;
}

程序运行结果如下

第一个字符：H
最后一个字符：O

【利4-12】输出一个菱形图形

#include 
using namespace std;
int main() 
{
   char c = '*';
   for(int i = 1; i <= 5; i++) 
   {
      for(int j = 1; j <= 5 - i; j++) 
      {
         cout << " ";
      }
      for(int k = 1; k <= 2 * i - 1; k++) 
      {
         cout << c;
      } 
      cout << endl;
   }
   for(int i = 4; i >= 1; i--) 
   {
      for(int j = 1; j <= 5 - i; j++)
      {
         cout << " ";
      }
      for(int k = 1; k <= 2 * i - 1; k++) 
      {
         cout << c;
      } 
      cout << endl;
   }
   return 0;
}

程序运行结果如下

     *
    ***
   *****
  *******
 *********
  *******
   *****
    ***
     *

【到4-13】字符数组整体引用：

#include 
using namespace std;
int main() 
{
    char str[6] = "Hello";
    char *ptr = str;
    cout << "字符串为：" << ptr << endl;
    return 0;
}

程序运行结果如下

字符串为：Hello

4.3.4 字符串与字符串结束标志

字符串是由字符组成的字符数组，以空字符 ‘\0’ 结尾。可以通过字符串结束标志来判断字符串的结束位置。

【到4-14】求一个字符串的实际长度：

#include 
using namespace std;
int main() 
{
    char str[] = "Hello";
    int length = 0;
    while (str[length] != '\0') 
    {
        length++;
    }
    cout << "字符串的长度为：" << length << endl;
    return 0;
}

程序运行结果如下

字符串的长度为：5

4.4 常用的字符串处理函数

4.4.1 stremp()函数

【例 4-15】stremp()函数的应用

stremp()函数用于比较两个字符串是否相同。

示例代码：

#include
#include
using namespace std;
int main() 
{
    char str1[] = "Hello";
    char str2[] = "Hello";  
    int result = strcmp(str1, str2);   
    if (result == 0) 
    {
        cout << "字符串相同" << endl;
    } 
    else 
    {
        cout << "字符串不相同" << endl;
    }    
    return 0;
}

输出：

字符串相同

4.4.2 strepy()函数

【例4-16】strepy函数的应用

strepy()函数用于比较两个字符串是否相同，忽略大小写。

示例代码：

#include
#include
using namespace std;
int main() 
{
    char str1[] = "Hello";
    char str2[] = "hello";    
    int result = stricmp(str1, str2);    
    if (result == 0) 
    {
        cout << "字符串相同" << endl;
    } 
    else 
    {
        cout << "字符串不相同" << endl;
    }    
    return 0;
}

输出：

字符串相同

4.4.3 strcat()函数

【例4-17】strcat函数的应用

strcat()函数用于将一个字符串追加到另一个字符串的末尾。

示例代码：

#include
#include
using namespace std;
int main() 
{
    char str1[20] = "Hello";
    char str2[] = " World";   
    strcat(str1, str2);    
    cout << "合并后的字符串为：" << str1 << endl;    
    return 0;
}

输出：

合并后的字符串为：Hello World

4.4.4 strlen()函数

【例4-18】strlen() 函数的应用

strlen()函数用于获取字符串的长度。

示例代码：

#include
#include
using namespace std;
int main() 
{
    char str[] = "Hello";
    int length = strlen(str);    
    cout << "字符串的长度为：" << length << endl;   
    return 0;
}

输出：

字符串的长度为：5

4.4.5 strlwr()函数

strlwr()函数用于将字符串转换为小写。

示例代码：

#include
#include
using namespace std;
int main() 
{
    char str[] = "Hello";
    strlwr(str);    
    cout << "转换后的字符串为：" << str << endl;    
    return 0;
}

输出：

转换后的字符串为：hello

4.4.6 strlwr()函数

strupr()函数用于将字符串转换为大写。

示例代码：

#include
#include
using namespace std;
int main() 
{
    char str[] = "hello";
    strupr(str);    
    cout << "转换后的字符串为：" << str << endl;  
    return 0;
}

输出：

转换后的字符串为：HELLO

4.4.7 字符数组应用实例

【例4-19】字符串翻转

示例代码：

#include
#include
using namespace std;
void reverseString(char str[]) 
{
    int length = strlen(str);    
    for (int i = 0; i < length / 2; i++) 
    {
        char temp = str[i];
        str[i] = str[length - i - 1];
        str[length - i - 1] = temp;
    }
}

int main() 
{
    char str[] = "Hello World";    
    reverseString(str);    
    cout << "翻转后的字符串为：" << str << endl;   
    return 0;
}

输出：

翻转后的字符串为：dlroW olleH

【例4-20】判断字符串是否为回文

示例代码：

#include
#include
using namespace std;
bool isPalindrome(char str[]) 
{
    int length = strlen(str);    
    for (int i = 0; i < length / 2; i++) 
    {
        if (str[i] != str[length - i - 1]) 
        {
            return false;
        }
    }
    
    return true;
}

int main() 
{
    char str[] = "madam";   
    if (isPalindrome(str)) 
    {
        cout << "是回文字符串" << endl;
    } 
    else 
    {
        cout << "不是回文字符串" << endl;
    }    
    return 0;
}

输出：

是回文字符串

C++学习笔记（综合实例）

4.5 综合实例

4.5.1 折半查找法

【例4-21】折半查找法的应用

折半查找法是一种高效的查找算法，适用于有序数组。它的基本思想是通过比较中间元素和查找目标的大小关系，将查找范围不断缩小一半，直到找到目标或查找范围为空。

示例代码：

#include
using namespace std;
int binarySearch(int arr[], int target, int left, int right) 
{
    while (left <= right) 
    {
        int mid = (left + right) / 2;        
        if (arr[mid] == target) 
        {
            return mid;
        }
         else if (arr[mid] < target) 
        {
            left = mid + 1;
        } 
        else 
        {
            right = mid - 1;
        }
    }    
    return -1;
}
int main() 
{
    int arr[] = {1, 3, 5, 7, 9, 11, 13, 15};
    int target = 9;
    int size = sizeof(arr) / sizeof(arr[0]);    
    int result = binarySearch(arr, target, 0, size - 1);    
    if (result != -1) 
    {
        cout << "找到目标，索引为：" << result << endl;
    } 
    else 
    {
        cout << "未找到目标" << endl;
    }    
    return 0;
}

输出：

找到目标，索引为：4

4.5.2 将字符数组中的字符分类

【例4-22】将字符数组中的字符分类的应用

将一个字符数组中的字符按照字母、数字和其他字符分别存放到三个不同的数组中。

示例代码：

#include
using namespace std;
void classifyCharacters(char str[], char letters[], char digits[], char others[], int& letterSize, int& digitSize, int& otherSize) 
{
    letterSize = 0;
    digitSize = 0;
    otherSize = 0;    
    for (int i = 0; str[i] != '\0'; i++) 
    {
        if (isalpha(str[i])) 
        {
            letters[letterSize++] = str[i];
        } 
        else if (isdigit(str[i])) 
        {
            digits[digitSize++] = str[i];
        }
        else 
        {
            others[otherSize++] = str[i];
        }
    }    
    letters[letterSize] = '\0';
    digits[digitSize] = '\0';
    others[otherSize] = '\0';
}
int main()
{
    char str[] = "Hello 123@";
    char letters[100], digits[100], others[100];
    int letterSize, digitSize, otherSize;    
    classifyCharacters(str, letters, digits, others, letterSize, digitSize, otherSize);   
    cout << "字母数组：";
    for (int i = 0; i < letterSize; i++) 
    {
        cout << letters[i] << " ";
    }
    cout << endl;    
    cout << "数字数组：";
    for (int i = 0; i < digitSize; i++) 
    {
        cout << digits[i] << " ";
    }
    cout << endl;    
    cout << "其他字符数组：";
    for (int i = 0; i < otherSize; i++) 
    {
        cout << others[i] << " ";
    }
    cout << endl;    
    return 0;
}

输出：

字母数组：H e l l o 
数字数组：1 2 3 
其他字符数组：@