C语言与Java基础编程练习：LaunchCode和CS50课程练习合集

本文还有配套的精品资源，点击获取

简介：本练习集提供了用C语言编写的编程练习，旨在帮助初学者掌握编程基础，并涵盖了C语言的核心概念，如变量、数据类型、运算符、控制流、函数、数组和字符串。同时也提供了Java语言的学习资源，使学习者能够对比和理解两种不同编程语言的特点。C语言部分包括指针的使用、控制流结构、函数定义和调用、数组和字符串操作；Java部分则涉及面向对象编程的核心概念，包括类、对象、方法、异常处理、数组和集合框架、IO流和线程编程。综合练习覆盖了编程基础到面向对象编程，是初学者学习软件开发的良好起点。

1. C语言基础概念介绍

C语言作为编程世界的基石，拥有直接操纵硬件的强大力量，同时也需要程序员具备严谨的逻辑思维和细节处理能力。本章将带领读者了解C语言的基本元素，包括数据类型、变量、常量以及运算符等，为进一步深入学习C语言打下坚实基础。

首先，我们将探讨C语言中的数据类型。数据类型是定义变量所存储信息的种类，例如整型、浮点型等，它们决定了内存中用于存储变量的字节数，以及如何解释这些字节的内容。

接下来，我们会讲解变量和常量的定义。变量是可以改变的值，它们在程序执行过程中可以被赋新值；而常量是不可变的值，一旦初始化后就不能被改变。

最后，我们将深入理解运算符。C语言提供了丰富的运算符，包括算术运算符、关系运算符、逻辑运算符等，用于执行各种运算和逻辑判断。掌握它们是进行有效编程的关键。

#include <stdio.h>

int main() {
    int a = 10;     // 定义了一个整型变量a，并赋初值为10
    const float pi = 3.14159; // 定义了一个常量pi，并赋初值为3.14159
    a = a + 5;      // 使用算术运算符改变变量a的值

    printf("a = %d, pi = %.5f\n", a, pi); // 输出变量a和常量pi的值
    return 0;
}

代码示例说明了变量的定义、常量的使用，以及如何通过输出函数printf来显示它们的值。在C语言中，正确的数据类型使用和运算符的掌握是编写有效代码的前提，也是进一步学习指针、数组、函数等高级特性的基础。随着学习的深入，读者将会发现C语言的精妙和强大之处。

2. C语言指针使用

2.1 指针的基本概念与特性

2.1.1 指针的定义与内存地址

指针是C语言中一个核心的概念，它实际上是一个变量，用来存储内存地址。每个变量都有自己的地址，这个地址是内存中的一个位置。指针变量的值就是这个地址。理解指针的关键在于认识到指针变量和它所指向的变量是不同的实体。

指针变量的声明遵循以下的语法：

数据类型 *指针变量名;

例如，声明一个指向整型变量的指针：

int *ptr;

这里 ptr 是一个指针变量，它将存储一个整型变量的地址。在32位系统上，一个指针通常占用4个字节的内存空间，在64位系统上，通常占用8个字节。

指针的使用首先需要获取变量的地址，这通过在变量名前加上 & 操作符来实现。以下是如何使用指针来存储一个变量地址的示例：

int a = 10;
int *ptr = &a; // ptr现在存储变量a的地址

2.1.2 指针的运算与引用

指针的另一个重要特性是它们可以进行运算。指针运算包括增加指针的值以指向下一个元素（ ptr++ ），或者减小指针的值以指向前一个元素（ ptr-- ）。在C语言中，指针也可以进行算术运算（加或减一个整数），比较运算和解引用操作（获取指针所指向的值）。

解引用操作使用 * 操作符：

int b = *ptr; // 获取ptr指向的值并存储在变量b中

下面是代码块的解释分析：

• int a = 10; 这行代码声明了一个名为 a 的整型变量并初始化为10。
• int *ptr = &a; 这行代码声明了一个名为 ptr 的指针，并且让 ptr 指向变量 a 的地址。
• int b = *ptr; 这行代码获取指针 ptr 所指向的值，并将其存储在新的整型变量 b 中。

指针运算的一个重要方面是它们依赖于指针所指向的数据类型。例如，如果 ptr 是一个指向整型数据的指针，那么 ptr++ 将使指针前进一个整型数据的大小。如果 ptr 是一个指向字符数据的指针，则 ptr++ 将只前进一个字节。

理解指针的这些基本特性对于掌握更高级的概念至关重要，比如动态内存管理、指针与数组的互动、函数指针以及它们在更复杂的数据结构中的应用。

2.2 指针与数组的互动

2.2.1 指针遍历数组

数组是一种数据结构，它包含一系列相同类型的数据元素。在C语言中，数组名本身就是一个指向数组第一个元素的指针。因此，可以通过指针来遍历数组。指针遍历数组的一个优势是它通常比使用数组索引更高效。

下面是一个使用指针遍历数组的示例代码：

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr; // 指针ptr指向数组的第一个元素

for (int i = 0; i < 5; i++) {
    printf("%d ", *(ptr + i)); // 使用指针访问数组元素
}

代码逻辑分析：

• int arr[5] = {1, 2, 3, 4, 5}; 这行代码声明了一个整型数组 arr 并初始化了它的值。
• int *ptr = arr; 这行代码声明了一个指针 ptr ，并将其初始化为指向数组 arr 的第一个元素。
• 在 for 循环中， ptr + i 是一个指针算术的例子， ptr + i 实际上表示 ptr 向后移动 i 个整型元素的位置。
• *(ptr + i) 是对指针进行解引用操作，它获取 ptr 所指向的元素的值。

2.2.2 指针与多维数组

多维数组是一个数组，其元素也是数组。在C语言中，多维数组可以使用指针以更复杂的方式进行遍历。对于二维数组，我们可以用指针来遍历数组的每一行和每一列。

下面是一个使用指针遍历二维数组的示例代码：

int arr[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};
int (*ptr)[3] = arr; // 指针ptr指向数组的第一个子数组

for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        printf("%d ", *(*(ptr + i) + j));
    }
    printf("\n");
}

代码逻辑分析：

• int arr[2][3] = {...}; 这行代码声明了一个二维数组 arr 。
• int (*ptr)[3] = arr; 这行代码声明了一个指向数组第一个子数组的指针 ptr 。注意这里的括号是必须的，它指明了 ptr 是一个指针，而不是一个数组。
• 在外层 for 循环中， ptr + i 使指针 ptr 向前移动到第 i 行的开始位置。
• 在内层 for 循环中， *(ptr + i) + j 使指针向前移动到第 i 行的第 j 个元素。
• *(*(ptr + i) + j) 是对这个位置的元素进行解引用操作，获取它存储的值。

通过指针遍历多维数组是一种高级技巧，它展示了指针的强大功能。指针的使用并不只限于数组，还可以用于指向函数和动态内存管理。

2.3 指向函数的指针

2.3.1 函数指针的声明与定义

函数指针是一种特殊的指针，它可以存储函数的地址。函数指针允许我们动态地决定调用哪个函数，这在许多高级编程任务中是非常有用的，比如回调函数的实现。

下面是如何声明和定义函数指针的示例：

#include <stdio.h>

// 函数原型
int add(int a, int b);

int main() {
    // 声明函数指针
    int (*funcPtr)(int, int);
    // 定义函数指针，使其指向函数add
    funcPtr = add;
    // 使用函数指针调用函数
    int sum = funcPtr(10, 5);
    printf("Sum is %d\n", sum);
    return 0;
}

// 定义函数
int add(int a, int b) {
    return a + b;
}

代码逻辑分析：

• int (*funcPtr)(int, int); 这行代码声明了一个名为 funcPtr 的函数指针，它指向一个接受两个整型参数并返回一个整型值的函数。
• funcPtr = add; 这行代码将函数指针 funcPtr 定义为指向函数 add 。这里不需要使用 & 操作符，因为函数名本身就是函数的地址。
• funcPtr(10, 5); 这行代码通过函数指针调用 add 函数，参数为10和5，并获取返回值赋给变量 sum 。

函数指针的声明需要包含函数的返回类型和参数类型，这与函数原型的声明类似。通过声明函数指针，我们可以将函数作为参数传递给另一个函数，或者从函数中返回一个函数，从而实现更高级的编程技巧。

2.3.2 函数指针的应用示例

函数指针可以在很多不同的场景中使用，其中一个常见的应用是在排序算法中使用比较函数。我们可以用函数指针将一个比较函数传递给排序算法，使得排序算法能够适应不同的数据类型和排序规则。

下面是一个使用函数指针作为比较函数的排序示例：

#include <stdio.h>
#include <stdlib.h>

// 比较函数原型
int compare(const void *a, const void *b);

// 实际的比较函数，比较整数
int compare_int(const void *a, const void *b) {
    int int_a = *(const int *)a;
    int int_b = *(const int *)b;
    if (int_a < int_b) return -1;
    if (int_a > int_b) return 1;
    return 0;
}

int main() {
    int arr[] = {3, 1, 4, 1, 5, 9};
    int n = sizeof(arr) / sizeof(arr[0]);

    // 使用函数指针进行排序
    qsort(arr, n, sizeof(int), compare_int);
    // 打印排序后的数组
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

代码逻辑分析：

• int compare(const void *a, const void *b); 这行代码声明了一个比较函数原型，它用于 qsort 函数。
• int compare_int(const void *a, const void *b) 是实际的比较函数的实现，用于比较整数类型的数据。
• qsort 函数是C标准库提供的一个快速排序算法，它的第四个参数是用于比较元素的函数指针。
• qsort(arr, n, sizeof(int), compare_int); 这行代码调用 qsort 函数，并传递 compare_int 函数作为比较函数。

通过这种方式，我们可以根据需要传递不同的比较函数给 qsort 函数，从而实现不同类型数据的排序。这体现了函数指针在程序设计中的灵活性和强大功能。

3. C语言控制流结构

3.1 选择结构的使用

3.1.1 if-else语句的深入理解

在编程中，我们经常会遇到需要根据不同的条件来执行不同代码块的情况，这就需要用到选择结构。在C语言中， if-else 语句是最基本的选择结构，它的使用非常广泛，可以让我们基于条件判断来决定执行哪个代码分支。

if-else 语句的基本结构如下：

if (condition) {
    // 条件为真时执行的代码块
} else {
    // 条件为假时执行的代码块
}

这里的 condition 是一个布尔表达式，它的结果只能是真（非零值）或假（零值）。如果条件为真，则执行花括号内的代码块。如果条件为假，并且存在 else 部分，则执行 else 后面的代码块。

我们可以通过 else if 来扩展 if-else 语句，形成多条件分支：

if (condition1) {
    // 当 condition1 为真时执行的代码块
} else if (condition2) {
    // 当 condition1 为假且 condition2 为真时执行的代码块
} else {
    // 如果前面的条件都不满足，则执行这里的代码块
}

if-else 语句的优化主要是通过提前结束某些分支的执行来简化代码逻辑，尤其是在多层嵌套的情况下。例如，使用逻辑运算符 && 和 || 来合并条件可以减少 else if 的层数。此外，尽量避免在 if-else 条件判断中进行复杂的计算，因为这样会影响代码的可读性和性能。

3.1.2 switch-case语句的高级用法

switch-case 语句是另一种选择结构，它在某些情况下比 if-else 语句更加高效和清晰。 switch-case 用于基于一个变量的多个固定值来执行不同的代码块。

基本的 switch-case 语句格式如下：

switch (expression) {
    case value1:
        // 当 expression 等于 value1 时执行的代码块
        break;
    case value2:
        // 当 expression 等于 value2 时执行的代码块
        break;
    // 可以有任意数量的 case 分支
    default:
        // 当没有 case 分支匹配时执行的代码块
}

在这里， expression 必须是一个整型或枚举类型的表达式，每个 case 后面跟着一个要比较的常量值。 break 语句是可选的，用于终止 switch 语句的执行，防止程序自动继续执行下一个 case 。

switch-case 语句在编译时会被转换成跳转表（Jump Table），这使得其在执行时比 if-else 链更加高效，特别是在需要进行多条件分支判断时。不过， switch-case 只能用于等值判断，不能用于范围判断。

下面是一个使用 switch-case 语句的示例代码，它根据输入的数字打印出相应的星期几：

#include <stdio.h>

int main() {
    int num;
    printf("Enter a number between 0 and 6: ");
    scanf("%d", &num);

    switch (num) {
        case 0:
            printf("Sunday\n");
            break;
        case 1:
            printf("Monday\n");
            break;
        case 2:
            printf("Tuesday\n");
            break;
        case 3:
            printf("Wednesday\n");
            break;
        case 4:
            printf("Thursday\n");
            break;
        case 5:
            printf("Friday\n");
            break;
        case 6:
            printf("Saturday\n");
            break;
        default:
            printf("Invalid number\n");
    }

    return 0;
}

在使用 switch-case 时，应当注意，如果没有 break 语句，程序会从匹配的 case 开始执行，直到遇到 break 或者 switch 语句结束，这被称为“穿透”现象。合理利用这一特性有时可以减少代码量，比如在多个 case 需要执行相同操作时。

3.2 循环结构的深化

3.2.1 for循环的进阶技巧

for 循环是C语言中用于重复执行代码块的结构之一。它的基本形式包括初始化表达式、条件表达式和迭代表达式，其结构如下：

for (initialization; condition; update) {
    // 循环体
}

初始化表达式会在循环开始前执行一次；条件表达式会在每次循环迭代之前被评估，如果为真，则继续执行循环体，否则退出循环；迭代表达式在每次迭代结束后执行。

for 循环可以利用其结构灵活地实现各种复杂的重复操作，是进行数学运算和数组处理时不可或缺的工具。

进阶技巧包括使用逗号运算符在初始化和迭代表达式中执行多个操作：

for (i = 0, j = 10; i < j; i++, j--) {
    // 循环体
}

此外，还可以使用空的初始化或迭代表达式：

for (; count < MAX_COUNT; ) {
    // 使用其他方式更新 count
    count++;
}

for (int i = 0;;) {
    // 根据条件判断决定是否 break
    if (i >= 10) break;
    i++;
}

空的初始化和迭代表达式在现代C编程中越来越常见，特别是在循环体内部处理条件更新时更为方便。

3.2.2 while与do-while循环的区别与选择

while 和 do-while 循环都是C语言中用于重复执行代码块的结构，但它们在条件检查的时机上有所不同。

while 循环的基本结构如下：

while (condition) {
    // 循环体
}

在 while 循环中，条件在每次迭代开始前进行检查，如果条件为假，则循环体一次也不会执行。

而 do-while 循环至少会执行一次循环体，然后在每次迭代结束后检查条件：

do {
    // 循环体
} while (condition);

选择使用 while 还是 do-while 循环，依赖于具体需求。如果需要先进行条件判断再决定是否执行循环体，使用 while 循环；如果循环体无论如何都要执行至少一次，那么 do-while 循环是更好的选择。

do-while 循环的使用示例：

int count = 0;
do {
    printf("Count is: %d\n", count);
    count++;
} while (count < 5);

在编写循环结构时，要注意循环的退出条件是否合理，防止出现无限循环。同时，确保循环变量在循环体内有更新，否则会导致死循环。

3.3 break和continue的深入探讨

3.3.1 break语句的多场景应用

break 语句可以用来立即退出包含它的最内层循环或 switch 语句。在复杂的循环结构中， break 可以用于提前结束循环，从而避免不必要的迭代。

例如，在一个搜索算法中，一旦找到目标项，即可使用 break 退出循环：

int data[] = {1, 2, 3, 4, 5};
int target = 3;

for (int i = 0; i < sizeof(data)/sizeof(data[0]); i++) {
    if (data[i] == target) {
        printf("Target found at index: %d\n", i);
        break; // 找到目标，退出循环
    }
}

除了在循环中使用外， break 也经常用在 switch-case 语句中防止“穿透”现象，或者在某些嵌套的控制结构中直接退出到外层。

3.3.2 continue语句的优化策略

continue 语句用于跳过当前循环中的剩余代码，并开始下一次的循环迭代。它通常用于过滤不符合条件的元素，或者在循环体中快速跳转到下一个迭代。

一个简单的例子是在打印1到10的数字时，跳过数字5：

for (int i = 1; i <= 10; i++) {
    if (i == 5) continue; // 跳过数字5
    printf("%d ", i);
}

使用 continue 可以使代码更加简洁，但过度使用可能会降低代码的可读性。在适当的地方使用 continue 语句，可以让循环结构更高效。

// 统计0到99之间非3的倍数的数字个数
int count = 0;
for (int i = 0; i < 100; i++) {
    if (i % 3 == 0) continue; // 不统计3的倍数
    count++;
}
printf("Total numbers not divisible by 3: %d\n", count);

continue 语句的优化策略在于避免在循环体内部使用过多的 if-else 语句，这样可以减少代码的复杂度并提高执行效率。

4. C语言函数操作

4.1 函数的声明与定义

4.1.1 函数原型的作用与好处

函数原型是函数声明的另一种说法，它提供了函数名称、返回类型以及参数类型等信息，但不包含函数体。函数原型在C语言中是非常重要的，它具有以下好处：

1. 类型检查 ：函数原型使编译器能够检查函数调用的参数类型是否匹配，确保类型安全。
2. 代码组织 ：通过在代码的顶部声明所有使用的函数原型，可以更清晰地组织程序的结构，提高代码的可读性。
3. 避免重复 ：函数原型避免了在每个调用点都要给出函数定义的重复。
4. 链接支持 ：在多文件项目中，函数原型允许编译器在链接时查找函数定义的位置。
5. 接口说明 ：函数原型清晰地声明了函数的接口，便于开发者理解每个函数的作用。

#include <stdio.h>

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

int main() {
    int a = 10, b = 20;
    printf("Max value: %d\n", max(a, b)); // 正确的函数调用，类型匹配
    return 0;
}

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

4.1.2 参数传递机制：值传递与引用传递

C语言中，函数的参数传递可以通过值传递或引用传递。参数传递机制影响数据在函数间的传递方式和内存的使用。

值传递 ： - 在值传递中，函数接收的是实际参数的副本。 - 对这些副本的修改不会影响到原始数据。 - 值传递适用于不需要改变原始数据的场景。

void increment(int num) {
    num++; // 增加副本的值，不影响原始数据
}

int main() {
    int value = 10;
    increment(value);
    printf("Original value: %d\n", value); // 输出原始值，不受影响
    return 0;
}

引用传递 ： - 在引用传递中，函数接收的是实际参数的引用（地址）。 - 对引用的修改将直接反映在原始数据上。 - 引用传递通常通过指针实现。

void increment(int *num) {
    (*num)++; // 通过指针直接修改原始数据的值
}

int main() {
    int value = 10;
    increment(&value);
    printf("Original value: %d\n", value); // 输出修改后的值
    return 0;
}

4.2 函数的高级特性

4.2.1 递归函数的原理与应用

递归函数是一种直接或间接调用自身的函数。递归函数的设计应遵循两个原则：基本情况和递归步骤。

// 斐波那契数列实现示例
int fibonacci(int n) {
    if (n <= 1) {
        return n; // 基本情况：n为0时返回0，n为1时返回1
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2); // 递归步骤
    }
}

int main() {
    int n = 5;
    printf("Fibonacci number at position %d is %d\n", n, fibonacci(n));
    return 0;
}

在上面的代码中， fibonacci 函数通过递归的方式计算斐波那契数列的第 n 项。递归函数虽然强大且在某些问题上能提供简洁的解决方案，但也要注意递归深度限制和性能开销。

4.2.2 变长参数函数的实现与限制

变长参数函数是一种能够接受任意数量参数的函数，常用于实现类似 printf 和 scanf 这样的函数。变长参数通过 <stdarg.h> 头文件提供的宏来实现。

#include <stdarg.h>
#include <stdio.h>

// 计算整数参数的和
int sum(int count, ...) {
    int sum = 0;
    va_list args; // 定义va_list类型变量
    va_start(args, count); // 初始化args指向第一个变长参数
    for (int i = 0; i < count; i++) {
        sum += va_arg(args, int); // 获取下一个参数并累加
    }
    va_end(args); // 清理工作
    return sum;
}

int main() {
    printf("Sum is: %d\n", sum(3, 10, 20, 30)); // 输出和为60
    return 0;
}

在实现变长参数函数时，应始终注意以下限制和要求：

• 必须至少有一个已知类型的参数，以便确定参数列表的结束位置。
• 参数列表必须以省略号（...）结尾。
• 使用 va_start 、 va_arg 和 va_end 宏来进行参数的遍历和处理。
• 在递归使用变长参数函数时，要特别小心，确保不会导致未定义行为。

4.3 函数与模块化编程

4.3.1 模块化设计的基本原则

模块化编程是将一个大程序分解为多个小的、相对独立的模块，并且每个模块完成特定功能的设计方法。模块化设计遵循以下原则：

• 单一职责 ：每个模块只负责一个具体的功能。
• 高内聚 ：模块内部的功能应紧密相关。
• 低耦合 ：模块之间的依赖关系应尽可能弱化。
• 可复用性 ：模块应设计为可重用的，并且在不同上下文中易于使用。
• 可测试性 ：模块应当容易测试，确保其按预期工作。

4.3.2 函数库的创建与使用

创建函数库是模块化编程中的一项重要技术。函数库提供了一组预先编写好的函数，供其他程序调用。创建和使用函数库的步骤通常包括：

1. 定义库函数 ：确定函数库需要提供的功能，并编写对应的函数。
2. 编写头文件 ：为库函数编写相应的头文件，声明函数原型。
3. 编译库函数 ：将库函数编译为静态库或共享库。
4. 使用库函数 ：在其他程序中通过包含头文件并链接库文件来使用函数。

// example.h: 函数库头文件
#ifndef EXAMPLE_H
#define EXAMPLE_H

// 函数原型声明
void example_function(int param);

#endif

// example.c: 函数库实现文件
#include "example.h"

// 函数定义
void example_function(int param) {
    printf("Function called with parameter: %d\n", param);
}

// 编译命令，生成静态库 libexample.a
// gcc -c example.c
// ar rcs libexample.a example.o

// 使用函数库的主程序
#include "example.h"

int main() {
    example_function(123);
    return 0;
}

// 编译主程序并链接函数库
// gcc main.c -L. -lexample -o main

在上述示例中， example.c 编译为名为 libexample.a 的静态库，然后在主程序 main.c 中包含对应的头文件并链接此库来使用 example_function 函数。通过这种方式，可以将函数封装为独立的模块，从而提高程序的模块化程度和代码的可维护性。

5. C语言数组和字符串

在C语言中，数组和字符串是数据结构的重要组成部分，它们在处理集合数据时扮演了核心角色。本章将深入探讨数组的使用和优化方法，以及字符串处理的技巧和综合应用。

5.1 数组的使用与优化

数组是一种存储相同类型数据的数据结构，这些数据在内存中连续存放。在C语言中，数组的使用是基础且常见的编程实践。

5.1.1 数组的定义与初始化

数组的定义通过指定数组名和类型来完成，例如定义一个整型数组：

int array[10]; // 定义了一个包含10个整数的数组

数组的初始化可以在定义时直接赋值：

int array[3] = {1, 2, 3}; // 定义并初始化包含3个整数的数组

或者在数组定义之后对数组元素进行赋值：

int array[3];
array[0] = 1;
array[1] = 2;
array[2] = 3;

5.1.2 动态数组的创建与管理

静态数组的大小在编译时就确定了，而动态数组则允许在运行时分配内存，C语言中通常使用 malloc 和 calloc 来创建动态数组。

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *dynamicArray = malloc(10 * sizeof(int)); // 创建一个可存储10个整数的动态数组
    if(dynamicArray == NULL) {
        // 内存分配失败的处理
        exit(EXIT_FAILURE);
    }
    // 初始化数组元素...
    free(dynamicArray); // 使用完毕后释放内存
    return 0;
}

动态数组的大小可以动态改变，适用于不知道数组大小的情况。必须注意的是，使用完动态数组后，必须调用 free() 函数释放内存，避免内存泄漏。

5.2 字符串处理技巧

字符串在C语言中以字符数组的形式存在，以空字符 \0 结尾。在处理字符串时，C语言提供了丰富的库函数，如 strcpy 、 strcat 、 strlen 等。

5.2.1 字符串字面量与字符数组的区别

字符串字面量是存储在程序代码段中的常量，而字符数组则是在数据段中分配的。示例如下：

char *str = "Hello, World!"; // 字符串字面量
char arr[] = "Hello, World!"; // 字符数组

5.2.2 字符串函数的正确使用与常见问题

在使用字符串函数时，如 strcpy ，需要注意目标数组的空间是否足够大，以防止缓冲区溢出：

char source[] = "source";
char dest[10];
strcpy(dest, source); // 正确使用，dest足够大

使用字符串函数的常见问题是未检查目标数组大小导致的缓冲区溢出：

char source[] = "source";
char dest[5]; // 目标数组太小
strcpy(dest, source); // 将导致缓冲区溢出

应避免此类错误，因为它们可能会导致程序崩溃或安全漏洞。

5.3 字符串与数组的综合应用

字符串数组是一种常见的数据结构，可以用于存储多个字符串。在处理字符串数组时，经常需要使用循环结构来遍历或比较数组中的字符串。

5.3.1 字符串数组的使用场景

字符串数组可用于存储单词列表、文件路径集合等。例如，命令行参数就是通过字符串数组 argv 传递给 main 函数的：

int main(int argc, char *argv[]) {
    for (int i = 0; i < argc; i++) {
        printf("%s\n", argv[i]);
    }
    return 0;
}

5.3.2 字符串处理算法示例

字符串的处理算法可能包括查找、排序、转换等。下面是一个使用 strcmp 函数对字符串数组进行排序的简单示例：

#include <stdio.h>
#include <string.h>

int main() {
    char *names[] = {"Alice", "Bob", "Charlie"};
    int n = sizeof(names) / sizeof(names[0]);
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            if (strcmp(names[i], names[j]) > 0) {
                // 交换字符串指针
                char *temp = names[i];
                names[i] = names[j];
                names[j] = temp;
            }
        }
    }
    // 打印排序后的名字
    for (int i = 0; i < n; i++) {
        printf("%s\n", names[i]);
    }
    return 0;
}

在实际应用中，字符串与数组的综合使用场景非常广泛，掌握其基本操作和常见算法对开发效率有着显著的提升作用。

本文还有配套的精品资源，点击获取

简介：本练习集提供了用C语言编写的编程练习，旨在帮助初学者掌握编程基础，并涵盖了C语言的核心概念，如变量、数据类型、运算符、控制流、函数、数组和字符串。同时也提供了Java语言的学习资源，使学习者能够对比和理解两种不同编程语言的特点。C语言部分包括指针的使用、控制流结构、函数定义和调用、数组和字符串操作；Java部分则涉及面向对象编程的核心概念，包括类、对象、方法、异常处理、数组和集合框架、IO流和线程编程。综合练习覆盖了编程基础到面向对象编程，是初学者学习软件开发的良好起点。

本文还有配套的精品资源，点击获取