Après toute cette théorie et cette parole, commençons par construire le code écrit dans les neuf dernières parties de cette série. Cette partie de notre série pourrait en fait vous servir même si vous avez appris C ailleurs, ou si vous pensez que votre côté pratique du développement C a besoin d'un peu de force. Nous verrons comment installer les logiciels nécessaires, ce que fait le logiciel et, le plus important, comment transformer votre code en zéros et ceux. Avant de commencer, vous voudrez peut-être jeter un œil à nos articles les plus récents sur la façon de personnaliser votre environnement de développement:

• Introduction à l'éditeur VIM
• Introduction à Emacs
• Personnalisation du VIM pour le développement
• Personnalisation des EMAC pour le développement

Construire votre programme

Rappelez-vous la première partie de notre série de développement C? Là, nous avons décrit le processus de base qui a lieu lorsque vous compilez votre programme. Mais à moins que vous ne travailliez dans le développement du compilateur ou d'autres choses très bas, vous ne serez pas intéressé le nombre d'instructions JMP que le fichier d'assembleur généré a, le cas échéant. Vous voudrez seulement savoir comment être aussi efficace que possible. C'est cela que cette partie de l'article est tout, mais nous ne faisons que gratter la surface, en raison de l'étendue du sujet. Mais un programmeur C de niveau d'entrée le saura après avoir lu ceci tout ce qui était nécessaire pour fonctionner efficacement.

Les outils

En plus de savoir exactement ce que vous voulez réaliser, vous devez vous familiariser avec les outils pour réaliser ce que vous voulez. Et il y a beaucoup plus d'outils de développement Linux que GCC, bien qu'il soit suffisant seul pour compiler les programmes, mais ce serait une tâche fastidieuse à mesure que la taille de votre projet augmente. C'est pourquoi d'autres instruments ont été créés, et nous verrons ici ce qu'ils sont et comment les obtenir. J'ai déjà plus que suggéré de lire le manuel du GCC, donc je suppose que vous avez fait.

faire

Imaginez que vous ayez un projet multi-fichiers, avec beaucoup de fichiers source, les travaux. Imaginez maintenant que vous devez modifier un fichier (quelque chose de mineur) et ajouter du code à un autre fichier source. Il serait douloureux de reconstruire tout le projet à cause de cela. Voici pourquoi la création a été créée: en fonction des horodatages de fichiers, il détecte quels fichiers doivent être reconstruits afin d'atteindre les résultats souhaités (exécutables, fichiers d'objet…), nommé cibles. Si le concept semble toujours trouble, ne vous inquiétez pas: après avoir expliqué un makefile et les concepts généraux, tout cela semblera plus facile, bien que des concepts de marque avancés puissent être inducteurs de maux de tête.

Make a ce nom exact sur toutes les plates-formes sur lesquelles j'ai travaillé, c'est-à-dire que c'est beaucoup de distros Linux, * BSD et Solaris. Donc, quel que soit le gestionnaire de packages que vous utilisez (le cas échéant), que ce soit apt *, yum, zypper, pacman ou émerger, utilisez simplement la commande d'installation respective et faites comme argument et c'est tout. Une autre approche serait, sur les distros avec des gestionnaires de packages qui ont un support de groupe, pour installer l'ensemble du groupe de développement C / C ++. En parlant de langues, je voulais démystifier un mythe ici, qui dit que Makefiles (l'ensemble des règles qui fait doit suivre pour atteindre la cible) n'est utilisé que par les développeurs C / C ++. Faux. Toute langue avec un compilateur / interprète capable d'être invoqué à partir de la coquille peut utiliser les installations de Make. En fait, tout projet qui nécessite une mise à jour basée sur les dépendances peut utiliser. Donc une définition mise à jour d'un makefile serait Un fichier qui décrit les relations et les dépendances entre les fichiers d'un projet, dans le but de définir ce qui devrait être mis à jour / recompilé en cas de changement de la chaîne de dépendance dans la chaîne de dépendance. Comprendre comment faire des œuvres est essentiel pour tout développeur C qui travaille sous Linux ou Unix - oui, les offres commerciales Unix font également, bien que probablement une version qui diffère de GNU MADE, qui est notre sujet. «Version différente» signifie plus que les nombres, cela signifie qu'un bsd makefile est incompatible avec un makefile GNU. Alors assurez-vous que vous faites installer GNU si vous n'êtes pas sur une boîte Linux.

Dans la première partie de cet article, et certaines suivantes, nous avons utilisé et parlé de certaines parties de Yest, un petit programme qui affiche la date d'hier par défaut, mais fait beaucoup de choses liées à la date / temps astucieuses. Après avoir travaillé avec l'auteur, Kimball Hawkins, un petit Makefile est né, c'est ce avec quoi nous travaillerons.

Tout d'abord, voyons quelques bases sur le Makefile. Le nom canonique doit être GnumakeFile, mais si aucun fichier de ce type n'existe, il recherche des noms comme Makefile et MakeFile, dans cet ordre, du moins, la page manuelle dit. Au fait, bien sûr, vous devriez le lire et le relire, puis lire un peu plus. Ce n'est pas aussi grand que GCC et vous pouvez apprendre beaucoup de trucs utiles qui seront utiles plus tard. Le nom le plus utilisé dans la pratique, cependant, est Makefile, et je n'ai jamais vu aucune source avec un fichier nommé GnumakeFile, à vrai dire. Si, pour diverses raisons, vous devez spécifier un autre nom, utilisez Make's -f, comme ceci:

 $ make -f mymakefile

Voici le makefile d'ulest, que vous pouvez utiliser pour compiler et installer ledit programme, car il n'est pas encore téléchargé de Sourceforge. Bien que ce ne soit que un programme à deux fichiers - la source et la manche - vous verrez que faire devient déjà utile.

# Makefile pour compiler et installer yest Uname: = $ (shell uname -s) cc = gcc cflags = -wall cp = cp rm = rm rmflags = -f gzip = gzip version = yest-2.7.0.5 Yest: ifeq ($ (Uname), sunos) $ (cc) -dsunos $ (cflags) -o yest $ (version).c autre $ (Cc) $ (cflags) -o yest $ (version).c fin si Tous: Yest Installer Maninstall Installer: Maninstall $ (CP) Yest / USR / Local / Bin Maninstall: $ (CP) $ (version).Man1 Yest.1 $ (gzip) Yest.1 $ (CP) Yest.1.GZ / USR / Share / Man / Man1 / Clean: $ (RM) $ (RMFLAGS) Yest Yest.1.gz deinstall: $ (rm) $ (rmflags) / usr / local / bin / yest / usr / share / man / man1 / yest1.gz 

Si vous regardez attentivement le code ci-dessus, vous observerez déjà et apprendrez un certain nombre de choses. Les commentaires commencent par des hachages, et puisque les makefiles peuvent devenir assez cryptiques, vous feriez mieux de commenter vos makefiles. Deuxièmement, vous pouvez déclarer vos propres variables, puis vous pouvez en faire bon usage. Vient ensuite la partie essentielle: cibles. Ces mots qui sont suivis d'un côlon sont appelés cibles, et on les utilise comme make [-f makefile name] Target_name. Si vous avez déjà installé à partir de Source, vous avez probablement tapé «Faire installer». Eh bien, «Installer» est l'une des cibles de la Makefile, et d'autres cibles couramment utilisées incluent «Clean», «Deinstall» ou «tout». Une autre chose la plus importante est que la première cible est toujours exécutée par défaut si aucune cible n'est spécifiée. Dans notre cas, si je tapais «faire», cela aurait été l'équivalent de «Make Yest», comme vous pouvez le voir, ce qui signifie une compilation conditionnelle (si nous sommes sur Solaris / Sunos, nous avons besoin d'un drapeau GCC supplémentaire) et de la création de la création de un exécutable nommé «oui». Des cibles comme «tout» dans notre exemple ne font rien par eux-mêmes, dites simplement à faire qu'ils dépendent d'autres fichiers / cibles pour être à jour. Regardez la syntaxe, à savoir des trucs comme des espaces et des onglets, car la marque est assez prétentieuse sur des choses comme celle-ci.

Voici un court Makefile pour un projet qui a deux fichiers source. Les noms de fichiers sont SRC1.C et Src2.C et le nom de l'exécutable doit être exécuté. Simple, à droite?

exec: src1.o src2.o gcc -o exec src1.o src2.O SRC1.O: SRC1.C GCC -C SRC1.c src2.O: SRC2.C GCC -C SRC2.c

La seule cible pratiquement utilisée, qui est également la valeur par défaut, est «EXEC». Il dépend sur src1.O et SRC2.o, qui, à son tour, dépendent du respect .c fichiers. Donc, si vous modifiez, disons, src2.C, tout ce que vous avez à faire est de faire à nouveau faire de la marque, ce qui remarquera que Src2.C est plus récent que le reste et continue en conséquence. Il y a beaucoup plus à faire que couvert ici, mais il n'y a plus d'espace. Comme toujours, une auto-apprentissage est encouragée, mais si vous n'avez besoin que de fonctionnalités de base, ce qui précède vous servira bien.

Le script de configuration

Habituellement, ce n'est pas seulement «Make && faire l'installation», car avant ces deux. Fondamentalement, ledit script vérifie que les composants nécessaires pour la compilation sont installés, mais prend également divers arguments qui vous aident à modifier la destination des fichiers installés et diverses autres options (e.g. Prise en charge QT4 ou GTK3, prise en charge du fichier PDF ou CBR, etc.). Voyons en quelques coups d'œil à quoi servent ces scripts de configuration.

Vous n'écrivez généralement pas le script de configuration à la main. Vous utilisez AutoConf et Automake pour cela. Comme les noms l'impliquent, ce qu'ils font est de générer des scripts et des makefiles, respectivement. Par exemple, dans notre exemple précédent avec le programme Yest, nous pourrions en fait utiliser un script de configuration qui détecte l'environnement du système d'exploitation et modifie certaines variables de fabrication, et après tout qui génère un Makefile. Nous avons vu que l'opinion de Makefile vérifie si nous courons sur Sunos, et si nous le sommes, ajoute un drapeau de compilateur. J'élargirais cela pour vérifier si nous travaillons sur un système BSD et si oui, invoquez Gmake (GNU Make) au lieu de la marque native qui, comme nous l'avons dit, incompatible avec GNU Makefiles. Ces deux choses sont faites en utilisant AutoConf: nous écrivons un petit configurer.dans Fichier dans lequel nous disons à AutoConf ce que nous devons vérifier, et vous voudrez généralement vérifier plus que la plate-forme OS. Peut-être que l'utilisateur n'a aucun compilateur installé, pas de marque, pas de bibliothèques de développement qui sont importantes et ainsi importantes. Par exemple, une ligne qui vérifierait l'existence du temps.H Dans le système, les emplacements de l'en-tête standard ressembleraient ainsi:

 Ac_check_headers (temps.h)

Nous vous recommandons de commencer par une application pas trop big, de vérifier le contenu de Tarball source et de lire la configuration.dans et / ou configurer.fichiers AC. Pour les tarball qui les ont, makefile.AM est également un bon moyen de voir à quoi ressemble un fichier d'automake. Il y a quelques bons livres sur la question, et l'un d'eux est que Robert Mecklenburg «Gestion Projects with GNU Make».

Conseils GCC et drapeaux de ligne de commande habituels

Je sais que le manuel du GCC est grand et je sais que beaucoup d'entre vous ne l'ont même pas lu. Je suis fier de lire tout cela (tout ce qui concerne le matériel IA de toute façon) et je dois avouer que j'ai eu mal à la tête après. Là encore, il y a des options que vous devriez savoir, même si vous en apprendrez plus au fur et à mesure.

Vous avez déjà rencontré le Flag -O, qui indique à GCC ce que le Outfile résultant, et -C, qui dit à GCC de ne pas exécuter le linker, produisant ainsi ce que l'assembleur crache, à savoir les fichiers d'objet. En parlant de cela, il existe des options qui contrôlent les étapes auxquelles GCC doit arrêter l'exécution. Donc, pour s'arrêter avant l'étape d'assemblage, après la compilation en soi, utilisez -S. Dans la même veine, -e doit être utilisé si vous souhaitez arrêter GCC juste après le prétraitement.

C'est une bonne pratique de suivre une norme, sinon pour l'uniformité, mais pour de bonnes habitudes de programmation. Si vous êtes dans la période de formation en tant que développeur C, choisissez une norme (voir ci-dessous) et suivez-la. Le langage C a été standardisé d'abord après que Kernighan et Ritchie (RIP) ont publié «The C Programming Language» en 1978. C'était une norme non formelle, mais il a été sous peu surnommé K&R et respecté. Mais maintenant, c'est obsolète et non recommandé. Plus tard, dans les années 80 et les années 90, ANSI et ISO ont développé une norme officielle, C89, suivie de C99 et C11. GCC prend également en charge d'autres normes, comme GNUxx, où xx peut être 89 ou 99, comme exemples. Vérifiez le manuel pour plus de détails, et l'option est '-std =', «appliqué» par «-pedantic».

Les options liées aux avertissements commencent par «-w», comme «-wall» (il indique à GCC de permettre à toutes les erreurs, bien qu'ils ne soient pas tout à fait activés) ou «-werror» (traiter les avertissements comme des erreurs, toujours recommandés). Vous pouvez transmettre des arguments supplémentaires aux programmes qui aident les étapes intermédiaires, telles que le préprocesseur, l'assembleur ou la liaison. Par exemple, voici comment transmettre une option au linker:

 $ gcc [Autres options…] -wl,option [Encore un autre ensemble d'options…]

De même et intuitivement, vous pouvez utiliser «WA», pour l'assembleur et «WP», pour le préprocesseur. Prenez note de la virgule et de l'espace blanc qui indique au compilateur que la pièce du préprocesseur / assembleur / linker est terminée. D'autres familles utiles d'options incluent «-g» et les amis pour le débogage, «-o» et les amis pour l'optimisation ou «-iannuaire'- Pas d'espace blanc - pour ajouter un emplacement contenant de l'en-tête.

Conclusion

Je vous recommande de prendre votre temps pour lire cet article, de jouer avec les exemples, puis d'écrire le vôtre, d'augmenter la complexité au fur et à mesure.

Voici ce à quoi vous pouvez vous attendre ensuite:

• 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
• Installez Arch Linux dans VMware Workstation
• Tutoriel de débogage GDB pour les débutants
• Advanced Bash Regex avec des exemples
• Système linux hung? Comment s'échapper vers la ligne de commande et…
• Manipulation de Big Data pour le plaisir et le profit Partie 1
• Python Expressions régulières avec des exemples
• Boucles de bash avec des exemples