我有一个没有MMU的微控制器，但我们使用的是C和C ++。
我们避免使用所有动态内存（即没有new SomeClass()或malloc()）和大多数标准库。
半问题0：
根据我的理解，std::array不使用任何动态内存，因此它的用法应该没问题（它只在堆栈上）。看看std::array源代码，它看起来很好，因为它创建了一个c风格的数组，然后围绕该数组包装功能。
我们使用的芯片有1MB的闪存用于存储代码。
问题1：
我担心在std::array中使用模板会导致二进制文件变大，这可能会导致二进制文件超过1MB的代码内存限制。
我想如果你创建一个std::array< int, 5 >的实例，那么对std::array上的函数的所有调用都将占用一定量的代码内存，让我们说X字节的内存。
如果你创建另一个std::array< SomeObject, 5 >实例，然后调用那个std::array的函数，那么这些函数现在会在二进制文件中重复，从而占用更多的代码内存吗？ X字节的内存+ Y字节的内存。
如果是这样，您认为在有限的代码内存容量下生成的代码量是一个问题吗？
问题2：
在上面的例子中，如果你创建了第二个std::array< int, 10 >实例，对函数的调用是否也会复制生成的代码中的函数调用？即使两个实例属于同一类型，int？
std::array被认为是零成本抽象，这意味着编译器应该可以相当优化它。
从任何零成本抽象开始，它可能会导致较小的编译时间，并且如果所需的优化确实不支持零成本，那么它可能会产生小的尺寸或运行时间。
但是，请注意编译器可以在结构的末尾添加填充。由于std::array是一个结构，你应该检查你的平台如何处理std::array，但我非常怀疑你的情况。
拿这个数组和std::array案例：
#include <numeric>
#include <iterator>
template<std::size_t n>
int stuff(const int(&arr)[n]) {
return std::accumulate(std::begin(arr), std::end(arr), 0);
}
int main() {
int arr[] = {1, 2, 3, 4, 5, 6};
return stuff(arr);
}
#include <numeric>
#include <iterator>
#include <array>
template<std::size_t n>
int stuff(const std::array<int, n>& arr) {
return std::accumulate(std::begin(arr), std::end(arr), 0);
}
int main() {
std::array arr = {1, 2, 3, 4, 5, 6};
return stuff(arr);
}
Clang非常支持这种情况。使用std::array或原始数组的所有情况都是以同样的方式处理：
-O2 / -O3阵列和std::array与clang：
main: # @main
mov eax, 21
ret
但是，对于std::array和原始数组情况，GCC似乎在优化它时遇到问题：
-O3与GCC的阵列和std::array：
main:
movdqa xmm0, XMMWORD PTR .LC0[rip]
movaps XMMWORD PTR [rsp-40], xmm0
mov edx, DWORD PTR [rsp-32]
mov eax, DWORD PTR [rsp-28]
lea eax, [rdx+14+rax]
ret
.LC0:
.long 1
.long 2
.long 3
.long 4
然后，它似乎在原始数组的情况下使用-O2更好地优化并且使用std::array失败：
-O2 GCC std::array：
main:
movabs rax, 8589934593
lea rdx, [rsp-40]
mov ecx, 1
mov QWORD PTR [rsp-40], rax
movabs rax, 17179869187
mov QWORD PTR [rsp-32], rax
movabs rax, 25769803781
lea rsi, [rdx+24]
mov QWORD PTR [rsp-24], rax
xor eax, eax
jmp .L3
.L5:
mov ecx, DWORD PTR [rdx]
.L3:
add rdx, 4
add eax, ecx
cmp rdx, rsi
jne .L5
rep ret
-O2 GCC原始阵列：
main:
mov eax, 21
ret
似乎GCC错误的优化-O3，但成功与-O2固定在最近的版本。
在陈述所有这些情况后，您可以看到一个共同的模式：没有关于std::array的信息在二进制文件中输出。没有构造函数，没有operator[]，甚至没有迭代器，也没有算法。一切都是内联的。编译器擅长内联简单的功能。 std::array成员函数通常非常简单。
如果你创建std :: array <SomeObject，5>的另一个实例，然后调用那个std :: array的函数，那么现在每个函数都会在二进制文件中重复，从而占用更多的闪存吗？ X字节的内存+ Y字节的内存。
好吧，您更改了数组包含的数据类型。如果你手动添加所有函数的重载来处理这个额外的情况，那么是的，所有这些新函数可能会占用一些空间。如果您的功能很小，那么它们很有可能被内联并占用更少的空间。正如您在上面的示例中所看到的，内联和常量折叠可能会大大减少二进制大小。
在上面的例子中，如果你创建了第二个std :: array实例，对函数的调用是否也会复制闪存中的函数调用？即使两个实例的类型相同，int？
再取决于它。如果你有许多模板的数量模板，std::array和原始数组都可以“创建”不同的功能。但同样，如果它们被内联，那么就没有重复的担心了。
两者都是原始数组和std::array，你可以将指针传递给数组的开头并传递大小。如果您发现这更适合您的情况，那么使用它，但仍然原始数组和std::array可以做到这一点。对于原始数组，它隐式衰减到指针，并且使用std::array，您必须使用arr.data()来获取指针。