Contraintes de l’embarqué : sans RTTI ni exceptions
Travailler avec les sous-ensembles courants de l’embarqué qui désactivent RTTI et les exceptions
Contraintes de l’embarqué : sans RTTI ni exceptions est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.
C++ embarqué
Les systèmes embarqués sont soumis à des contraintes : RAM limitée, absence de MMU et échéances temps réel. Le sous-ensemble C++ « autonome » supprime les parties du langage trop coûteuses.
Pourquoi pas de RTTI ?
RTTI (informations de type à l'exécution) prend en charge dynamic_cast et typeid. Chaque classe polymorphe contient un pointeur supplémentaire ; les tables RTTI augmentent la taille du code. Désactivez-le avec -fno-rtti.
Pourquoi pas d'exceptions ?
Les exceptions nécessitent des tables de déroulement de pile et un support à l'exécution, ce qui augmente la taille du code et rend la temporisation imprévisible. De nombreux codes embarqués utilisent -fno-exceptions.
g++ -fno-rtti -fno-exceptions main.cppGestion des erreurs sans exceptions
Utilisez :
- des codes de retour (
std::expected,std::optional, des énumérations d'erreurs) - des paramètres de sortie pour les résultats
- std::error_code pour les erreurs système
Types de résultat
C++23 std::expected<T, E> représente soit une valeur, soit une erreur, à la manière de Result en Rust. De nombreux projets embarqués utilisent déjà un type Result personnalisé.
std::expected<int, ErrorCode> parse(const char* s);
if (auto r = parse("42"); r) use(*r);
else log_error(r.error());Éviter l'allocation dynamique
La fragmentation du tas est un véritable fléau pour le temps réel. Le code embarqué interdit souvent new en dehors du démarrage. Utilisez :
- l'allocation sur la pile
- les tableaux statiques
- les pools mémoire
- les allocateurs adaptés à l'embarqué
Schémas de mémoire statique
Réservez la mémoire à la compilation ou au démarrage.
template <typename T, size_t N>
class StaticVector {
alignas(T) char storage_[sizeof(T) * N];
size_t size_ = 0;
public:
void push_back(const T& v);
// ...
};Polymorphisme à la compilation
Remplacez si possible les fonctions virtuelles par des modèles ou par CRTP : pas de table virtuelle ni d'appels indirects.
template <typename Derived>
class Base {
public:
void process() { static_cast<Derived*>(this)->process_impl(); }
};
class Concrete : public Base<Concrete> {
public:
void process_impl() { /* ... */ }
};Bibliothèque standard autonome
Le sous-ensemble C++ autonome exclut la majeure partie de <iostream>, la gestion des fils d'exécution et l'allocation dynamique. La norme définit explicitement ce qui est disponible.
ETL : bibliothèque de modèles pour systèmes embarqués
La bibliothèque de modèles pour systèmes embarqués (ETL) fournit des conteneurs semblables à ceux de la STL, avec une taille déterministe et sans allocation dynamique.
Contraintes de taille du code
Utilisez -Os pour optimiser la taille, -flto pour l'optimisation à l'édition des liens, et -ffunction-sections -fdata-sections -Wl,--gc-sections pour supprimer le code inutilisé.
Cas réels : astromobiles martiennes et voitures
Le C++ est largement utilisé dans les systèmes embarqués critiques pour la sécurité, notamment dans l'automobile (AUTOSAR), l'aérospatiale (MISRA) et le secteur médical (IEC 62304). Les normes de codage restreignent encore davantage le langage.
Vérification rapide
Quel indicateur du compilateur désactive la prise en charge des exceptions en C++ afin de réduire la taille du binaire ?
Récapitulatif
Le C++ embarqué désactive RTTI et les exceptions pour réduire la taille du code et améliorer sa prévisibilité. Remplacez le tas par de la mémoire statique, utilisez des types de résultat pour les erreurs et CRTP pour le polymorphisme. Les normes de codage comme MISRA restreignent davantage le langage.
Questions Fréquemment Posées
La leçon « Contraintes de l’embarqué : sans RTTI ni exceptions » est-elle gratuite ?
Oui — le texte complet de « Contraintes de l’embarqué : sans RTTI ni exceptions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Contraintes de l’embarqué : sans RTTI ni exceptions » ?
Travailler avec les sous-ensembles courants de l’embarqué qui désactivent RTTI et les exceptions Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C++ Academy ?
Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Contraintes de l’embarqué : sans RTTI ni exceptions » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?
Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Contraintes de l’embarqué : sans RTTI ni exceptions
- IO mappées en mémoire et volatile
- Considérations temps réel et latence
- Compilation croisée pour cibles ARM