使用模板静态分配缓冲区

Question

我想要一些类包含不同大小的数组。我希望静态地分配它，因为它是为嵌入式系统设计的。我能想到的唯一好的解决方案就是使用模板。

但是，我希望使用相同的类类型来访问这些对象。

到目前为止，这是我的解决方案。

class Base
{
public:
    Base(char* _data, int _size) :
        data(_data), size(_size) {}

    char* getData(void)
    {
        return data;
    }

    int getSize(void)
    {
        return size;
    }

protected:
    char* const data;
    const int size;
};

template <int sz>
class Foo : public Base
{
public:
    Foo() : Base(dataBuff, sizeof(dataBuff)) {}
private:
    char dataBuff[sz];
};

// Here I can access every template that inherits Base class
void printFoo(Base* base)
{
    std::cout << base->getData() << std::endl;
    std::cout << "size is " << base->getSize() << std::endl;
}

int main(void)
{
    Foo<20> foo;

    char* data = foo.getData();
    strcpy(data, "Hello world");
    printFoo(&foo);
    return 0;
}

当然，这样做的原因是基类中有更多用于追加、删除和搜索数据的方法。

这东西有效吗？这是非常基本的东西。

我能有更好的解决方案吗？

编辑:修正错误(错误)。

Answer 1

可能使用std::array (如果可能的话)

您可以使用std::array获得静态分配的缓冲区。它的实现非常类似于您的Foo，它的附加好处是它与任何其他STL容器一样工作。以下是您将如何使用它：

#include <array>
#include <cstring>
#include <iostream>

int main()
{
    std::array<char, 20> foo;
    strcpy(foo.data(), "Hello world");
    std::cout << foo.data() << "\nSize is " << foo.size() << '\n';
}

关于静态分配的

在您的示例中，foo不是静态分配的，而是在堆栈上分配的。您可以在它前面加上static和/或在函数之外声明该变量，以确保它确实是静态分配的。

那么问题是，这是否会为你节省任何记忆。许多嵌入式系统确实允许动态分配堆内存。当然，存在一些与其相关的开销，但优点是您只分配了所需的资源，而对于一个静态大小的数组，您可能需要保留比所需的内存更多的内存。什么是最好的取决于情况。

关于类型擦除

但是，我希望使用相同的类类型来访问这些对象。

在你的示例用法中，我看不出有什么原因。但是，如果您确实需要传递一个指向Base的指针，请考虑不需要继承；您可以有一个单独的类来存储指向数组的指针和大小，比如数组的std::span，特别是字符串的std::string_view。下面是一个与您的示例匹配的使用std::span的示例：

#include <array>
#include <cstring>
#include <iostream>
#include <span>

void printFoo(std::span<char> base)
{
    std::cout << base.data() << "\nSize is " << base.size() << '\n';
}

int main()
{
    std::array<char, 20> foo;
    strcpy(foo.data(), "Hello world");
    printFoo(foo);
}

如果不能在嵌入式系统上使用std::array和/或std::span，我建议您尝试自己实现它们。您的代码已经有部分，您只需要更改一些名称，并且不再将span用作数组的基类。