Nous continuerons dans cette partie de notre tutoriel avec les types de données complexes en C, et nous parlerons de structures. De nombreux langages de programmation modernes leur offrent, une forme ou une autre, tout comme C. Comme vous le verrez plus loin, les structures vous permettent de manipuler plus facilement les données, en vous permettant de stocker différentes variables de types (éventuellement) différents sous un seul «toit».

Structures de début

Bien que je voulais reporter la partie de définition de ce sous-chapitre, il semble que je ne pouvais pas attendre et l'inclure dans l'introduction. Oui, les amis, c'est ce qu'est une structure, et vous verrez chez un coup dans quelle mesure il est utile quand je vais vous montrer quelques exemples. Un parallèle intéressant est celui qui fait référence à une table de base de données: si vous avez un tableau appelé utilisateurs (le nom unique), vous metterez dans ce tableau les données exactes qui concernent directement les utilisateurs: âge, sexe, nom, adresse, et ainsi de suite. Mais ce sont différents types! Pas de problème, vous pouvez le faire avec une table, tout comme vous pouvez le faire avec une structure: l'âge sera un entier, le sexe sera un char, le nom sera une chaîne et ainsi de suite. Alors vous pourrez accéder au membres du tableau facilement, en se référant au nom du tableau / membre. Mais ce n'est pas un cours de base de données, alors passons à autre chose. Mais avant cela, jetons un bref aperçu d'un aspect logique: vous êtes invité à créer des structures avec des membres qui ont quelque chose en commun d'un point de vue logique, comme l'exemple ci-dessus. Vous faciliter la tâche et les personnes qui regarderont plus tard votre code. Voyons donc comment la table de la base de données de nos utilisateurs se traduirait dans une structure C:

structure Utilisateurs int Age; Char Gender; nom char *; Adresse CHAR *; ; 

S'il vous plaît, n'oubliez pas le point-virgule à la fin. OK, je me vantais donc que les membres de la structure soient simples pour accéder. Voici comment, à condition que vous souhaitiez accéder à l'âge de l'utilisateur:

printf ("L'âge de l'utilisateur est% D.\ n ", utilisateurs.âge); 

Mais pour que ce printf fonctionne, nous devrons d'abord définir l'âge. Qui peut être fait comme ça

structure Utilisateurs int Age;… USRS; usrs.âge = 25;… 

Ce que nous avons fait ici, c'est déclarer un exemple de la structure (vous pouvez avoir autant d'instances que vous le souhaitez), nommé «USRS». Vous pouvez avoir USRS1, USRS2, USRS3 et ainsi de suite, vous pouvez donc utiliser ces attributs (comme l'âge, le sexe, l'adresse) sur tous. La deuxième façon de le faire est de déclarer la structure comme nous l'avons fait la première fois (e.g. sans instances), puis déclarez les instances respectives plus tard dans le code:

… structure Utilisateurs USRS1, USRS2, USRS3; 

… Et puis prenez soin de l'âge, du sexe, de l'adresse et ainsi de suite comme nous l'avons fait ci-dessus.

Lorsque nous parlons de structures en conjonction avec des fonctions, la chose la plus importante à dire est probablement le fait que les structures sont considérées comme un ensemble, pas comme un composé composé de plusieurs éléments. Voici un exemple:

void show_age (usrs i) printf ("L'âge de l'utilisateur est% D.\ n ", i.âge); printf ("Le nom de l'utilisateur est% s.\ n ", (& i) -> name); 

Ce que fait cette fonction, c'est: il prend un argument numérique et imprime tous les utilisateurs qui ont cet âge spécifique. Vous avez peut-être remarqué un nouvel opérateur dans le code ci-dessus (si vous ne l'avez pas fait, regardez à nouveau). L'opérateur «->» fait exactement ce que fait l'opérateur de points, vous permettant d'accéder à un membre de la structure, avec la spécification qu'il est utilisé lorsque les pointeurs sont impliqués, tout comme l'opérateur de points est utilisé dans les cas où les pointeurs ne sont pas impliqués. Une autre considération importante ici. Compte tenu du code suivant:

structure mystruct int myInt; char * mystring;  * p; 

Que pensez-vous que l'expression suivante fera?

++p-> myInt; 

Sujets avancés

L'une des choses que vous verrez assez souvent en relation avec les structures, mais pas seulement typedef mot-clé. Comme son nom l'indique, il vous permet de définir des données personnalisées, comme dans les exemples ci-dessous:

typedef longueur int; / * maintenant la longueur est un synonyme pour int * / typedef char * string; 

En ce qui concerne les structures, typedef élimine essentiellement la nécessité d'utiliser le mot «s». Voici donc une structure déclarée de cette manière:

typedef structure collègues int Age; Char Gender;… colls; 

Pour notre prochain sujet, nous prendrons une idée trouvée dans K&R et l'utiliserons pour illustrer notre point. Pourquoi? C'est bien pensé et il se voit très bien et d'une manière simple ce que nous allons illustrer. Mais avant de commencer, voici une question pour vous: sachant que C permet des structures imbriquées, pensez-vous que les structures imbriquées au moyen de typedef pourraient être acceptées? Pourquoi?

Alors, voici le sujet suivant: les tableaux de structure. Maintenant que vous savez quels tableaux êtes-vous facilement deviner de quoi il s'agit. Cependant, certaines questions demeurent: comment mettre en œuvre le concept et, plus important encore, quelle pourrait être l'utilisation? L'exemple dont nous avons parlé apportera bientôt une certaine lumière sur les deux questions. Supposons que vous ayez un programme, écrit en C, et vous souhaitez compter le nombre d'occurrences de tous les mots clés définis par la norme. Nous avons besoin de deux tableaux: l'un pour stocker les mots clés et un autre pour stocker le nombre d'occurrences correspondant à chaque mot-clé. Cette implémentation peut être écrite comme telle:

Char * Mots-clés [nrkeywords]; INT Results [nrkeywords]; 

En regardant le concept, vous verrez bientôt qu'il utilise un concept de paires, qui est plus efficacement décrit en utilisant une structure. Donc, à cause du résultat final dont nous aurons besoin, nous aurons un tableau dont chaque élément est une structure. Voyons.

structure mot-clé char * mots clés; Résultats int;  keywrdtbl [nrkeywords]; 

Maintenant, initialisons le tableau avec les mots clés et le nombre initial d'occurrences qui seront bien sûr 0.

structure mot-clé char * mots clés; Résultats int;  keywrdtbl [] = "Auto", 0, "Break", 0, "case", 0,… "while", 0; 

Votre prochaine et dernière affectation, car cette tâche est un peu plus complexe, consiste à écrire un programme complet qui se prend comme le texte sur lequel travailler et imprimer le nombre d'occasions de chaque mot-clé, selon la méthode ci-dessus.

Le dernier sujet sur les structures que je traiterai est la question des pointeurs vers les structures. Si vous avez écrit le programme dans le dernier exercice, vous avez peut-être déjà une assez bonne idée de la façon dont il pourrait être réécrit afin qu'il puisse utiliser des pointeurs à la place sur les index. Donc, si vous aimez écrire du code, vous pourriez considérer cela comme un exercice facultatif. Donc, il n'y a pas grand-chose ici, juste quelques aspects, comme (très important), vous devez introduire un code supplémentaire avec des soins supplémentaires afin que lors de l'analyse du code source du fichier, vous évaluez des mots clés, et bien sûr la fonction de recherche Doit être modifié, vous ne créerai pas ou ne trébucherez pas sur un pointeur illégal. Voir la partie précédente pour référence sur l'arithmétique du pointeur et les différences entre l'utilisation des tableaux et l'utilisation de pointeurs. Un autre problème avec qui faire attention est la taille des structures. Ne soyez pas dupe: il ne peut y avoir qu'une seule façon de bien comprendre la structure, et c'est en utilisant sizeof ().

#inclure  structure test int one; int deux; char * str; float flt; ; int main () printf ("La taille de la structure est% d.\ n ", taille de(structure test)); retour 0;  

Cela devrait revenir 24, mais ce n'est pas garanti, et K&R explique cela à cause de diverses exigences d'alignement. Je recommande d'utiliser la taille de chaque fois que vous doutez et ne présume rien.

Des syndicats

J'aurais dû modifier le titre et inclure le mot «syndicats», et peut-être même «Bitfields». Mais en raison de l'importance et du modèle général d'utilisation des structures par rapport aux syndicats et aux bitriers, surtout maintenant que le matériel devient une marchandise moins chère (pas nécessairement une pensée saine, mais de toute façon), je suppose que le titre ne dira que des «structures». Alors qu'est-ce qu'un syndicat? Une syndicat ressemble beaucoup à une structure, ce qui diffère, c'est la façon dont le compilateur traite du stockage (mémoire). Bref, une syndicat est un type de données complexe qui peut stocker différents types de données, mais Un membre à la fois. Donc, quelle que soit la taille de la variable stockée, elle aura sa place, mais d'autres ne seront pas autorisées dans l'Union à ce moment précis. D'où le nom «Union». Les déclarations et définitions des syndicats sont les mêmes que les structures, et il est garanti que le syndicat prendra autant de mémoire que son «plus grand membre.

Champs

Si vous voulez utiliser C dans la programmation de systèmes intégrés et / ou des trucs de bas niveau est votre jeu, alors cette partie semblera attrayante. Un Bitfield (certains champs d'écriture bit), n'a pas de mot-clé attribué comme enum ou union, et cela vous oblige à connaître votre machine. Il vous permet d'aller au-delà des limitations basées sur les mots. Il vous permet également de le faire, et cela pourrait être une définition formelle, «pack» plus d'un objet en un seul mot.

Énumération

Pour commencer par un court fait historique, les énumérations ont été introduites en C lorsque C89 était dehors, ce qui signifie que K&R manquait de ce type astucieux. Une énum permet au programmeur de créer un ensemble de valeurs nommées, également appelées énumérateurs, qui ont comme caractéristique principale qu'ils ont une valeur entière qui leur est associée, soit implicitement (0,1,2…) ou explicitement par le programmeur ( 1,2,4,8,16…) . Cela facilite d'éviter les numéros magiques.

énumérer Pression pres_low, pres_medium, pres_high; énumérer Pression p = pres_high; 

Maintenant, c'est plus facile, si nous avons besoin de pres_low pour être 0, moyen 1 et ainsi de suite, et vous n'aurez pas à utiliser #Defines pour cela. Je recommande un peu de lecture si vous êtes intéressé.

Conclusion

Bien que les informations puissent sembler un peu plus condensées qu'auparavant, ne vous inquiétez pas. Les concepts sont relativement faciles à saisir et un peu d'exercice fera des merveilles. Nous vous attendons sur nos forums Linux pour toute autre discussion.

Tous les articles de cette série:

• je. C Développement sur Linux - Introduction
• Ii. Comparaison entre C et d'autres langages de programmation
• III. Types, opérateurs, variables
• Iv. Contrôle de flux
• V. Les fonctions
• Vi. Pointeurs et tableaux
• Vii. Structure
• Viii. E / S de base
• Ix. Style de codage et recommandations
• X. Construire un programme
• Xi. Emballage pour Debian et Fedora
• Xii. Obtenir un forfait dans les référentiels officiels Debian

Tutoriels Linux connexes:

• Choses à installer sur Ubuntu 20.04
• Une introduction à l'automatisation Linux, des outils et des techniques
• Choses à faire après l'installation d'Ubuntu 20.04 Focal Fossa Linux
• Ubuntu 20.04 astuces et choses que vous ne savez peut-être pas
• Masterring Bash Script Loops
• Boucles imbriquées dans les scripts bash
• Choses à installer sur Ubuntu 22.04
• Mint 20: Mieux que Ubuntu et Microsoft Windows?
• Comment doubler Kali Linux et Windows 10
• Manipulation de Big Data pour le plaisir et le profit Partie 1