C语言编程实践：创建计算器

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

简介：创建计算器是C语言初学者的入门级项目，涉及C语言基础语法和控制结构。本指南涵盖了从输入输出、变量定义、运算符优先级到条件语句、循环语句、函数定义、错误处理、字符串处理、内存管理和逻辑结构等多个关键知识点。学习这一实践项目将加深对C语言的理解，并提供对编程逻辑和结构的直观认识。

1. C语言基础语法与控制结构

在第一章中，我们将深入了解C语言的基础知识和控制结构，为后面章节的深入学习打下坚实的基础。首先，我们会讨论C语言的基本语法元素，包括数据类型、表达式、控制语句以及函数定义等。这将为读者提供掌握程序设计的基本技能。

我们将从程序的基本组成部分开始，解释如何使用C语言中的控制结构来实现程序逻辑。控制结构是任何编程语言中的核心，允许开发者控制程序的流程，包括选择结构和循环结构，如 if-else 语句和 for 循环。理解这些概念对于编写高效、可靠的C程序至关重要。

我们还会介绍如何利用C语言提供的控制结构来解决复杂问题。例如，通过适当的控制流程，我们可以处理不同类型的数据并执行复杂的操作，这为后续学习更高级的编程技巧提供了一个稳固的起点。

2. 输入输出和变量操作

2.1 输入输出使用 printf() 和 scanf()

2.1.1 printf()的基本用法

printf() 函数是C语言中最基本的输出函数，它允许程序员将格式化后的数据输出到标准输出设备上，通常是电脑的屏幕。其基本语法结构是：

printf("格式字符串", 参数列表);

格式字符串定义了输出的样式，而参数列表则是要输出的数据。格式字符串可以包含普通字符、转义字符以及格式说明符。转义字符包括如换行符 \n 、制表符 \t 等。格式说明符以 % 开头，并指示了输出数据的类型。常见的格式说明符包括 %d （整数）、 %f （浮点数）、 %c （字符）等。

代码示例：

#include <stdio.h>

int main() {
    int num = 10;
    float pi = 3.14159;
    char grade = 'A';
    printf("整数: %d\n", num);
    printf("浮点数: %f\n", pi);
    printf("字符: %c\n", grade);

    return 0;
}

逻辑分析和参数说明：

在上述代码中， printf 函数被用来输出一个整数、一个浮点数和一个字符。每个 printf 调用中的格式字符串包含了一个或多个格式说明符，分别对应要输出的变量类型。格式说明符 %d 用于输出整数， %f 用于输出浮点数，而 %c 用于输出单个字符。

2.1.2 scanf()的高级技巧

scanf() 函数用于从标准输入（通常是键盘）读取格式化输入。其语法如下：

scanf("格式字符串", 参数列表);

scanf 的格式字符串与 printf 类似，它定义了如何读取输入。与 printf 不同的是， scanf 需要变量的地址作为参数，这样函数才能在读取输入后修改变量的值。

高级技巧：

1. 指定宽度： 对于字符串的输入，可以通过 %Ns 格式说明符来指定输入的最大字符数，防止缓冲区溢出。
2. 控制空格的读取： 使用 %[...] 和 %[^...] 可以控制对空格的读取，这对于处理包含空格的输入数据非常有用。
3. 地址操作符 & ： 读取变量时必须使用 & 获取变量的地址，否则 scanf 无法正确存储输入的值。
4. 读取和转换组合： 使用 scanf 可以在同一行内读取和转换数据，如 scanf("%d%c", &num, &ch); 可以在读取一个整数后读取一个字符。

代码示例：

#include <stdio.h>

int main() {
    int num;
    char grade;
    printf("请输入一个整数和一个字符（用空格分隔）: ");
    scanf("%d %c", &num, &grade);

    printf("读取到的整数为: %d\n", num);
    printf("读取到的字符为: %c\n", grade);

    return 0;
}

逻辑分析和参数说明：

在本例中， scanf 函数首先读取一个整数并存储在变量 num 中，然后读取一个字符并存储在变量 grade 中。需要注意的是， %d 和 %c 之间有一个空格，这是为了正确地分隔整数和字符输入。如果输入格式不正确， scanf 可能无法正确读取数据，因此编写健壮的代码时需要考虑到异常输入的处理。

2.2 变量定义与数值存储

2.2.1 常见数据类型与变量定义

在C语言中，变量是存储数据的单元，它们必须在使用前声明类型。C语言支持多种数据类型，包括基本类型如 int 、 float 、 char ，以及派生类型如数组、结构体等。定义变量的基本语法如下：

数据类型 变量名;

或者

数据类型 变量名1, 变量名2, ..., 变量名n;

定义多个同类型的变量时，可以在一个声明中完成。

代码示例：

#include <stdio.h>

int main() {
    int a, b;
    float x, y;
    char initial;

    a = 10;
    b = 20;
    x = 3.14159;
    y = 0.61803;
    initial = 'A';

    printf("整数 a: %d, 整数 b: %d\n", a, b);
    printf("浮点数 x: %f, 浮点数 y: %f\n", x, y);
    printf("字符 initial: %c\n", initial);

    return 0;
}

逻辑分析和参数说明：

在上述代码中，我们声明了整数、浮点数和字符类型的变量，并分别对它们赋值。这些变量在声明后即可在程序中使用，用于存储临时数据或程序状态。需要注意的是，每个变量在使用前必须声明，并且应该根据变量的预期用途选择合适的数据类型。

2.2.2 数据存储与内存布局

当变量被定义之后，计算机为它们分配内存空间。在C语言中，数据类型决定了变量在内存中所占用的字节数。例如，一个 int 类型在大多数平台上占用4个字节，而 float 类型通常占用4个字节， char 类型占用1个字节。内存布局可以根据变量的声明顺序、数据类型以及编译器对齐规则而变化。

数据类型还决定了可以对变量进行的操作。例如，整数类型的变量可以进行算术运算，而字符类型的变量可以进行字符操作。

内存布局的考虑因素：

1. 内存对齐： 编译器通常会将变量按特定的对齐方式存储，以优化性能。例如，某些平台可能会要求双字节整数在偶数地址上对齐。
2. 栈内存与堆内存： 局部变量（自动存储期）通常存储在栈内存上，由系统自动管理；动态分配的变量（动态存储期）则存储在堆内存上，需要手动管理。
3. 变量的生命周期： 变量的生命周期取决于它们的存储期，栈上变量通常在其声明的作用域结束后就被销毁，而堆上的变量则需要显式释放。

理解数据的存储和内存布局对于编写高效且可预测的程序至关重要。程序员必须根据变量的用途和预期的生命周期来选择正确的存储区域。

代码示例：

#include <stdio.h>

int main() {
    int a;
    float b;
    char c;
    int *ptr_a = &a;

    printf("整数 a 的地址: %p\n", (void*)ptr_a);
    printf("浮点数 b 的地址: %p\n", (void*)&b);
    printf("字符 c 的地址: %p\n", (void*)&c);

    return 0;
}

逻辑分析和参数说明：

在这个代码中，我们打印出了变量 a 、 b 和 c 的内存地址。通过指针 ptr_a ，我们能够访问并打印整数变量 a 的地址。输出的地址信息显示了这些变量是如何在内存中布局的，同时反映了栈内存的性质，即内存地址通常是递减的，因为栈是由高地址向低地址生长的。

通过本节的介绍，我们学习了如何在C语言中进行基本的输入和输出操作，了解了变量的定义以及它们在内存中的存储方式。这些基础知识对于编写可靠的C语言程序至关重要，特别是在进行更复杂的内存管理和系统编程时。接下来的章节将探讨运算符与流程控制，这是编写任何程序都需要使用的控制结构。

3. 运算符和流程控制

3.1 运算符优先级规则

3.1.1 基础运算符及其优先级

在C语言中，运算符用于指定执行特定的数学或逻辑操作。基础运算符包括算术运算符、关系运算符、逻辑运算符、位运算符和赋值运算符。不同的运算符具有不同的优先级，决定了表达式中操作的执行顺序。

算术运算符包括加法 + 、减法 - 、乘法 * 、除法 / 、取模 % 等。关系运算符用于比较两个操作数，并返回一个布尔值，比如 > 、 < 、 >= 、 <= 、 == 、 != 。逻辑运算符用于执行逻辑运算，如逻辑与 && 、逻辑或 || 、逻辑非 ! 。

运算符优先级从高到低大致如下：
- () 圆括号，用于改变运算顺序。
- ! 逻辑非，单目运算符。
- * 、 / 、 % 算术运算符。
- + 、 - 算术运算符。
- < 、 <= 、 > 、 >= 、 != 、 == 关系运算符。
- && 逻辑与，双目运算符。
- || 逻辑或，双目运算符。

掌握运算符的优先级对于编写准确的表达式至关重要。

3.1.2 运算符的组合使用和括号的运用

在复杂表达式中，合理使用括号可以清晰地表达运算顺序。括号内的表达式首先被计算，无论括号内是什么类型的运算符。

int result = 3 + 5 * 2;  // 乘法运算先执行，结果为13
int result_paren = (3 + 5) * 2;  // 使用括号改变运算顺序，结果为16

上述例子中，不使用括号时先执行乘法运算，而使用括号后先计算加法。对于C语言初学者，熟练掌握优先级和使用括号可以避免许多常见的错误。

3.2 条件语句（if-else）的运用

3.2.1 if-else语句的基本结构

条件语句允许根据表达式的真假执行不同的代码块。if-else语句是最基本的条件语句。基本结构如下：

if (expression) {
    // 当expression为真（非零）时执行的代码块
} else {
    // 当expression为假（零）时执行的代码块
}

3.2.2 嵌套条件语句的应用

嵌套条件语句指的是在if-else语句的代码块内部再使用if-else语句。它适用于需要根据多个条件进行决策的情况。

int num = 10;

if (num > 0) {
    if (num % 2 == 0) {
        printf("正数且为偶数\n");
    } else {
        printf("正数且为奇数\n");
    }
} else if (num == 0) {
    printf("为零\n");
} else {
    printf("负数\n");
}

此代码段首先判断 num 是否大于零，然后再根据 num 是否能被2整除来进一步判断是偶数还是奇数。在嵌套条件语句中，代码的可读性尤为重要，使用适当的缩进和大括号是良好编码习惯的体现。

3.3 循环语句（for或while）的实现

3.3.1 for循环的结构和特性

for循环是一种常用的循环结构，它将循环控制代码集中在一起，使得结构更加清晰。for循环的结构包含三部分：初始化表达式、条件表达式和迭代表达式，每部分用分号隔开。

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

• initialization ：通常用于初始化循环变量。
• condition ：在每次循环迭代前进行检查的表达式，如果为真（非零），则执行循环体；如果为假（零），则退出循环。
• increment/decrement ：每次迭代结束时执行的操作，通常用于更新循环变量。

for循环非常适合迭代固定次数的情况。

3.3.2 while循环与do-while循环的区别

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

while循环在每次迭代开始前检查条件：

while (condition) {
    // 循环体
}

与此相反，do-while循环至少执行一次循环体，即使条件从未满足过，因为它是先执行循环体，然后检查条件。

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

do-while循环更适合那些至少需要执行一次循环体的情况。

3.4 分支和循环的优化方法

3.4.1 减少不必要的计算

在循环结构中，减少不必要的计算能够显著提高程序的性能。特别是在条件判断中，复杂的表达式应当避免放在循环条件中反复计算。

3.4.2 使用早期返回避免嵌套

过深的嵌套会使代码难以阅读和维护。通过早期返回（使用return语句提前结束函数执行）可以减少嵌套深度。

3.4.3 循环展开与向量化

循环展开（Loop unrolling）是一种减少循环开销的技术，它通过减少迭代次数来降低条件检查和循环控制的开销。

向量化是使用硬件级的向量操作来加速数据处理的技术，适用于支持SIMD（单指令多数据）的操作。

以上章节展示了C语言中运算符和流程控制的详细运用。从基础的运算符优先级到复杂的条件和循环结构，理解这些基础概念对于成为高效的C程序员至关重要。而在实际应用中，结合优化策略能够显著提高代码性能和可读性。

4. 函数定义与模块化编程

4.1 函数定义与参数传递

4.1.1 函数的定义和声明

函数是C语言中的一个基本构造，用于将一段代码封装起来，以便重复使用。函数的定义由返回类型、函数名、一对圆括号以及一对花括号组成的大括号内的一组语句组成。

返回类型 函数名(参数列表) {
    // 函数体
}

在这个结构中，返回类型指明函数将要返回的数据类型，它决定了函数可以返回什么类型的数据。函数名是函数的标识符，用于在代码中引用该函数。参数列表是可选的，用逗号分隔的变量列表，这些变量定义了传递给函数的参数。函数体包含了函数的实现逻辑。

声明一个函数时，通常会省略函数名后的花括号及其中的代码，而只提供返回类型、函数名和参数列表。声明的目的是告诉编译器该函数的存在以及如何调用它，以便在编译时检查函数调用的正确性。

4.1.2 参数的传递方式和作用域

C语言中的函数参数通过值传递的方式进行参数传递。这意味着当函数被调用时，实际参数的值被复制到形参中。因此，在函数内部对形参的任何修改都不会影响到实参。

void increment(int n) {
    n += 1;
    // 此处修改n不会影响函数外部的变量
}

int main() {
    int a = 5;
    increment(a);
    // a 的值仍然是5
    return 0;
}

在上述示例中， increment 函数接收一个整型参数 n ，并在函数内部将 n 的值增加 1 。但是，由于是值传递，所以函数外部的变量 a 的值并没有被修改。

函数参数的作用域局限于函数体内部。这意味着只有在函数内部定义的变量才能在函数内部访问。函数外部定义的变量（全局变量除外）无法在函数内部直接访问。

4.2 模块化编程

4.2.1 模块化的优势和设计思路

模块化编程是指将复杂的问题分解为较小、更易于管理的部分的编程方法。在C语言中，这通常是通过将程序分解为多个函数来实现的。每个函数可以看作是一个模块，它封装了一段特定的功能。

模块化的主要优势包括：

1. 可维护性 ：模块化代码更容易阅读和理解。每个函数的职责清晰定义，使得代码的维护和更新更加方便。
2. 可重用性 ：良好的模块化设计允许代码片段被重用。这些模块可以在多个程序或程序的不同部分中重复使用。
3. 可测试性 ：函数作为独立的模块，可以单独进行测试。这有助于发现和修复bug，提高了程序的可靠性。

设计模块化程序时，应遵循“高内聚低耦合”的原则。高内聚意味着函数应集中于完成一个单一的功能，而低耦合则意味着函数之间应尽量减少依赖关系。

4.2.2 函数复用和代码重用

在模块化编程中，函数复用是一个重要的概念。它是通过在多个地方调用同一个函数来实现的。这不仅减少了代码的冗余，还有助于代码的维护。

#include <stdio.h>

void printMessage(const char *message) {
    printf("Message: %s\n", message);
}

int main() {
    printMessage("Hello, World!");
    printMessage("This is a reusable function.");
    return 0;
}

在这个例子中， printMessage 函数被用来打印不同类型的消息。通过将打印逻辑封装在一个函数内，我们避免了在程序的多个地方重复编写相同的代码。

代码重用是指在多个项目或程序中使用相同或相似的代码。在模块化编程中，通过创建通用的、功能明确的函数，我们可以轻松地在不同的项目中重用这些函数，从而提高开发效率并保证代码的一致性。

接下来的章节，我们将会探讨错误处理和高级操作，这些在模块化编程中同样重要，因为它们对于开发健壮的程序至关重要。

5. 错误处理和高级操作

5.1 错误处理和异常检查

5.1.1 异常处理机制

C语言虽然没有像Java或C++那样的异常处理机制，但它通过返回值、错误码和信号等方式来处理程序运行时可能出现的异常情况。在编写C语言程序时，了解和正确使用这些机制对于开发出健壮的程序至关重要。

以标准库函数的返回值为例，很多函数在遇到错误时会返回一个特定的值，如 malloc 在内存分配失败时返回 NULL 。开发者应当检查这些返回值，并根据不同的错误采取相应的措施：

int *ptr = malloc(sizeof(int) * 10);
if (ptr == NULL) {
    // 内存分配失败，执行错误处理代码
    fprintf(stderr, "Memory allocation failed\n");
    exit(EXIT_FAILURE);
}

错误码是另一种常见的错误处理方式，特别是在系统调用和库函数中。错误码通常是一个整数，每个错误码对应一种错误状态。例如， errno 是一个全局变量，它在函数调用失败时被设置为对应的错误码。开发者可以通过检查 errno 来确定错误类型：

#include <errno.h>
#include <sys/types.h>
#include <unistd.h>

int result = write(STDOUT_FILENO, "Hello, world\n", 13);
if (result == -1) {
    if (errno == EINTR) {
        // 信号中断了系统调用
    } else {
        // 其他错误处理
        perror("Failed to write");
    }
}

异常检测和处理在程序中的重要性不容忽视。通过适当的错误处理机制，我们能保证程序在面对错误情况时能够优雅地处理，从而提高程序的可靠性和健壮性。

5.1.2 错误检测与程序的健壮性

程序的健壮性是指程序在面对错误输入或错误条件时仍能保持稳定运行的能力。为了提升程序的健壮性，除了使用基本的错误检测机制外，还需要通过一系列策略来预防和处理潜在的异常情况。

一种有效的策略是进行边界检查和输入验证。对于所有的用户输入和边界条件，开发者应当在逻辑判断中添加必要的检查：

int main() {
    int number;
    printf("Enter a number: ");
    if (scanf("%d", &number) != 1) {
        // 输入不正确
        printf("Error: Invalid number.\n");
        return EXIT_FAILURE;
    }
    // 正常处理逻辑
    return EXIT_SUCCESS;
}

在上述例子中， scanf 的返回值告诉我们用户输入是否成功。当输入失败时，程序会通知用户错误信息并终止执行。

此外，程序应当具有日志记录功能，记录关键操作和错误信息，这对于错误追踪和程序维护非常有帮助。在实际应用中，日志记录通常会借助于专门的日志库来实现。

总之，通过上述方法进行错误检测和处理，可以使程序在发生错误时仍能保持稳定运行，有效避免因错误处理不当导致的程序崩溃。

5.2 字符串处理方法

5.2.1 字符串的基本操作

在C语言中，字符串是以字符数组的形式存储，以空字符(‘\0’)作为结束标志。C标准库提供了一系列处理字符串的函数，这些函数定义在头文件 <string.h> 中。下面是一些常见的字符串操作函数及其用法：

• strcpy() ：用于复制字符串。它会将源字符串复制到目标字符串中，包括结尾的空字符。

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

int main() {
    char src[] = "Hello";
    char dest[6]; // 确保有足够的空间存储复制的字符串

    strcpy(dest, src);
    printf("Copied string: %s\n", dest);
    return 0;
}

• strncpy() ：与 strcpy() 类似，但允许指定复制的最大字符数。这在防止缓冲区溢出方面非常有用。

char src[] = "Hello";
char dest[6];

strncpy(dest, src, 5); // 只复制5个字符
dest[5] = '\0'; // 确保目标字符串以空字符结尾

• strcat() ：用于连接字符串。它将源字符串追加到目标字符串的末尾。

char str1[20] = "Hello, ";
char str2[] = "World!";

strcat(str1, str2);
printf("Concatenated string: %s\n", str1);

• strcmp() ：用于比较两个字符串。如果两个字符串相等，则返回0；如果第一个不匹配的字符在第一个字符串中的ASCII值大于在第二个字符串中，返回正值；否则返回负值。

char str1[] = "Hello";
char str2[] = "World";

int result = strcmp(str1, str2);
if (result < 0) {
    printf("%s is less than %s\n", str1, str2);
} else if (result > 0) {
    printf("%s is greater than %s\n", str1, str2);
} else {
    printf("%s is equal to %s\n", str1, str2);
}

字符串操作是C语言程序中非常常见的需求，掌握这些基本的字符串处理函数对于编写高效且安全的代码至关重要。错误使用字符串处理函数可能会导致安全漏洞，如缓冲区溢出，因此开发者在使用这些函数时需要格外小心。

5.2.2 字符串函数的深入应用

在C语言中，字符串处理不仅限于基本的操作，高级的字符串处理函数如 strtok() 、 strstr() 等也非常重要，它们扩展了程序处理字符串的能力。

• strtok() ：用于分割字符串。它根据指定的分隔符集合来分割源字符串，并返回第一个分割得到的子字符串。该函数通常用于分割以空格、标点等分隔的文本数据。

char str[] = "This is a test string.";
char *tok;

tok = strtok(str, " ");
printf("First token: %s\n", tok);
tok = strtok(NULL, " ");
printf("Second token: %s\n", tok);

• strstr() ：用于查找子字符串在目标字符串中的位置。如果找到子字符串，它返回指向第一次出现子字符串的指针；否则，返回NULL。

char str[] = "This is a string";
char substr[] = "is a";
char *result;

result = strstr(str, substr);
if (result != NULL) {
    printf("Substring '%s' found at position %ld\n", substr, result - str);
} else {
    printf("Substring '%s' not found\n", substr);
}

• strchr() 和 strrchr() ：分别用于查找字符在字符串中第一次和最后一次出现的位置。

char str[] = "This is a string";
char *result;

result = strchr(str, 'i');
if (result != NULL) {
    printf("First occurrence of 'i' is at position %ld\n", result - str);
}

result = strrchr(str, 'i');
if (result != NULL) {
    printf("Last occurrence of 'i' is at position %ld\n", result - str);
}

在进行字符串处理时，一个重要的考虑是处理边界情况，例如检查字符串是否为空或处理字符串末尾的空字符。熟练使用字符串处理函数，并能够根据具体的需求选择合适的函数，是C语言高级开发人员的重要技能之一。

通过综合运用字符串处理函数，可以开发出更为复杂和高效的应用程序。例如，文本处理程序、数据分析工具和用户界面的构建等。在实践中，开发者应当根据实际需求灵活运用这些函数，同时还要注意防范潜在的安全风险，确保程序的稳定和安全。

6. 内存管理与计算器实践

内存管理在C语言程序设计中扮演着至关重要的角色。一个好的程序员必须学会合理分配和释放内存，以保证程序的稳定性和效率。本章节将探讨内存管理的技术，并通过计算器的逻辑结构设计案例来实践这些概念。

6.1 内存管理技术

6.1.1 动态内存分配和释放

在C语言中，动态内存分配是通过 malloc() 、 calloc() 、 realloc() 和 free() 这几个函数来实现的。它们在程序运行时分配和管理内存。

#include <stdlib.h>

int main() {
    int *ptr = (int*)malloc(sizeof(int)); // 分配内存
    if (ptr != NULL) {
        *ptr = 10; // 使用内存
    }
    free(ptr); // 释放内存
    return 0;
}

• malloc(size_t size) 分配 size 字节的内存，并返回指向它的指针。
• calloc(size_t num, size_t size) 为 num 个 size 字节的对象分配内存，并初始化为零。
• realloc(void *ptr, size_t size) 改变之前分配的内存块的大小。
• free(void *ptr) 释放之前分配的内存。

动态分配的内存需要适时释放，否则会导致内存泄漏。

6.1.2 内存泄漏的预防和检测

内存泄漏是指程序中已分配的内存由于错误操作或忘记释放，导致无法回收。预防内存泄漏的方式包括：

• 使用智能指针或RAII（Resource Acquisition Is Initialization）模式来自动管理资源。
• 代码审查和使用静态代码分析工具，如Valgrind，进行内存泄漏检测。
• 在单元测试中加入内存泄漏检测逻辑。

6.2 计算器的逻辑结构设计

6.2.1 计算器需求分析与功能规划

在设计一个计算器之前，首先需要明确其需求，包括支持的操作（如加、减、乘、除）、用户界面、输入输出方式等。计算器的功能规划应涵盖：

• 简单的命令行输入输出。
• 支持浮点数运算。
• 提供基本的错误处理机制。

6.2.2 计算器代码实现与测试

计算器的实现可以分为几个部分：用户输入处理、运算逻辑实现、结果输出。以下是一个简单的计算器实现示例代码：

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

// 函数声明
double add(double a, double b);
double subtract(double a, double b);
double multiply(double a, double b);
double divide(double a, double b);

int main() {
    char operator;
    double firstNumber, secondNumber;

    printf("输入运算符 (+, -, *, /): ");
    scanf("%c", &operator);

    printf("输入两个操作数: ");
    scanf("%lf %lf", &firstNumber, &secondNumber);

    switch (operator) {
        case '+':
            printf("%.1lf + %.1lf = %.1lf\n", firstNumber, secondNumber, add(firstNumber, secondNumber));
            break;
        case '-':
            printf("%.1lf - %.1lf = %.1lf\n", firstNumber, secondNumber, subtract(firstNumber, secondNumber));
            break;
        case '*':
            printf("%.1lf * %.1lf = %.1lf\n", firstNumber, secondNumber, multiply(firstNumber, secondNumber));
            break;
        case '/':
            if(secondNumber != 0.0)
                printf("%.1lf / %.1lf = %.1lf\n", firstNumber, secondNumber, divide(firstNumber, secondNumber));
            else
                printf("除数不能为0。\n");
            break;
        default:
            printf("错误的运算符\n");
    }

    return 0;
}

// 运算函数定义
double add(double a, double b) { return a + b; }
double subtract(double a, double b) { return a - b; }
double multiply(double a, double b) { return a * b; }
double divide(double a, double b) { return a / b; }

这段代码展示了如何通过函数封装不同的运算逻辑，并提供了一个简单的用户界面进行输入输出。测试计算器时，要确保覆盖各种输入情况，包括边界条件和异常情况。

通过本章内容，我们学习了内存管理的基本技术，并通过计算器的设计与实现，加深了对C语言在实际应用中的理解。这种实践是提升编程技能不可或缺的一部分。

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

简介：创建计算器是C语言初学者的入门级项目，涉及C语言基础语法和控制结构。本指南涵盖了从输入输出、变量定义、运算符优先级到条件语句、循环语句、函数定义、错误处理、字符串处理、内存管理和逻辑结构等多个关键知识点。学习这一实践项目将加深对C语言的理解，并提供对编程逻辑和结构的直观认识。

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