如何使对象获取并存储任意但编译时已知大小的数组？

Question

背景

对于嵌入式项目，我想要一个带有结构列表的类。这个列表在编译时是已知的，所以我不应该为此求助于动态内存分配。

但是，如何创建一个封装此数组的结构/类，而不必将其大小用作模板参数？

模板

我的第一个想法就是这样做：

struct Point {
    const uint16_t a;
    const double b;
};

template<size_t n>
struct Profile {
    Array<Point, n> points;

    Profile(const Array<Point, n> &points) : points(points) {}
};

这里，Profile 是存储/封装点数组（2 成员结构）的类。 n，数组的大小，是模板参数。

我正在使用数组的this 实现，类似于std::array，顺便说一句，因为我无法访问这个嵌入式平台上的 STL。

但是，没有，我有另一个使用这个 Profile 的类，现在也必须对其进行模板化，因为 Profile 是使用数组大小​​进行模板化的：

template<size_t n>
class Runner {
private:
    const Profile<n> profile;
public:
    Runner(const Profile<n> &profile) : profile(profile) {};

    void foo() {
        for(auto point : profile.points) {
            // do something
        }
    }
};

可以看出，这个Runner 类在Profile 上运行并对其进行迭代。必须模板化Runner 本身并不是什么大问题，但是这个Runner 又被我项目中的另一个类使用，因为这个另一个类调用Runner::foo()。现在我也必须为该类模板！以及使用该类的类等。

这已经失控了！最初只使用一个模板参数来指定大小，现在在我的整个应用程序中传播。因此，我认为这不是一个好的解决方案。

问题

有没有办法在Profile 或Runner 中“隐藏”数组的大小？ Runner 只需要对其进行迭代，因此大小原则上应该只影响它的实现，而不影响它的公共接口。不过，我该怎么做呢？

另外，我是否可以完全避免手动指定n，而只需将数组传递给Profile 的构造函数并让编译器计算出它有多大？当然是在编译时。我觉得这应该是可能的（考虑到这个数组在编译时是已知的），但我不知道具体如何。

其他方法

宏

我可以写一个类似的宏

#define n 12

并将其包含在Profile.h 和我实例化Profile 的地方。不过这感觉很脏，我想避免使用宏。

矢量

我可以通过使用 std::vector（或等效项）来避免这种大惊小怪，但这是在运行时分配在堆上的，我想在这里避免这种情况，因为它不应该是必需的。

Answer 1

有没有办法在 Profile 或 Runner 中“隐藏”数组的大小？

是的。解决方案是间接的。您可以指向它，而不是直接存储对象。你不需要知道你指向的东西的大小。

一个方便的解决方案是指向动态存储（例如std::vector），因为它允许您将动态大小的对象的生命周期“绑定”到成员。这通常不是必需的，您可以改用自动存储。但是，在这种情况下，您无法绑定指向对象的生命周期，并且您必须非常小心，不要让指向对象在停止使用之前被销毁。

间接可以在您喜欢的任何级别完成。如果您在最低级别执行此操作，您只需将数组存储在Profile 之外。事实上，如果该配置文件所做的只是包含一个数组，那么您就不需要一个类。使用通用的span：

struct Runner {
    span<const Point> profile;
    void foo() {
        for(auto point : profile) {
            // do something
        }
    }
};

Point points[] {
    // ... number of points doesn't matter
};
Runner runner {
    .profile = points,
};

---

span，我的意思是 std::span。如果您不能使用标准库，请使用其他实现。它基本上只是一个指针和大小，带有方便的模板构造函数。

---

为了澄清，你可以选择任何两个，但你不能同时拥有这三个：

1. 绑定到类的数组的生命周期（安全）
2. 没有编译时常量大小
3. 无动态存储

• 1,2 (no 3) = std::vector, RAII
• 1,3 (no 2) = std::array，模板，无间接
• 2,3 (no 1) = std::span，注意生命周期

Answer 2

我将对此评论进行扩展：

这个想法是，无论大小，Runner 都会获取配置文件。 Runner 需要对其进行迭代，但除此之外，它的行为始终相同。使用 Runner 并调用 Runner::foo() 的类不需要知道大小。模板化 Runner 的问题是使用 Runner 的类也需要模板化，使用它的类等等。

仅当类直接使用模板化的Runner 时才会出现问题。它具有比实际需要更多的依赖项。如果它不需要知道数组的大小，那么它不应该知道数组的大小。如果运行时多态性是一个选项，您可以添加一个允许访问数组元素的基类，但不需要了解有关数组大小的任何信息。以下仅为示意图：

#include <iostream>

struct RunnerInterface {
    virtual int* begin() = 0;
    virtual int* end() = 0;
    virtual ~RunnerInterface(){}
};

template <unsigned size>
struct Runner : RunnerInterface {
    int data[size];
    int* begin() override { return data; }
    int* end() override { return data+size; } // pointer one past the end if fine (it won't get dereferenced)
};

void foo(RunnerInterface& ri) {
    for (auto it = ri.begin(); it != ri.end(); ++it){
        *it = 42;
    }
}

void bar(RunnerInterface& ri){
    for (auto it = ri.begin(); it != ri.end(); ++it){
        std::cout << *it;
    }
}

int main() {
    Runner<42> r;
    foo(r);
    bar(r);
}

现在，如果一个类需要一个 Runner 成员，它们存储一个 std::unique_ptr<RunnerInterface> 并且仅在构造时您需要决定数组的大小（尽管您仍然需要在某个地方决定大小）。