for-loop - 基于范围的 for 循环而不使用标准库

Question

我正在做一个 arduino 项目，我需要为多个数字输出执行相同的任务。由于 arduino 编译器支持 C++11，我想使用基于范围的 for 循环来获得更具可读性的代码。但是，据我所知，在 arduino 上无法访问通常在这种情况下使用的 std 库(如果我在这里错了，请纠正我)。所以我的问题是，是否有好的方法可以在没有 std 库的情况下使用基于范围的 for 循环。我的(简化的)工作代码如下所示:

static const byte OUTPUT_GROUP1[] = {4};
static const byte OUTPUT_GROUP2[] = {5, 6, 7};
static const byte *OUTPUTS[] = {OUTPUT_GROUP1, OUTPUT_GROUP2};

static const uint32_t MILLIS_GROUP1[] = {1000};
static const uint32_t MILLIS_GROUP2[] = {5000, 2000, 3000};
static const uint32_t *MILLIS[] = {MILLIS_GROUP1, MILLIS_GROUP2};

static const size_t GROUP_SIZES[] = {1, 3};

void loop() {
    for (size_t group = 0; group < 2; ++group) {
        for (size_t i = 0; i < GROUP_SIZES[group]; ++i) {
            digitalWrite(OUTPUTS[group][i], HIGH);
            delay(MILLIS[group][i]);
            digitalWrite(OUTPUTS[group][i], LOW);
        }
    }
}

因此，我想将两组输出分开。我的主要目标是摆脱变量 GROUP_SIZES，因为每组输出的数量可能会改变，而忘记更新 GROUP_SIZES 是错误的来源。为此，我需要完成两件事。首先，我需要遍历嵌套列表，通常我可能会使用 std::vector 来解决这个问题。其次，我需要同时遍历两个范围，以访问毫秒延迟。这可能是 done使用 std 或 boost。但是，在 arduino 上，似乎没有简单的方法可以自己编写很多魔法。有没有一种简单的方法可以让它正常工作？

Answer 1

此答案中的代码示例仅在您以 C++17 模式编译时才有效 - 请参阅答案末尾的操作方法

---

首先，我建议稍微重组数据。您有一个输出 pin 和一个相应的 millis 时间，您现在将它们存储在单独的数组中。我会把它们放在 struct 中:

struct Output {
    byte pin;
    uint32_t ms;
};

您还需要一个可以存储对象并具有 begin() 的容器和 end()成员函数。我把一个胚胎放在一起，staticvector ，这是最糟糕的 std::vector和 std::array结合 - 但它很简单。我没有让它更像 std::array 的原因是它应该能够存储 staticvector 的数组大小不一。不让它更像std::vector的原因是因为它需要更多的代码。

为了更容易理解，我从 https://cppreference.com/ 中复制了一些标准模板的可能实现。并将它们放在自己的命名空间中。您可以在 https://cppreference.com/ 上阅读有关模板的信息如果他们不熟悉。

namespace xyz {
template<class T> struct remove_reference      {using type = T;};
template<class T> struct remove_reference<T&>  {using type = T;};
template<class T> struct remove_reference<T&&> {using type = T;};
template<class T>
using remove_reference_t = typename remove_reference<T>::type;

template<class T>
constexpr T&&  forward(remove_reference_t<T>& t) noexcept { return static_cast<T&&>(t); }
template<class T>
constexpr T&&  forward(remove_reference_t<T>&& t) noexcept { return static_cast<T&&>(t); }

template<class T>
constexpr remove_reference_t<T>&&  move(T&& t) noexcept {
    return static_cast<remove_reference_t<T>&&>(t);
}

template<class T, class U = T>
constexpr T exchange(T& obj, U&& new_value) {
    T old_value = move(obj);
    obj = forward<U>(new_value);
    return old_value;
}
} // namespace xyz

有了这些辅助模板，实际的容器可能看起来像这样:

template<class T>
class staticvector {
private:
    size_t len = 0;
    T* data = nullptr;

public:
    // a constructor taking one or more T's and storing them in "data"
    template<class U, class... V>
    constexpr staticvector(U&& u, V&&... vs) :
        len(sizeof...(V) + 1),
        data{new T[sizeof...(V) + 1]{xyz::forward<U>(u), xyz::forward<V>(vs)...}}
    {}

    // copy constructor
    staticvector(const staticvector& rhs) :
        len(rhs.len),
        data(new T[len])
    {
        auto rhs_it = rhs.data;
        for(auto it = data, end = data + len; it != end; ++it, ++rhs_it) {
            *it = *rhs_it;
        }
    }

    // move constructor
    staticvector(staticvector&& rhs) noexcept :
        len(rhs.len), data(xyz::exchange(rhs.data, nullptr))
    {}

    // implement this if you wish
    staticvector& operator=(const staticvector&) = delete; // copy assignment
    
    // move assignment
    staticvector& operator=(staticvector&& rhs) noexcept {
        len = rhs.len;
        // this could use `std::swap(data, rhs.data)`
        auto *tmp = data;        
        data = rhs.data;
        rhs.data = tmp;
    }

    ~staticvector() { delete[] data; } // destructor

    size_t size() const { return len; }

    // subscript operator
    const T& operator[](size_t idx) const { return data[idx]; }
    T& operator[](size_t idx) { return data[idx]; }
    
    // iterator support
    using const_iterator = const T*;
    using iterator = T*;

    const_iterator cbegin() const { return data; }
    const_iterator cend() const { return data + len; }
    const_iterator begin() const { return cbegin(); }
    const_iterator end() const { return cend(); }
    iterator begin() { return data; }
    iterator end() { return data + len; } 
};

现在您可以创建一个 staticvector包含 Output对象以及包含此类容器的容器。

using OutputGroup = staticvector<Output>; // a convenience alias

// All your arrays put into a container of containers
static const staticvector<OutputGroup> OUTPUTS{
    OutputGroup{Output{4, 1000}},
    OutputGroup{Output{5, 5000}, Output{6, 2000}, Output{7, 3000}}
};

void loop() {

    // Two range-based for loops:
    for (const OutputGroup& group : OUTPUTS) {

        // structured bindings from each Output object in `group`
        for (auto[pin, ms] : group) {
            digitalWrite(pin, HIGH);
            delay(ms);
            digitalWrite(pin, LOW);
        }
    }
}

Demo

---

在 Arduino 项目中使用 C++17

当前的 Arduino IDE 使用 g++ 7.3.0并支持 C++17——但设置起来有点麻烦。

• 查找并编辑 platform.txt - 我在 <installation_directory>/hardware/avr/1.8.3 中找到了它但它可能会有所不同。
• 找到以compiler.cpp.flags= 开头的行
• 更改 -std=gnu++11至 -std=gnu++17在那条线上。

重要说明:使用 delete[] 的程序(如上)在 C++17 模式下将无法链接，因为 arduino 库不包含 operator delete[](void* ptr, size_t) ，甚至在 Arduino IDE 2.0-beta 中也是如此。

目前的解决方法似乎是将您自己的添加到项目中:

void operator delete[](void* ptr, size_t) noexcept { free(ptr); }

通过上述修复，为 Uno 编译的上述程序具有以下统计信息:

Sketch uses 2052 bytes (6%) of program storage space. Maximum is 32256 bytes.
Global variables use 43 bytes (2%) of dynamic memory, leaving 2005 bytes for local variables. Maximum is 2048 bytes.