Question

我正在为嵌入式设备开发功能，需要检查电源是否打开。我遇到的问题是，在一种硬件版本中，由于硬件错误，两个电源相互依赖。

我在一个文件中具有此功能：

bool sensor_power_supply_is_on() {
    if (is_spi_shared_between_sensors_and_flash() == true) {
        return (m_sensor_power.state == 1) && flash_power_supply_is_on();
    }

    return (m_sensor_power.state == 1);
}

和另一个：

bool flash_power_supply_is_on() {
    if (is_spi_shared_between_sensors_and_flash() == true) {
        return (m_flash_power.state == 1) && sensor_power_supply_is_on();
    }

    return (m_flash_power.state == 1);
}

如果我在is_spi_shared_between_sensors_and_flash()返回true时使用此代码，则这些函数将以递归方式调用它们。

如何解决这种依赖性？我以为我可以做一些包装功能，但我真的想不起来怎么做。

编辑：问题不在于前向声明，而在于如何重组代码以避免无限递归。

编辑：我想将m_变量保持静态（每个文件专用）。为了解决这个问题，我可以创建一个getter函数，但是我也不想这样做，因为其他模块不一定知道flash_power_state = x的含义。

Answer 1

最后，我决定创建另一个像这样的函数：

bool sensor_power_supply_is_on() {
    return (m_sensor_power.state == 1);
}

bool sensor_power_supply_is_ready() {
    if (is_spi_shared_between_sensors_and_flash() == true) {
        return sensor_power_supply_is_on() && flash_power_supply_is_on();
    }

    return sensor_power_supply_is_on();
}

Flash文件中有相同内容。

bool flash_power_supply_is_on() {
    return (m_flash_power.state == 1);
}

bool flash_power_supply_is_ready() {
    if (is_spi_shared_between_sensors_and_flash() == true) {
        return flash_power_supply_is_on() && sensor_power_supply_is_on();
    }

    return flash_power_supply_is_on();
}

Answer 2

也许尝试将每个函数限制为最大递归运行次数

bool flash_power_supply_is_on(int n) {
    if (n) {
        if (is_spi_shared_between_sensors_and_flash() == true) {
            return (m_flash_power.state == 1) && sensor_power_supply_is_on(n - 1);
            //                                                             ^^^^^
        }
        return (m_flash_power.state == 1);
    } else {
        return 0;
    }
}

然后您可以用if (flash_power_supply_is_on(512)) /* do something */;

来称呼它

Answer 3

如果is_spi_shared_between_sensors_and_flash()为true，则两个函数都调用另一个函数，在这种情况下，这等于为m_<the other>_power.state添加了额外的检查：

只需：

bool sensor_power_supply_is_on() {
    bool retval = m_sensor_power.state == 1;

    if (is_spi_shared_between_sensors_and_flash()) {
        return retval && (m_flash_power.state == 1);
    }

    return retval;
}

bool flash_power_supply_is_on() {
    bool retval = m_flash_power.state == 1;

    if (is_spi_shared_between_sensors_and_flash()) {
        return retval && (m_sensor_power.state == 1);
    }

    return retval;
}

Answer 4

如何使用结构成员m_flash_power.state代替函数flash_power_supply_is_on()：

bool sensor_power_supply_is_on() {
    if (is_spi_shared_between_sensors_and_flash() == true) {
        return (m_sensor_power.state == 1) && (m_flash_power.state == 1);     // Use struct instead of function call
    }
    return (m_sensor_power.state == 1);
}

Answer 5

这是您需要的吗？

bool sensor_power_supply_is_on() {
    if (is_spi_shared_between_sensors_and_flash() == true) {
        return (m_sensor_power.state == 1) && (m_flash_power.state == 1);
    }

    return (m_sensor_power.state == 1);
}

bool flash_power_supply_is_on() {
    if (is_spi_shared_between_sensors_and_flash() == true) {
        return (m_flash_power.state == 1) && (m_sensor_power.state == 1);
    }

    return (m_flash_power.state == 1);
}

Answer 6

由于这些功能非常简单，因此只需对每个功能进行两项检查即可：

bool sensor_power_supply_is_on() {
    boot ret = m_sensor_power.state == 1
    if (is_spi_shared_between_sensors_and_flash() == true) {
        ret &= m_flash_power.state == 1;
    }

    return ret;
}

类似于第二个功能。

如何修复函数之间的循环依赖关系？

6 个答案: