嵌入式软件：函数式 VS 非函数式编程

函数式编程

软件设计

发布日期: 2025-04-17

文章字数: 1.7k

阅读时长: 6 分

阅读次数:

大家好，我是杂烩君。

本篇我们来分享函数式编程与非函数式编程在嵌入式应用中的对比。

函数式 VS 非函数式编程

函数式编程（或称函数程序设计、泛函编程）是一种编程范式，它将计算视为函数的求值，避免使用共享状态和可变数据，强调函数的纯粹性和不可变性。

在嵌入式应用领域，函数式编程与非函数式编程（如常见的指令式编程）在多个方面存在显著差异，下面将从多个方面对它们进行对比。

1、可测试性

函数式编程：

纯函数的特性使得函数式编程的代码具有很高的可测试性。

由于函数的输出只依赖于输入，测试时只需要提供不同的输入参数并验证输出结果是否符合预期即可，无需考虑复杂的外部环境和状态。

我们在嵌入式软件，有必要进行自测吗？这篇文章中就是使用了函数式编程可测试性高的特点：

非函数式编程：

非函数式编程中存在大量的共享状态和副作用，测试时需要模拟复杂的外部环境和状态，增加了测试的难度和复杂度。

2、可维护性

函数式编程：

代码结构通常围绕函数的组合和复用构建，函数之间的依赖关系清晰，每个函数只负责单一的任务。

这使得代码具有较高的模块化程度，易于理解和维护。

例如，在处理传感器数据时，可以将数据读取、处理等操作分别封装成独立的纯函数，然后通过函数组合完成整个处理流程。

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

// 模拟读取传感器数据
float read_sensor(void) 
{
    srand(time(NULL));
    return (float)rand() / RAND_MAX * 100;
}

// 对传感器数据进行平方处理
float square(float value) 
{
    return value * value;
}

void print_sensor_data(float value) 
{
    printf("Processed sensor data: %f\n", value);
}

int main(void) 
{
    float sensor_value = read_sensor();
    float processed_value = square(sensor_value);
    print_sensor_data(processed_value);
    
    return 0;
}

每个函数都是纯函数，输入和输出明确，不依赖或修改全局状态。
提高了代码的可维护性，例如可以独立测试 square 函数。

非函数式编程：

非函数式编程（如指令式编程）通常使用变量、循环和条件语句来控制程序的执行流程。

代码结构更侧重于描述如何一步步完成任务，可能会涉及到较多的状态变化和副作用。

在处理复杂逻辑时，代码可能会变得冗长和复杂，可读性和可维护性相对较低。

例如，在一个嵌入式控制系统中，使用命令式编程可能会有大量的循环和条件判断来实现不同的控制逻辑，代码的整体结构不够清晰。

上面传感器的例子中，使用非函数式编程的实现方式如：

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

// 模拟读取传感器数据
float sensor_value;
void read_sensor(void) 
{
    srand(time(NULL));
    sensor_value = (float)rand() / RAND_MAX * 100;
}

// 对传感器数据进行平方处理
void square_sensor_data(void) 
{
    sensor_value = sensor_value * sensor_value;
}

void print_sensor_data(void) 
{
    printf("Processed sensor data: %f\n", sensor_value);
}

int main(void) 
{
    read_sensor();
    square_sensor_data();
    print_sensor_data();
    
    return 0;
}

该实现使用全局变量 sensor_value来存储传感器数据，不同函数对其进行读写操作，存在副作用。
代码的可维护性和可测试性较差，因为函数之间的依赖关系不清晰，修改一个函数可能影响其他函数。

3、性能与资源利用

函数式编程：

函数式编程中频繁创建不可变数据的副本和函数调用会增加内存开销和执行时间。

在嵌入式系统中，由于资源有限，这种开销可能会对系统性能产生较大影响。

例如，在一个资源受限的单片机系统中，过多地使用函数式编程可能会导致内存不足或处理速度变慢。此外，一些函数式编程的特性（如递归调用）可能会导致栈溢出等问题。

#include <stdio.h>

#define ARRAY_SIZE 1000

// 函数式递归累加数组元素
int sum_array_recursive(int arr[], int index) 
{
    if (index == 0) 
    {
        return arr[0];
    }
    return arr[index] + sum_array_recursive(arr, index - 1);
}

int main(void) 
{
    int arr[ARRAY_SIZE];
    for (int i = 0; i < ARRAY_SIZE; i++) 
    {
        arr[i] = i;
    }
    int sum = sum_array_recursive(arr, ARRAY_SIZE - 1);
    printf("Sum: %d\n", sum);
    return 0;
}

使用递归的方式累加数组元素，每次递归调用都会在栈上分配新的栈帧。当数组规模较大时，递归调用会导致栈空间的大量使用，可能会引发栈溢出问题。

非函数式编程：

非函数式编程可以直接操作内存和硬件资源，通过合理的优化可以实现较高的性能和资源利用率。

在嵌入式系统中，命令式编程通常可以更好地控制内存分配和释放，减少不必要的开销。

上面累加数组元素的例子中，使用非函数式编程方式的实现：

#include <stdio.h>

#define ARRAY_SIZE 1000

// 非函数式累加数组元素
int sum_array(int arr[], int size) 
{
    int result = 0;
    for (int i = 0; i < size; i++) 
    {
        result += arr[i];
    }
    return result;
}

int main(void) 
{
    int arr[ARRAY_SIZE];
    for (int i = 0; i < ARRAY_SIZE; i++) 
    {
        arr[i] = i;
    }
    int sum = sum_array(arr, ARRAY_SIZE);
    printf("Sum: %d\n", sum);
    return 0;
}

该代码使用简单的循环结构，直接对数组元素进行累加操作。内存使用方面，仅使用了固定大小的数组和一个整型变量来存储结果，没有额外的内存开销。