当前位置：文江博客话题详情

embedded c++

C++ 在嵌入式系统中的使用

发布于 2024-07-05 03:08:27 字数 173 浏览 5 评论 0 原文

在嵌入式系统中应避免使用 C++ 的哪些功能？

请按以下原因对答案进行分类：

内存使用
代码大小
速度
可移植性

编辑：让我们使用具有 64k RAM 的 ARM7TDMI 作为目标来控制答案的范围。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

你げ笑在眉眼 2024-07-12 03:08:27

ATMega GCC 3.something 的一个特殊问题让我感到惊讶：当我向我的一个类添加虚拟 ember 函数时，我必须添加一个虚拟析构函数。此时，链接器请求运算符delete(void *)。我不知道为什么会发生这种情况，并为该运算符添加一个空定义解决了问题。

回复收藏 0 原文

触ぅ动初心 2024-07-12 03:08:27

请注意，异常的成本取决于您的代码。在我分析的一个应用程序（ARM968 上的一个相对较小的应用程序）中，异常支持使执行时间增加了 2%，并且代码大小增加了 9.5 KB。在此应用程序中，只有在发生严重错误的情况下才会引发异常（即从未在实践中发生），这使得执行时间开销非常低。

回复收藏 0 原文

度的依靠╰つ 2024-07-12 03:08:27

使用 ARM7 并假设您没有外部 MMU，动态内存分配问题可能更难调试。我将“明智地使用 new/delete/free/malloc”添加到指南列表中。

回复收藏 0 原文

爱殇璃 2024-07-12 03:08:27

如果您使用的是 ARM7TDMI，请避免未对齐的内存访问所有费用。

基本的 ARM7TDMI 内核没有对齐检查，并且在执行未对齐读取时将返回旋转数据。某些实现具有用于引发 ABORT 异常的附加电路，但如果您没有这些实现之一，则查找由于未对齐访问而导致的错误将非常痛苦。

示例：

const char x[] = "ARM7TDMI";
unsigned int y = *reinterpret_cast<const unsigned int*>(&x[3]);
printf("%c%c%c%c\n", y, y>>8, y>>16, y>>24);

在 x86/x64 CPU 上，将打印“7TDM”。
在 SPARC CPU 上，这会转储带有总线错误的核心。
在 ARM7TDMI CPU 上，这可能会打印类似“7ARM”或“ITDM”的内容，假设变量“x”在 32 位边界上对齐（这取决于“x”所在的位置以及正在使用的编译器选项）等）并且您正在使用小端模式。这是未定义的行为，但几乎可以保证它不会按您想要的方式工作。

If you're using an ARM7TDMI, avoid unaligned memory accesses at all costs.

The basic ARM7TDMI core does not have alignment checking, and will return rotated data when you do an unaligned read. Some implementations have additional circuitry for raising an ABORT exception, but if you don't have one of those implementations, finding bugs due to unaligned accesses is very painful.

Example:

const char x[] = "ARM7TDMI";
unsigned int y = *reinterpret_cast<const unsigned int*>(&x[3]);
printf("%c%c%c%c\n", y, y>>8, y>>16, y>>24);

On an x86/x64 CPU, this prints "7TDM".
On a SPARC CPU, this dumps core with a bus error.
On an ARM7TDMI CPU, this might print something like "7ARM" or "ITDM", assuming that the variable "x" is aligned on a 32-bit boundary (which depends on where "x" is located and what compiler options are in use, etc.) and you are using little-endian mode. It's undefined behavior, but it's pretty much guaranteed not to work the way you want.

回复收藏 0 原文

挽袖吟 2024-07-12 03:08:27

在大多数系统中，您不想使用new / delete，除非您使用从自己的托管堆中提取的自己的实现覆盖了它们。是的，它会起作用，但你正在处理一个内存受限的系统。

回复收藏 0 原文

送君千里 2024-07-12 03:08:27

我不会说这有一个硬性规定；这在很大程度上取决于您的应用程序。嵌入式系统通常是：

可用内存量受到更多限制
通常在较慢的硬件上运行
往往更接近硬件，即以某种方式驱动它，例如摆弄寄存器设置。

就像任何其他开发一样，您应该平衡您提到的所有要点与您给出/派生的要求。

回复收藏 0 原文

慕巷 2024-07-12 03:08:27

关于代码膨胀，我认为罪魁祸首更有可能是内联而不是模板。

例如：

// foo.h
template <typename T> void foo () { /* some relatively large definition */ }

// b1.cc
#include "foo.h"
void b1 () { foo<int> (); }

// b2.cc
#include "foo.h"
void b2 () { foo<int> (); }

// b3.cc
#include "foo.h"
void b3 () { foo<int> (); }

链接器很可能会将“foo”的所有定义合并到单个翻译单元中。因此，“foo”的大小与任何其他命名空间函数的大小没有什么不同。

如果您的链接器不这样做，那么您可以使用显式实例化来为您执行此操作：

// foo.h
template <typename T> void foo ();

// foo.cc
#include "foo.h"
template <typename T> void foo () { /* some relatively large definition */ }
template void foo<int> ();        // Definition of 'foo<int>' only in this TU

// b1.cc
#include "foo.h"
void b1 () { foo<int> (); }

// b2.cc
#include "foo.h"
void b2 () { foo<int> (); }

// b3.cc
#include "foo.h"
void b3 () { foo<int> (); }

现在考虑以下内容：

// foo.h
inline void foo () { /* some relatively large definition */ }

// b1.cc
#include "foo.h"
void b1 () { foo (); }

// b2.cc
#include "foo.h"
void b2 () { foo (); }

// b3.cc
#include "foo.h"
void b3 () { foo (); }

如果编译器决定为您内联“foo”，那么您最终将得到“foo”的 3 个不同副本'。看不到模板！

编辑：来自 InSciTek Jeff 的评论，

对您知道仅会使用的函数使用显式实例化，您还可以确保删除所有未使用的函数（与非模板情况）：

// a.h
template <typename T>
class A
{
public:
  void f1(); // will be called 
  void f2(); // will be called 
  void f3(); // is never called
}


// a.cc
#include "a.h"

template <typename T>
void A<T>::f1 () { /* ... */ }

template <typename T>
void A<T>::f2 () { /* ... */ }

template <typename T>
void A<T>::f3 () { /* ... */ }

template void A<int>::f1 ();
template void A<int>::f2 ();

除非您的工具链完全损坏，否则上面的代码将仅生成“f1”和“f2”的代码。

Regarding code bloat, I think the culprit is much more likely to be inline than templates.

For example:

// foo.h
template <typename T> void foo () { /* some relatively large definition */ }

// b1.cc
#include "foo.h"
void b1 () { foo<int> (); }

// b2.cc
#include "foo.h"
void b2 () { foo<int> (); }

// b3.cc
#include "foo.h"
void b3 () { foo<int> (); }

The linker most likely will merge all the definitions of 'foo' into a single translation unit. Therefore the size of 'foo' is no different to that of any other namespace function.

If your linker doesn't do this, then you can use an explicit instantiation to do that for you:

// foo.h
template <typename T> void foo ();

// foo.cc
#include "foo.h"
template <typename T> void foo () { /* some relatively large definition */ }
template void foo<int> ();        // Definition of 'foo<int>' only in this TU

// b1.cc
#include "foo.h"
void b1 () { foo<int> (); }

// b2.cc
#include "foo.h"
void b2 () { foo<int> (); }

// b3.cc
#include "foo.h"
void b3 () { foo<int> (); }

Now consider the following:

// foo.h
inline void foo () { /* some relatively large definition */ }

// b1.cc
#include "foo.h"
void b1 () { foo (); }

// b2.cc
#include "foo.h"
void b2 () { foo (); }

// b3.cc
#include "foo.h"
void b3 () { foo (); }

If the compiler decides to inline 'foo' for you then you will end up with 3 different copies of 'foo'. No templates in sight!

EDIT: From a comment above from InSciTek Jeff

Using explicit instantiations for the functions that you know will be used only, you can also ensure that all unused functions are removed (which may actually reduce the code size compared with the non template case):

// a.h
template <typename T>
class A
{
public:
  void f1(); // will be called 
  void f2(); // will be called 
  void f3(); // is never called
}


// a.cc
#include "a.h"

template <typename T>
void A<T>::f1 () { /* ... */ }

template <typename T>
void A<T>::f2 () { /* ... */ }

template <typename T>
void A<T>::f3 () { /* ... */ }

template void A<int>::f1 ();
template void A<int>::f2 ();

Unless your tool chain is completely broken, the above will generate code only for 'f1' and 'f2'.

回复收藏 0 原文

浮生未歇 2024-07-12 03:08:27

时间函数通常依赖于操作系统（除非您重写它们）。使用您自己的函数（特别是如果您有 RTC）

只要您有足够的代码空间就可以使用模板 - 否则不要使用它们

异常不是很可移植还有

printf 函数不

如果速度是问题，也许你应该使用自己的容器而不是 STL（例如 std::map 容器以确保键相等，与 'less' 进行 2 (yes 2) 比较运算符（ a [小于] b == false && b [小于] a == false 意味着 'less' 是 std::map 类接收的唯一比较参数（而不是）。这可能会导致关键例程中的一些性能损失，

异常会增加代码大小（您可以确定，有时甚至

可能需要重写较大的代码时性能也会受到影响）。还因为它们在很多方面都依赖于操作系统（特别是在处理线程安全内存分配时）

在“未知”环境中不是线程安全的。

malloc 使用 _end 变量（通常在链接器脚本中声明）来分配内存，但这有时应使用 Thumb 而不是 Arm 模式。它可以提高性能。

因此，对于 64k 内存，我认为 C++ 及其一些出色的功能（STL、异常等）可能有点过分了。我肯定会选择C。