Structures et classes en C++

C++ continue d'être un langage minoritaire pour le développement embarqué, mais il est couramment adopté par les développeurs lorsque les projets deviennent trop volumineux pour que le C soit utilisé efficacement. Ces développeurs passent généralement du C au C++ et les différences subtiles entre les langages représentent une partie importante de leur courbe d'apprentissage. Le C++ a des structures, comme le C, car elles ne sont pas les mêmes. C++ a des classes, qui sont remarquablement similaires aux structures. Cet article détaille les détails de ces éléments de langage.

Structures en C

Une structure en C est un élément de données composite personnalisé (objet), qui peut être construit à partir des types de données intégrés existants (int , caractère , etc.), des champs de bits (entiers de taille de bits spécifiée) et d'autres structures. L'idée est d'agréger un certain nombre d'éléments de données qui vont ensemble. Par exemple, une structure contenant des coordonnées tridimensionnelles pourrait ressembler à ceci :

struct coordonnées{   float x ; flotter y ; float z;};

Ce code indique au compilateur quelles sont les coordonnées de structure ressemble à. Vous pouvez ensuite déclarer des variables de ce type ainsi :

emplacement des coordonnées de struct ;

La variable localisation est de type coordonnées de structure et ses champs internes peuvent être adressés à l'aide de l'opérateur « point » :

location.x =1.0;location.y =2.0;location.z =9.99;

Bien sûr, un effet similaire pourrait être obtenu en utilisant trois flotteur distincts variables avec des noms comme location_x etc. Cependant, il est beaucoup plus facile de gérer la localisation en tant que variable unique pouvant être transmise à des fonctions, etc.

La possibilité d'inclure des champs de bits donne aux structures une capacité non disponible ailleurs en C. Voici un exemple :

struct bitreg{   non inscrit : 3 ; non signé :3; polarité non signée : 2 ;} ;

Chacun des champs d'une variable de type struct bitreg a une taille de bit spécifique. Le compilateur garantit que les données sont stockées de manière sensée, nous nous attendons donc à ce qu'une telle variable tienne dans un octet. De plus, tout le code « bit bashing » pour accéder aux champs dans l'octet est généré automatiquement. Ainsi, le programmeur peut simplement y accéder ainsi :

struct contrôle bitreg ; control.up =1;control.down =2;control.polarity =3;

Pour la plupart, l'utilisation de structures en C est assez simple et rend le code plus facile à comprendre sans impact sur l'efficacité de l'exécution. Cependant, les développeurs embarqués doivent être conscients de deux points :

• Les processeurs modernes haut de gamme (généralement 32 bits) ont des jeux d'instructions qui s'adaptent facilement à l'utilisation de structures. En effet, ils ont été conçus pour faire exactement cela. Cependant, la plupart des processeurs bas de gamme n'offrent pas de telles efficacités, l'utilisation des structures doit donc être prudente.
• Les champs de bits sont une fonctionnalité intéressante et peuvent générer un code efficace et lisible. Les développeurs embarqués peuvent immédiatement repérer une opportunité :utiliser des champs de bits pour accéder aux registres de contrôle des périphériques. De nombreux périphériques ont des registres d'un mot ou d'un octet contenant divers champs de bits. Cela ressemble à un grand match et parfois il peut être fait pour fonctionner. Mais il y a deux problèmes :
  • La disposition exacte des champs de bits est déterminée par le compilateur. Si tout est mappé correctement sur un appareil, le code peut fonctionner correctement. Cependant, un changement de compilateur, ou même simplement une mise à jour du compilateur, peut casser le code.
  • Le code généré par le compilateur pour accéder aux champs de bits utilisera très probablement un certain nombre d'opérations ET/OU et des accès multiples au registre, ce qui peut être problématique. De plus, certains registres de périphériques sont en écriture seule et ne seraient jamais pris en compte dans le code généré par le compilateur.

Bien qu'une structure C ressemble un peu à un nouveau type de données, ce n'est pas vraiment le cas. Un type de données devrait normalement avoir une gamme d'opérations qui peuvent être effectuées dessus; ce n'est pas le cas pour une structure C. Pour faire quoi que ce soit à une structure C, autre que faire un pointeur vers elle, vous devez accéder aux champs internes. Ce problème est traité en C++.

Cours en C++

Le langage C++ possède un certain nombre de capacités orientées objet. L'un d'eux est le concept d'une classe , qui permet la description de quelque chose de beaucoup plus semblable à un nouveau type de données. Une variable (normalement appelée un objet ) peut être instancié de la classe ; c'est-à-dire qu'il s'agit d'un objet de ce nouveau type.

Une classe C++ a presque exactement la même syntaxe qu'une structure C et des capacités très similaires. Cependant, il existe quelques différences importantes :

• Une classe peut aussi contenir des fonctions (appelées méthodes ).
• Les variables membres et les méthodes sont cachées du monde extérieur, sauf si leur déclaration suit un public :
• Il peut y avoir une paire de méthodes spéciales - le constructeur et le destructeur - qui sont exécutées automatiquement lorsqu'une instance de la classe (un objet) est créée et détruite respectivement.
• Les opérateurs travaillant sur le nouveau type de données peuvent être définis à l'aide de méthodes spéciales (fonctions membres).
• Une classe peut être utilisée comme base pour la définition d'une autre (c'est ce qu'on appelle l'héritage ).
• Déclarer une variable du nouveau type (une instance de la classe ; un objet) ne nécessite que le nom de la classe - le mot-clé class n'est pas obligatoire.

La plupart de ces fonctionnalités sont illustrées dans cet exemple :

class myclass{   char  a ; int   b;public:   void fun(); Ma classe(); ~maclasse();}; maclasse monobj; myobj.fun();

Les variables membres a et b ne sont accessibles qu'aux trois fonctions membres fun() , maclasse() et ~maclasse() . Ces deux dernières fonctions sont le constructeur et le destructeur. Seulement fun() est susceptible d'être appelé par code utilisateur. Le code réel des trois fonctions serait défini ailleurs et associé à la classe à l'aide de  : : opérateur, donc :

void myclass::fun(){  ...

Structures en C++

En plus des classes, le C++ possède des structures qui sont rétrocompatibles avec le C. Cependant, une structure C++ possède également les mêmes capacités supplémentaires que celles que possèdent les classes. Il n'y a qu'une seule différence entre une structure et une classe en C++. L'accessibilité par défaut des variables membres et des fonctions d'une classe est privée, comme nous l'avons vu; la valeur par défaut dans une structure est public. Ainsi, la fonctionnalité de la classe précédente pourrait également être exprimée comme ceci :

struct mystruct{   void fun(); Ma classe(); ~myclass();private:   char  a; int   b;} ;

Utiliser des classes et des structures en C++

Après avoir acquis ces informations, vous êtes priés de ne pas trop les exploiter. Il existe de nombreuses raisons pour n'utiliser des structures que pour le type de fonctionnalité qu'elles offrent en C et des classes lorsque vous avez besoin de capacités supplémentaires. Il s'agit principalement d'un problème de lisibilité du code. Un autre développeur peut ne pas être aussi clair sur les détails et le code écrit d'une manière « non standard » sera source de confusion.

Une priorité clé lorsque vous écrivez du code est de vous assurer qu'il est lisible (=maintenable). Quelqu'un – cela pourrait être vous – pourrait avoir besoin de regarder ce code dans un an et de comprendre ce qu'il fait. Quelques conseils :supposez que la personne qui maintiendra votre code est un psychopathe armé, qui a une patience limitée et qui connaît votre adresse personnelle.