Installez et maîtrisez à fond Code::Blocks

Transcription

Installez et maîtrisez à
fond Code::Blocks !
Par Nesquik69 et Xaviou
www.siteduzero.com
Dernière mise à jour le 23/07/2009
Sommaire
1/31
Sommaire
Sommaire ........................................................................................................................................... 1
Informations sur le tutoriel ................................................................................................................... 0
Installez et maîtrisez à fond Code::Blocks ! ........................................................................................ 2
Informations sur le tutoriel ................................................................................................................................................. 2
Partie 1 : Les bases ............................................................................................................................ 3
Téléchargez et installez les "nightly builds" de Code::Blocks ........................................................................................... 3
Préparez le terrain et téléchargez les fichiers nécessaires ......................................................................................................................................... 3
Installez les différents fichiers téléchargés .................................................................................................................................................................. 5
Installation sous Windows (toutes versions) ............................................................................................................................................................... 6
Installation sous Ubuntu (et ses variantes Kubuntu / Xubuntu) .................................................................................................................................. 6
Installation sous Debian .............................................................................................................................................................................................. 7
Vous avez fini ! ............................................................................................................................................................................................................ 9
Réparations d'urgence ! .............................................................................................................................................................................................. 9
La compilation ne fonctionne pas ! ............................................................................................................................................................................ 10
Où se trouve mon programme une fois compilé ? .................................................................................................................................................... 10
Mettez à jour vos nightly builds ................................................................................................................................................................................. 11
L'interface de Code::Blocks ............................................................................................................................................. 11
Une interface bien pensée ........................................................................................................................................................................................
Les barres d'outils .....................................................................................................................................................................................................
Les menus .................................................................................................................................................................................................................
L'autocomplétion .......................................................................................................................................................................................................
11
12
13
15
Configurez vos projets ..................................................................................................................................................... 15
Qu'est-ce que ce panneau ? .....................................................................................................................................................................................
Project settings ..........................................................................................................................................................................................................
Notes .........................................................................................................................................................................................................................
"C/C++ parser options" et "Debugger options" ..........................................................................................................................................................
EnvVars options ........................................................................................................................................................................................................
Les cibles de construction .........................................................................................................................................................................................
Les variables d'environnement ..................................................................................................................................................................................
Les variables globales ...............................................................................................................................................................................................
17
17
17
18
18
19
21
23
Les plugins débarquent ! ................................................................................................................................................. 25
Petit récapitulatif ........................................................................................................................................................................................................ 25
Présentation de l'architecture des plugins ................................................................................................................................................................. 27
Quelques plugins... ................................................................................................................................................................................................... 29
Les inutiles ................................................................................................................................................................................................................ 29
Les utiles ................................................................................................................................................................................................................... 29
Manager ses plugins ................................................................................................................................................................................................. 31
www.siteduzero.com
Installez et maîtrisez à fond Code::Blocks !
2/31
Installez et maîtrisez à fond Code::Blocks !
Informations sur le tutoriel
Bienvenue,
Beaucoup d'entre vous utilisent Code::Blocks, seulement est-ce que vous
utilisez toutes ses capacités ? Si ce n'est pas le cas j'ai bien l'intention de
vous faire découvrir les fonctionnalités les plus importantes qui font que
cet IDE est excellent
! Certaines d'entre elles vous seront plus ou
Auteurs : Nesquik69 et Xaviou
Difficulté :
Licence :
moins utiles mais il est toujours bon de savoir qu'elles existent car si vous
en avez besoin un jour alors vous serez content de les connaître
.
Afin que vous puissiez comprendre au mieux ce tuto, je vous conseille d'avoir lu au minimum les deux premières
parties du tuto sur le C de M@teo21 , la troisième partie n'est pas à connaître mais savoir installer la SDL est un plus...
www.siteduzero.com
Partie 1 : Les bases
3/31
Cette unique partie a pour but de vous initier aux bases de l'utilisation de Code::Blocks... jusque là rien de bien extraordinaire
mais vous risquez d'être légèrement déstabilisés par l'arrivée d'un petit nouveau qui est rien d'autre qu'une nouvelle version de
Code::Blocks ! Vous êtes surpris
? Ce n'est pas grave, un peu de lecture vous remettra les idées bien en place
.
Téléchargez et installez les "nightly builds" de
Code::Blocks
Vous connaissez tous Code::Blocks : l'IDE que M@teo21 propose dans son tuto sur le C/C++ et finit même par conseiller lors
de la deuxième partie de son cours. Si vous l'avez essayé et conservé c'est qu'il a dû vous plaire, en revanche vous avez peutêtre été déçu par le fait qu'il n'y ait pas de nouvelle version du logiciel depuis que vous l'avez. Rassurez-vous, il y en a eu ! Et
même beaucoup, car les développeurs de Code::Blocks publient une nouvelle version de leur logiciel environ chaque jour.
Quoi mais c'est impossible ou alors ils bossent 25h/24h
!
En fait quand je dis "une nouvelle version chaque jour" c'est un peu exagéré car il s'agit surtout de correctifs du logiciel (qui
sont tout de même bienvenus
). Ces correctifs sont surnommés "nightly builds" par ceux qui les développent et permettent
de mettre constamment à jour Code::Blocks mais surtout de travailler plus facilement grâce à une interface plus claire et de
nouvelles fonctionnalités.
Pour les Linuxiens les "nightly builds" sont un énorme avantage puisque c'est la seule et unique façon d'installer
Code::Blocks sous leur système favori, cette démarche est maintenant expliquée dans ce tuto grâce à Xaviou.
Ça vous intéresse ? Eh bien on commence tout de suite !
www.siteduzero.com
4/31
Préparez le terrain et téléchargez les fichiers nécessaires
Cette partie concerne uniquement les possesseurs de Windows ! Les possesseurs de Linux doivent passer à la partie
suivante où Xaviou explique la démarche à suivre.
Tout d'abord, il est conseillé de désinstaller n'importe quelle version de Code::Blocks se trouvant sur votre ordinateur.
Quoi ? Mais j'ai installé la SDL et plein d'autres trucs dessus, je n'ai pas envie de le refaire !
Pour conserver les fichiers que vous avez mis dans le répertoire d'installation de Code::Blocks, il vous suffit de répondre
"Non" lorsque le programme de désinstallation vous demande si vous souhaitez supprimer votre configuration. Les fichiers
que vous aviez installés seront alors conservés et je vous réexpliquerai comment les réinstaller dans le troisième chapitre
.
Bon, nous pouvons maintenant passer aux choses sérieuses. Il va vous falloir télécharger différentes archives puis les installer.
Comme il sort environ une "nightly build" par nuit, je ne serai plus d'actualité dans peu de temps donc il va vous falloir aller à
cette adresse et vous débrouiller tout seuls (mais non je reste pour vous aider
).
Une fois sur cette page, cliquer sur la date la plus récente (normalement c'est le jour où vous lisez ce tuto
) sauf si il est
écrit : "The (la date) build will NOT be out", il faut qu'il soit écrit : "The (la date) build is out".
Une fois sur la page suivante, téléchargez les fichiers ci-dessous :
Cliquez sur l'image pour l'agrandir
Le premier fichier est la DLL nécessaire à l'affichage de l'interface de Code::Blocks, le deuxième fichier permet de faire
fonctionner le compilateur MinGW et les deux derniers fichiers sont les nouvelles "nightly builds" du jour pour Windows et
Linux (je n'ai indiqué que Ubuntu, les autres distributions ne disposant que de peu de mises à jour au niveau des "nightly
builds").
Cependant il nous manque encore deux choses pour Windows : Le compilateur et le Debugger ! En effet avec les "nightly
builds" ils ne sont pas livrés pas défaut, il va donc nous falloir les télécharger :
- Compilateur MinGW 5.1.4 (lisez ce qui se trouve ci-dessous avant de le télécharger)
- GDB Debugger 6.8.3
Attention ! Je ne garantis pas que je mettrai constamment à jour les liens de téléchargement afin que vous puissiez
bénéficier des dernières versions de ces deux programmes ! Pensez-donc à faire une petite recherche sur Sourceforge
avant
.
Je déconseille fortement d'installer le compilateur avec le lien donné ci-dessus. En effet, une installation manuelle est
toujours plus efficace que l'installation automatique. Voici l'explication :
Il va nous falloir récupérer plusieurs archives sur SourceForge, tout d'abord allez sur la page de téléchargement de MinGW.
Bien, maintenant il nous faut en tout 5 archives :
Le runtime
Les Binutils
Le premier pack pour le C
Le deuxième pack pour le C++
www.siteduzero.com
5/31
Une fois le nettoyage et les téléchargements terminés, nous pouvons passer à la suite.
www.siteduzero.com
6/31
Installez les différents fichiers téléchargés
Nous y voilà ! Vous avez téléchargé tous les fichiers nécessaires, il est donc grand temps de commencer l'installation pour que
vous puissiez enfin vous replonger dans vos codes sources
.
Installation sous Windows (toutes versions)
Commençons par le compilateur, lancez le programme d'installation de MinGW. Cliquez deux fois sur "Next" en laissant les
options par défaut. Acceptez la licence d'utilisation, puis cliquez sur "Next". Vous arrivez sur un menu dans lequel on vous
donne la possibilité d'installer plusieurs composants pour pouvoir compiler différents langages, comme ici on ne s'intéresse
qu'au C/C++ cochez simplement la case "g++ compiler" et cliquez deux fois sur "Next" (je vous déconseille fortement de
changer le répertoire d'installation ! Cela vous évitera de nouvelles manipulations ultérieurement...) puis cliquez sur "Install".
Patientez jusqu'à la fin du téléchargement du compilateur et de son installation (oui, je sais, c'est long
).
Dans le répertoire qui contient le programme d'installation de MinGW vous remarquerez un nombre plus important de fichiers,
vous pouvez (lorsque l'installation est terminée) les supprimer.
Pour ceux qui ont opté pour l'installation manuelle, il vous suffit de créer un dossier "MinGW" à la base du disque
dur C: (ou autre mais je le déconseille) puis d'extraire toutes vos archives dedans et voilà
.
Installons maintenant le debugger, il vous suffit de tout extraire dans le dossier "MinGW" (ou autre si vous avez choisi un
autre dossier) et accepter l'écrasement des anciens fichiers.
Nous allons maintenant pouvoir installer la "nightly build" de Code::Blocks que vous avez récupéré.
Parmis les trois archives téléchargées vous en avez normalement une qui commence par "CB" et se finit par "win32",
décompressez-la (pour cela vous pouvez utiliser l'excellent Izarc) et placez tout son contenu à l'adresse "C:\Program
Files\CodeBlocks" (vous êtes libre de le mettre à un autre emplacement si vous le souhaitez).
Il nous reste maintenant plus que deux archives, décompressez-les et mettez leur contenu dans le répertoire de Code::Blocks.
Installation sous Ubuntu (et ses variantes Kubuntu / Xubuntu)
L'installation sous Ubuntu ne demande pas de téléchargement préalable.
Nous allons tout simplement utiliser un dépôt géré par un membre du forum Code::Blocks (Pasgui, pour ne pas le citer) qui
contiendra les versions 32 bits et 64 bits des dernières Nightly-Builds.
Mais avant de démarrer l'installation de Code::Blocks, il faut installer la bibliothèque qui lui sert de support, c'est à dire
wxWidgets.
Nous allons le faire directement en ligne de commande, ce qui nous fera gagner du temps (il est possible de le faire en utilisant
le gestionnaire de paquets synaptic, mais c'est plus long car il faut rechercher les paquets à installer, ce qui n'est pas très
évident).
Commencez tout d'abord par ouvrir un terminal.
Nous aurons besoin des paquets libwxgtk2.8-0 et wx-common (ils se trouvent dans les dépôts officiels d'Ubuntu).
Et pour l'utilisation future de Code::Blocks, nous aurons également besoin du paquet build-essential.
On peut donc lancer l'installation de ces 3 paquets avec la commande :
Code : Console
sudo apt-get install libwxgtk2.8-0 wx-common build-essential
Il faudra sans doute valider l'installation de paquets supplémentaires dont dépendent les 3 ci-dessus.
Il faut maintenant ajouter l'adresse du dépôt de Pasgui au fichier /etc/apt/sources.list, afin que les paquets qu'il contient soient
disponibles.
Reprenez votre fenêtre "Terminal", et lancez l'édition de ce fichier (avec les droits administrateur) :
Code : Console
www.siteduzero.com
7/31
sudo gedit /etc/apt/sources.list
et ajoutez simplement l'adresse du dépôt à la fin de ce fichier :
Code : Autre
deb http://lgp203.free.fr/ubuntu/ distname universe
Pensez bien à modifier "distname" par le nom de votre distribution (feisty, gutsy, hardy, intrepid, ...).
Lorsque cela est fait, enregistrez le fichier et fermez l'éditeur.
Il reste encore à ajouter la clef de vérification de ce nouveau dépôt et à mettre à jour la liste des paquets (toujours en ligne de
commande):
Code : Console
wget http://lgp203.free.fr/public.key -O- | sudo apt-key add sudo apt-get update
Nous voilà désormais rendus à l'installation de notre IDE préféré :
Code : Console
sudo apt-get install codeblocks codeblocks-contrib
Et pour ceux d'entre-vous qui voudraient installer le débogueur :
Code : Console
sudo apt-get install codeblocks-dbg
Sous Ubuntu, vous trouverez un lanceur dans le menu Applications, Développement (je n'ai actuellement pas la
correspondance sous Kubuntu ou Xubuntu, mais vous ne devriez pas avoir de mal à le trouver).
Le lanceur de Code::Blocks sous Ubuntu
www.siteduzero.com
8/31
Installation sous Debian
L'installation sous Debian ne demande pas de téléchargement préalable.
Nous allons tout simplement utiliser un dépôt géré par un membre du forum Code::Blocks (Jens, pour ne pas le citer) qui
contiendra les versions 32 bits et 64 bits des dernières Nightly-Builds.
Mais avant de démarrer l'installation de Code::Blocks, il faut installer la bibliothèque qui lui sert de support, c'est à dire
wxWidgets.
Nous allons le faire directement en ligne de commande, ce qui nous fera gagner du temps (il est possible de le faire en utilisant
le gestionnaire de paquets synaptic, mais c'est plus long car il faut rechercher les paquets à installer, ce qui n'est pas très
évident).
Nous allons donc ajouter le dépôt officiel wxWidgets à la liste des dépôts de notre distribution, et nous en profiterons pour
ajouter le dépôt de Jens.
Cette manipulation nécessite les droits administrateurs. Il faut donc ouvrir une fenêtre "Terminal" et vous identifier en tant
qu'Administrateur avec la commande :
Code : Console
su
Ensuite, ouvrez le fichier contenant la liste des dépôts à l'aide de l'éditeur de texte :
Code : Console
gedit /etc/apt/source.list
Ajoutez les deux dépôts dont je viens de vous parler (placez les deux lignes ci-dessous à la fin du fichier) :
Code : Autre
deb http://apt.jenslody.de/ any main
deb http://apt.wxwidgets.org/ etch-wx main
Enregistrez le fichier et fermez l'éditeur de texte.
Il faut ensuite mettre à jour la liste des paquets disponibles :
Code : Console
apt-get update
Pour que les deux nouveaux dépôts soient correctement installés, il reste encore à installer les clefs de vérification
correspondantes.
Pour le dépôt officiel wxWidgets, il faut télécharger le fichier contenant la clef et l'installer :
Code : Console
wget http://apt.wxwidgets.org/key.asc -O- | apt-key add -
Pour le dépôt de Jens, il existe un petit paquet spécialement prévu pour cela :
Code : Console
apt-get install jens-lody-debian-keyring
Comme la clef de vérification de ce dépôt n'est pas encore installée, vous devrez confirmer l'installation.
www.siteduzero.com
9/31
Lorsque nos deux dépôts sont correctement configurés, il ne nous reste plus qu'à lancer l'installation.
Tout d'abord, les libs wxWidgets, ainsi que le nécessaire pour pouvoir utiliser Code::Blocks plus tard (compilateur, headers,
...)
Code : Console
apt-get install libwxgtk2.8-0 wx-common build-essential
Et bien entendu, Code::Blocks :
Code : Console
apt-get install codeblocks codeblocks-contrib
Pour ceux qui voudraient installer le débogueur :
Code : Console
apt-get install codeblocks-dbg
Et voilà, c'est terminé.
Vous trouverez un lanceur pour Code::Blocks dans le menu Applications, Programmation
Le lanceur de Code::Blocks sous Ubuntu
Si vous rencontrez des problèmes ou bien que vous jugez ce passage un peu "léger", je vous conseille d'aller lire ce
tuto qui explique en détail l'installation de Code::Blocks sous Ubuntu
.
Vous avez fini !
Si vous lisez cette ligne c'est que vous avez sûrement fini d'installer Code::Blocks et bien je ne peux vous dire qu'une chose :
Bravo, parce que ce n'était pas très simple !
www.siteduzero.com
10/31
Réparations d'urgence !
Il se peut que certains d'entre vous ayez des problèmes de compilation, etc... Cette partie a été réalisée afin que vous puissiez
résoudre cela rapidement sans avoir à lire les chapitres suivants
. Et puis, avec un peu de chance, ça réduira peut-être de
25% le nombre de messages reçus pour des problèmes d'installation
!
La compilation ne fonctionne pas !
1/ Le compilateur est introuvable...
Cela vient sûrement du fait que vous avez modifié le répertoire d'installation de ce dernier, il est donc indispensable que vous
indiquiez à Code::Blocks où il est installé. Allez dans les options du compilateur (Settings -> Compiler and Debugger) et
choisissez "Toolchain executables" dans le menu déroulant, cliquez alors sur "Auto-detect", si la détection automatique a
fonctionné vous verrez un message vous indiquant le nom du compilateur ainsi que son chemin. Si ce n'est pas le cas, vous
devez entrer vous même le chemin d'installation.
2/ J'obtiens une erreur de compilation signalant des bibliothèques introuvables...
Si l'erreur ne ressemble pas à quelque chose comme cela alors passez votre chemin ou envoyez moi un MP (moi = Nesquik69) :
Code : Autre
D:\Documents\codeblocks\testCB2\main.c:1:19: no include path in which to search for std
D:\Documents\codeblocks\testCB2\main.c:2:20: no include path in which to search for std
Pour une raison qui m'est absolument inconnue, il se trouve que Code::Blocks ne sache pas compiler les projets qui ne sont
pas situés sur la même partition (ou disque dur) que celle où est installé MinGW. Pour remédier à cela il vous suffit tout
simplement de déplacer votre projet sur la partition de MinGW puis de relancer le projet et compiler le tout (oui, les projets
sont déplaçables sans que cela cause le moindre problème
).
Où se trouve mon programme une fois compilé ?
Ce problème survient à cause d'une réorganisation de la compilation, je vous apprendrai à résoudre cela plus tard, en attendant
votre programme se trouve dans le dossier "bin" du dossier de votre projet
.
www.siteduzero.com
11/31
Mettez à jour vos nightly builds
Si vous souhaitez rester sous les nightly builds de Code::Blocks (certains n'aimeront peut-être pas mais j'ai des doutes
),
vous voudrez sûrement continuer à mettre à jour vos versions.
Restez au courant des nouvelles versions
Pour commencer, il vous faudrait déjà être au courant de l'arrivée de nouvelles nightly builds. Pour cela il y a un moyen très
simple qui est le flux RSS (ne fonctionne pas sous IE6 et inférieur).
Cliquez sur ce lien.
Pour Firefox : Vous avez juste à cliquer sur le bouton "S'abonner maintenant" et mettre le marque-page dynamique dans...
dans vos marque-pages
.
Pour IE7 : Vous avez juste à cliquer sur le bouton "M'abonner à ce flux".
Mettez à jour votre "nightly build" de Code::Blocks
Il est très simple de mettre à jour sa nightly build : retournez à cette adresse (ou utilisez le flux RSS), choisissez la dernière date
disponible et téléchargez les trois archives que je vous avais indiqué auparavant.
Une fois téléchargées vous avez juste à décompresser ces archives dans le répertoire d'installation de Code::Blocks en
acceptant d'écraser les fichiers présents.
Astuce : Si vous n'avez pas envie de télécharger toutes les archives à chaque fois (notamment pour les petites connexions)
vérifiez simplement si les DLL que je vous avais fait télécharger avec l'archive de Code::Blocks ont été mises à jour. Si ce n'est
pas le cas vous aurez juste à télécharger l'archive qui contient Code::Blocks (celle qui commence par "CB" et se finit par
"win32"
).
Un QCM n'est pas utile mais si toutefois vous avez un quelconque problème avec l'installation de votre "nightly build"
n'hésitez pas à m'envoyer un MP.
L'interface de Code::Blocks
Bien, maintenant que vous avez installé Code::Blocks il ne vous reste plus qu'à vous en servir... oui, mais comment ? Dans ce
chapitre, je vais donc vous faire découvrir les principales fonctions de l'interface de ce dernier.
Ce chapitre a donc pour but de vous "mettre dans le bain", en effet, on peut vite passer à côté de quelques petites choses qui
sont pourtant bien utiles...
www.siteduzero.com
12/31
Une interface bien pensée
Y'a pas à dire ! Pour moi, l'interface de Code::Blocks est vraiment très complète et bien faite. Alors bien sûr ce n'est pas
quelque chose de bien incroyable mais elle est pleine de simplicité et très ergonomique.
Pour ceux qui n'aurait pas encore installé Code::Blocks, voici l'interface :
Ça change de l'ancienne version hein
?
Bien, nous allons pouvoir commencer à voir à quoi servent ces divers boutons.
Je tiens à préciser que si je dis que cette interface est ergonomique c'est tout simplement parce que les menus son très
facilement déplaçables, essayez donc d'en prendre un et de le disposer où vous le souhaitez et vous verrez
.
Les barres d'outils
Elles sont au nombre de quatre mais il est inutile de vous expliquer à quoi sert la première, vous le découvrirez vous-même.
Commençons par la deuxième barre d'outils :
Cette barre n'est pas d'une utilité formidable mais peut quand même servir... le menu de droite vous permet d'accéder très
facilement à une fonction se trouvant dans le fichier actuellement ouvert, le menu de gauche, lui, permet de voir dans quelle
classe nous sommes situé dans le fichier actuellement ouvert (ne vous étonnez pas si vous ne savez pas ce qu'est une classe,
vous ne l'avez peut-être pas encore vu dans le tuto sur le C++).
La troisième barre d'outils est extrêmement utile puisque c'est celle qui contrôle les options de compilation :
De gauche à droite :
Ce premier bouton sert à compiler le projet actuellement sélectionné
Permet d'exécuter le projet une fois compilé
Compilation puis exécution du programme
Recompile tous les fichiers du projet y compris ceux qui n'ont pas été modifiés
Permet d'annuler une compilation (par exemple si vous avez une compilation infinie dûe à une erreur dans votre code)
Ce menu sert à choisir la cible de construction souhaitée (j'y reviendrai dans le chapitre suivant)
Enfin la dernière barre d'outils sert à utiliser le debugger, malheureusement mes connaissances ne sont que très limitées dans ce
domaine je ne pourrais donc pas vous fournir d'explications sur l'utilisation de cette barre d'outils.
Mais puisque le debugger ne reste que très peu utilisé chez les débutants alors cela ne devrait pas vous poser de problèmes, de
plus son utilisation est quasiment identique sur n'importe quel IDE
.
www.siteduzero.com
13/31
Les menus
Ce qui était présenté ci-dessus est un peu rébarbatif mais maintenant ça va être un peu plus intéressant. Je ne sais pas si vous y
avez vraiment fait attention mais dans l'interface vous possédez trois menus. Deux d'entre eux sont très importants et il vous
sera donc utile de savoir vous en servir. Commençons les présentations :
Le menu de "management"
Ce menu est le plus utile de tous. Il vous permet d'ajouter, supprimer des fichiers
de vos projets, ainsi que de les paramètrer, etc...
Vous remarquerez qu'il y a plusieurs onglets, le premier concerne vos projets, le
deuxième liste toutes les fonctions, classes (et même plus !) que vous avez pu
créer dans les fichiers de votre projet, le troisième n'est pas vraiment utile je n'en
parlerai donc pas.
Nous allons bien entendu commencer par ce premier onglet nommé "Projects".
Vous pouvez y voir toute une arborescence qui commence par "Workspace", il
s'agit de votre espace de travail. En faisant un clique droit dessus vous pourrez le
renommer, l'enregistrer, y rechercher un fichier, etc...
Juste en dessous vous pouvez voir deux projets dont un qui est marqué en gras :
cela signifie que c'est le projet actif ! Autrement dit, c'est le projet qui sera compilé
si vous activez cette dernière.
Dans chaque projet est listé les fichiers qui lui sont associés, ceux-ci sont classés
en fonction de leur type. Si vous faites un clique droit sur un de vos projets vous
pourrez alors l'activer, le fermer, ajouter des fichiers, le compiler, accéder à ses
propriétés, etc...
Et enfin une dernière chose : vous pouvez supprimer un fichier de votre projet en
faisant un clique droit sur celui-ci.
Passons maintenant au deuxième onglet nommé "Symbols", comme je l'ai
expliqué précédemment, il liste (à peu près) tout ce qui est essentiel à votre projet
à savoir les fonctions, les classes, etc...
Dans cet onglet, vous pouvez voir un listage des fonctions et variables globales,
des classes et diverses autres choses. Je ne vais pas m'éterniser sur cet onglet mais je tiens au moins à vous apprendre le code
des symboles qui sont affichés parce que ce n'est pas évident à comprendre du premier coup :
Un carré vert seul est une variable globale
Un carré rouge est une variable privée
Un dièse est une constante de préprocesseur
Une icône jaune avec écrit "Type def" est un... type def
!
Un carré vert associé à un '+' est un constructeur
Un carré vert associé à un '-' est un destructeur
Un carré vert entouré de parenthèses est une fonction publique
Un carré rouge entouré de parenthèses est une fonction privée
Bien sûr, si il n'y avait qu'un listage ce ne serait alors pas très utile... c'est pourquoi lorsqu'on fait un clique droit sur un
symbole vous pouvez alors accéder rapidement à sa déclaration ou son implémentation.
Voilà, nous en avons terminé avec ce satané menu (j'en avais marre d'expliquer son fonctionnement
il sera très utile pour tous vos projets.
www.siteduzero.com
). On ne dirait pas mais
14/31
Les fichiers ouverts
Peu utile, il vous permet d'avoir un aperçu de tous les fichiers qui sont
actuellement ouverts.
Je me demande d'ailleurs à quoi ça sert de l'expliquer mais bon... je suis assez perfectionniste
.
Les messages de compilation et plus...
Bon, là je ne tiens pas à vous expliquer ce que veulent
dire les éventuels messages d'erreur qui peuvent
apparaître car ce n'est pas mon rôle, je vais ici vous
décrire à quoi servent ces différents onglets. Même si c'est très rapide c'est quand
même important
.
Code::Blocks : C'est un peu un historique de tout ce que vous avez demandé de
faire à ce dernier. Par exemple si vous avez ouvert un projet il sera alors écrit :
Code : Console
Opening chemin_du_projet: done
Code::Blocks Debug : C'est toujours un historique mais cette fois celui-ci
s'adresse surtout à ceux qui modifient le code source de Code::Blocks. En effet,
dans cet onglet sont listé toutes les actions effectuées par Code::Blocks comme la
mise en cache des fichiers de votre projet. Mais bon, comme nous ne modifions pas le code source de ce logiciel cela ne nous
concerne pas
.
Search results : Affiche les résultats d'une recherche dans plusieurs fichiers uniquement (Search -> Find in files...).
ClearCase : Cette fonction est toute récente je n'ai donc pas encore eu le temps d'étudier ni son utilité, ni son fonctionnement.
Dès que j'aurais fini mes recherches ainsi que mes tests, je vous ferais alors un résumé (toutefois, si c'est intéressant)
.
Build log : Cet onglet affiche l'historique des opérations de la dernière compilation.
Build messages : Cet historique est quasiment identique au précedent sauf qu'il n'affiche que les messages d'erreurs et rien
d'autre. L'avantage de cet onglet c'est qu'en double-cliquant sur le message d'erreur on arrive à la ligne correspondante,
l'inconvénient c'est qu'il faut aller dans le "Build log" si on veut faire Copier/Coller du message d'erreur en question :/ .
Debugger : Pas bien compliqué à comprendre. C'est l'historique des opérations du debugger.
Voilà, c'est terminé pour ce dernier menu, alors je suis quasiment sûr que vous vous ne servirez même pas de la moitié de ces
onglets mais au moins vous saurez à quoi ils servent
.
www.siteduzero.com
15/31
L'autocomplétion
L'autocomplétion... What is that
?
Citation : Wikipédia
En informatique, le complètement ou complètement automatique (on trouve aussi complétion et autocomplétion, qui sont
des anglicismes) est une fonctionnalité permettant à l'utilisateur de limiter la saisie d'informations avec son clavier. De
nombreux logiciels possèdent cette fonctionnalité : les éditeurs de texte prévus pour l'édition de code source, les
traitements de texte ou encore les navigateurs Web.
Bon, je crois que c'est clair
... Mais en fait qu'est-ce que ça vient faire là ? C'est très simple : Code::Blocks possède cette
faculté !
Alors quand je parle d'autocomplétion dans Code::Blocks il ne s'agit pas de vous aider à écrire les mots "int" ou bien "char"
, mais de compléter automatiquement les noms de variables ou bien encore vous rappeller ce que ce sont les paramètres
d'une fonction, etc... et je peux vous dire que ce n'est pas rien ! En plus d'être pratique, cette fonction est puissante !
Ne venez pas me dire que ça ne fonctionne pas... en effet, il faut enregistrer ses fichiers si on veut que
l'autocomplétion fonctionne car Code::Blocks analyse le code source une fois que celui-ci est enregistré !
Alors quelles sont les différentes possibilités de l'autocomplétion ? Eh bien pour vous en faire un résumé je vais vous parler de
ma propre expérience : il m'est souvent arrivé d'écrire des noms de variable assez long comme nomVariableNumeroUne et
si on s'en sert fréquemment il est assez contraignant de la réécrire à chaque fois surtout avec les majuscules.
C'est donc là que l'autocomplétion est utile, il vous suffit d'écrire 3 lettres de la variable en question et à ce moment là vous
avez un menu qui apparaît juste en dessus de votre curseur et qui vous donne la liste des variables qui peuvent correspondre,
voilà un exemple :
À ce moment là, il vous suffit alors de vous diriger avec les flèches pour choisir ce qui correspond. C'est pratique hein
?
Ce n'est pas tout ! Si vous créez une fonction avec dix paramètres (soyons fous) à entrer alors ça va être dur de vous en
souvenir ! Dans ce cas là, une fois la déclaration effectuée et enregistrée, à chaque fois que vous ouvrirez la première
parenthèse de la fonction vous aurez alors un résumé des paramètres à entrer et je peux vous dire que c'est vachement utile !
Alors bien sûr l'autocomplétion ne se limite pas à cela, il y a aussi de quoi faire avec les classes et tout ça. Seulement, je ne
peux pas vous faire un résumé complet sinon j'en aurais jamais fini, je vous ai donc indiqué le plus important mais le reste
vous le découvrirez vous même
.
Bien, ce chapitre est terminé. Alors bien sûr certains l'auront trouvé rébarbatif mais c'est tout de même essentiel à l'utilisation
de Code::Blocks !
Dans le prochain épisode chapitre nous verrons le paramètrage d'un projet et je peux vous dire que c'est tout de suite plus
intéressant
.
Configurez vos projets
www.siteduzero.com
16/31
La plupart d'entre vous écrivez votre code, compilez et puis basta... mais est-ce qu'il vous arrive d'aller dans le panneau
d'options de votre projet? C'est pourtant lui qui vous permet de paramètrer vos projets...
Dans ce chapitre, nous allons donc voir quel est ce panneau et à quoi il sert. Pour cela, créez au préalable un nouveau projet
avec les options par défaut (je vous expliquerai plus tard à quoi elles servent
) car nous allons travailler dessus.
Au fait, si l'icône de ce chapitre vous étonne c'est normal, mais vous comprendrez bien vite
www.siteduzero.com
.
17/31
Qu'est-ce que ce panneau ?
Ce panneau, vous devez sûrement le connaître, cliquez sur "Project -> Properties" et le voilà :
Il est important de préciser qu'il a été entièrement revu dans les nightly builds ce
qui risque de déstabiliser les anciens utilisateurs de Code::Blocks RC2, c'est
pourquoi je vous conseille de lire ce chapitre même si vous aviez des facilités
avec la RC2
.
Le panneau des options pour un projet
Voiçi donc ce fameux panneau, il vous permet de configurer vos projets ainsi
que de récupérer des informations importantes. Commençons tout de suite à voir
à quoi servent les différents onglets proposés...
Si vous avez des onglets en plus ne vous étonnez pas. Cela voudra sûrement dire que mes screens ne sont pas à jour
par rapport à votre version de Code::Blocks. Si c'est votre cas, veuillez me prévenir par MP afin que je rectifie cela au
plus vite
.
Project settings
Dans cet onglet, il vous est possible de paramètrer les options principales :
Title : Vous y entrez le nom de votre projet, il s'affichera dans l'arborescence à gauche de votre code.
Platforms : Une petite nouveauté, vous pouvez indiquer pour quel(s) OS votre projet est codé (cela n'a aucune influence sur le
code).
Filename : Le chemin de votre projet.
Makefile : Permet de définir le Makefile que vous voulez utiliser (si vous ne savez pas ce que c'est cherchez un peu sur
internet, ici ce n'est pas le sujet). Si vous ne cochez pas la case "This is a costum Makefile" alors il sera généré
automatiquement et remplacera celui qui s'y trouvait auparavent.
Precompiled headers : Vous permet de choisir de quelle façon doivent être générés les headers précompilés. Si vous modifiez
cela, vous devez supprimer l'ancien header afin d'éviter les conflits.
Object names generation : Très utile, cet ajout vous permet, dans de gros projets, d'éviter des problèmes d'écrasement avec
des fichiers dont les noms sont identiques, vos fichiers seront renommés afin de palier à ce problème.
Il reste deux boutons :
Project's dependencies... : Permet de voir les dépendances de votre projet.
Project's build options... : Permet de paramètrer en profondeur les configurations cible (vous verrez plus tard ce que c'est
Notes
Attends ! T'aurais pas sauté plusieurs onglets là
?
Effectivement, mais il ne s'agit pas d'une erreur... la raison c'est juste que je ne peux pas tout expliquer, d'autant plus que
Code::Blocks change très fréquemment donc c'est dur de suivre
. Mais ne vous inquiétez pas, l'utilisation de certains de
ces onglets est expliquée plus tard.
Reprenons. Cet onglet est soi utile, soi inutile, mais dans tout les cas certains l'apprécieront... il permettra (comme son nom
l'indique) de mettre des notes dans vos projets... moi personnellement j'adore parce qu'avant je marquais mes idées dans des
fichiers texte et il fallait que je pense à les ouvrir
.
En parlant de penser à les ouvrir, vous pouvez voir en bas du panneau qu'il y a une case à cocher : elle permet d'activer
l'affichage des notes dès que l'on ouvre le projet, utile lorsque vous voulez envoyer votre projet à un ami... au moins il ne se
perdra pas
.
www.siteduzero.com
).
18/31
"C/C++ parser options" et "Debugger options"
Ces deux onglets vous servent à éditer les options d'analyse de votre code. C'est relativement complexe, je ne vais donc pas
vous expliquer tout de suite comment modifier cela, je le ferais peut-être mais dans la deuxième partie de ce big-tuto.
EnvVars options
Là ce n'est pas que c'est difficile mais il vous manque encore deux ou trois notions... j'aborde donc cela à la fin de ce chapitre
.
www.siteduzero.com
19/31
Les cibles de construction
Nous voiçi donc dans une partie très importante, nous allons apprendre à nous servir des "cibles de construction" (traduction
personnelle de "Build Targets", c'est aussi l'explication de l'icône du chapitre
) qui sont très importantes mais surtout
relativement utiles lorsque l'on travail sur un gros projet.
Mais... concrètement, c'est quoi ?
Et bien cela vous permet de créer plusieurs fois le même projet mais avec des paramètres différents. C'est vraiment très
pratique... Imaginons que vous développiez un programme, lorsque vous le codez, vous le compilez avec les paramètres par
défaut du compilateur mais lorsque vous voulez compilez le programme final vous préférez configurer le compilateur de façon
plus pointieuse afin d'être sûr qu'il n'y aura aucun problème. Eh bien au lieu de faire deux projets qui auront le même code
mais des paramètres différents vous avez juste à créer un projet avec un code et deux cibles de construction, vous n'avez plus
qu'à paramétrer les cibles et hop !... vous choisissez la configuration souhaitée au moment de la compilation
!
Je me doute bien que ça vous intéresse, nous allons donc voir comment faire cela
.
Tout d'abord, il faut savoir où sont situées ces fameuses cibles. Rappellez-vous, lors de la présentation des onglets j'en avais
sauté quelques un, choisissez d'abord l'onglet "Build targets", vous tombez sur un panneau de ce style :
Les cibles de construction
Build targets
Voilà un beau bazar... mais je vais vous aider à décortiquer ça. Sur la gauche, vous pouvez voir un cadre nommé "Build
Targets", dans ce cadre il y a un menu contenant vos cibles de configurations, par défaut vous avez deux cibles qui sont
nommées Debug et Release.
Stop ! À quoi elles servent ces deux cibles
?
Eh bien, la première cible nommée "Debug" a pour but, comme son nom l'indique, de vous aider à trouver les erreurs
notamment lorsque vous faites une interface graphique, premièrement elle affiche constamment une console lors de l'exécution
de votre programme mais aussi les options du compilateur sont différentes. La deuxième cible nommée "Release" vous permet
simplement de compiler votre programme dans sa version finale, les options du compilateur sont celles par défaut et il y a une
petite pointe d'optimisation.
Au moment de la compilation vous devrez choisir votre cible de construction, pour cela regardez la barre de
compilation, vous verrez un menu avec deux cibles de construction par défaut. Il vous suffit de choisir la cible
souhaitée
.
Après ce petit détour, nous pouvons revenir au panneau : vous pouvez constater qu'à la droite de la liste se trouve plusieurs
boutons. Les quatre premiers sont les plus élémentaires, ils permettent, dans l'ordre, d'ajouter une cible de construction, de la
renommer, de la copier (un nouveau nom vous sera demandé) et de la supprimer.
Il nous reste cinq boutons :
Virtual Targets : Très utile ! Il permet de créer une cible virtuelle qui associe plusieurs cibles de construction...
J'ai rien compris !
www.siteduzero.com
20/31
C'est normal, je me suis mal expliqué, en fait vous avez deux cibles actuellement, celles-ci sont nommées "Debug" et
"Release". Si, pendant vos compilations, vous avez autant besoin de la cible "Debug" que de la cible "Release" alors il serait
bien de pouvoir les compiler en même temps... eh bien avec le bouton "Virtual Targets" c'est possible ! Commencez par
cliquer dessus, vous verrez un panneau comme celui-ci :
La liste des cibles virtuelles
À gauche, vous avez vos cibles virtuelles (traduction de "virtual targets") et à droite vous pouvez voir à quelle(s) cible(s) est
associé la cible virtuelle actuellement sélectionnée, vous pouvez en ajouter avec le bouton "Add", les éditer avec le bouton
"Edit" et les supprimer avec le bouton "Remove".
Une dernière chose : lors de la compilation avec une cible virtuelle (pour la choisir vous devez faire comme lorsque vous
choisissez une cible de construction) vous aurez plusieurs programmes créés (ceux des cibles de construction associées à la
cible virtuelle), si vous cliquez sur le bouton pour exécuter ces programmes il vous sera alors demandé quelle cible de
configuration vous souhaitez exécuter
.
Dependencies : Si vous cliquez dessus, un panneau s'ouvre alors, il vous permet de gérer les dépendances de votre projet. Je ne
m'attarde pas là dessus vu que je n'en sais pas grand chose.
Re-order : Rien de plus simple ! Ce bouton vous permet de ré-ordonner vos cibles de construction.
Build options : Là je ne vais pas pouvoir vous faire une description immédiate, j'aborderai cela dans la deuxième partie de ce
big-tuto en raison de sa complexité
.
Create project from target : Un bouton encore une fois d'une grand utilité ! Son utilisation n'est pas fréquente mais cela
n'empêche pas le fait qu'il est utile. Si vous cliquez dessus vous pourrez exporter la cible de construction sélectionnée dans un
nouveau projet. Essayez par vous-même...
Voilà, c'est tout pour ce fameux cadre...
Selected build target options
Intéressons-nous maintenant au cadre de droite nommé "Selected build target options", comme son nom l'indique, il permet de
configurer les paramètres de la cible sélectionnée (je précise que là ce sont des paramètres basiques, je vous apprendrais plus
tard comment faire quelque chose de bien plus intéressant
).
Voici donc la description de chaque bouton ou zone de texte dans l'ordre :
Platforms : En cliquant sur le bouton "..." vous aurez la possibilité de cocher les OS compatibles avec votre code, si ils sont
tous cochés alors il sera inscrit "All" dans le champ.
Si vous réfléchissez bien vous pourrez alors découvrir l'utilité des cibles de construction : en effet, chaque cible peut
alors créer un programme pour un OS (uniquement si vous avez un code portable) ! Il vous suffit donc de créer trois
cibles, une pour Windows, une autre pour Linux et enfin une dernière pour Mac, puis de les configurer toutes les
trois (là c'est compliqué car il ne s'agit pas simplement de choisir l'OS compatible...) et ensuite vous compilez chaque
cible
!
Type : Pas bien dur à comprendre ça, vous choisissez comment doit être lancé votre programme : en console, en interface
graphique (que vous devez d'abord avoir codée), ect...
Les trois cases à cocher permettent, dans l'ordre :
De faire une pause à la fin de votre programme lorsqu'il est exécuté depuis Code::Blocks, il ne se ferme pas
automatiquement. Cette option n'est disponible que lorsque vous faites un programme en console !
Je n'ai aucune idée de son utilité ! Toutefois, sachez que ce n'est disponible que si vous créez une bibliotèque
dynamique (cf: ici) !
www.siteduzero.com
21/31
Même chose que pour la case à cocher précédente...
Output filename : Vous permet de choisir le chemin de création de votre programme pour la cible de construction
actuellement sélectionnée.
Si vous changez le chemin de destination mais que vous avez déjà compilé alors l'ancien programme ne sera pas
supprimé automatiquement !
Les deux cases à cocher suivantes permettent, dans l'ordre :
De générer automatiquement un chemin de destination pour votre programme
De générer automatiquement une extension pour votre programme/bibliotèque en fonction du type de projet que vous
avez choisi
Execution working dir : Cela vous permet de choisir le chemin d'exécution de votre programme, par défaut ce sera toujours le
dossier de votre projet.
Objects output dir : Vous pouvez y spécifier le dossier où seront stockés les fichiers compilés (pour les têtes en l'air, vous
avez un rappel de ce que c'est ici).
Build target files
Il nous reste plus qu'un dernier cadre nommé "Build target files", là je ne vais pas m'éterniser... il s'agit simplement de choisir
les fichiers que vous voulez compiler
.
Pensez bien aux dépendances avant de décochez tel ou tel fichier!
Les ajouts de fichiers à un projet
Je tenais au moins à vous informer sur ça : dès que vous ajouterez un fichier à votre projet il vous sera alors demandé avec
quelles cibles de construction vous voulez que ce fichier soit compilé : faites votre choix
.
Passons à la suite...
www.siteduzero.com
22/31
Les variables d'environnement
Comme promis, je vous explique maintenant le fonctionnement des variables d'environnement. Rappellez-vous ! C'est un
onglet dans le panneau d'options nommé "EnvVars options", j'avais dû sauter ce passage car je tenais à ce que vous sachiez
d'abord vous servir des cibles de construction.
Nous pouvons donc commencer...
Les variables d'environnement ne sont pas particulièrement difficiles à utiliser mais plutôt complexes à expliquer, je vais donc
faire de mon mieux...
Lorsque vous utilisez les options de Code::Blocks vous avez la possibilité de faire appel à des variables, vous allez sûrement
vous demandez quel en l'utilité... et bien aucune à part faire gagner du temps (le seul avantage c'est de pouvoir tout changer en
modifiant simplement la valeur de la variable). Il est possible de faire des variables accessibles dans tous les projets mais vous
pouvez aussi limiter votre projet à un seul groupe de variable (pratique si vous créez plusieurs variables de même nom, il suffit
alors de les mettre dans des groupes différents), c'est pour cela que l'on a créé les variables d'environnement.
À noter que les variables créées dans les options de Code::Blocks sont faites pour vos projets et non pour vos codes.
Plutôt qu'un long discours, nous allons essayer nous-mêmes. Allez dans l'onglet "EnvVars options" et cochez la case "Select
environment variables set to be applied", vous pourrez alors choisir quel groupe de variables vous souhaitez, normalement
vous n'avez que "default" de disponible. Bien, maintenant que vous avez choisi votre groupe, il faut lui attribuer des variables,
pour cela fermer le panel des options en cliquant sur "OK" puis aller dans "Settings -> Environment", là descendez dans le
menu de gauche jusqu'à voir "Environment variables", cliquez dessus.
Si vous avez bien suivi vous êtes normalement tombé dans le panneau (elles sont bien mes
blagues hein
?) :
Par défaut, vous êtes sur le groupe nommé "default", nous allons rester dessus, retenez
seulement qu'il suffit de cliquer sur "Create..." pour en créer un nouveau
.
Pour créer une nouvelle variable nous allons cliquer sur "Add", mettez le nom suivant :
debug_chemin_prog et entrez la valeur bin\debug\, faites de même pour la variable
release_chemin_prog et la valeur bin\release\.
Les variables d'environnement
Bien, vos variables sont créées mais ne sont pas encore initialisées, vérifiez donc quelles soient toutes les deux cochées puis
cliquez sur le bouton "Set now" ce qui aura pour effet de mettre vos variables en mémoire vous pourrez alors vous en servir
immédiatement.
Notez bien que si vous n'aviez pas cliquez sur "Set now" vos variables auraient alors été initialisées au prochain
démarrage. Encore une chose : si vous ne cochez pas les variables alors celles-ci ne seront jamais initialisées.
Bon, maintenant fermez le panneau puis retournez dans les options votre projet puis dans l'onglet "Build targets", sélectionnez
la cible "Debug" et entrez alors dans le champ "Output filename" la chaîne de caractères suivante :
$(debug_chemin_prog)programme.exe
Faites de même pour la cible "Release" mais entrez la chaîne suivante : $(release_chemin_prog)programme.exe
Voilà ! Ce que nous venons de faire est totalement mais alors totalement inutile mais bon il s'agissait de vous montrer le
principe des variables d'environnement
!
Décortiquons un peu tout ça :
Nous avons tout d'abord commencé par choisir le groupe de variables que nous souhaitions puis nous avons créé deux
variables nommées debug_chemin_prog et release_chemin_prog. Ensuite nous avons modifié les chemins de création du
programme en y intégrant les deux variables, vous avez pu alors remarquer qu'il fallait entourer la variable des trois caractères
suivants pour pouvoir afficher sa valeur et pas son nom : $()
www.siteduzero.com
23/31
Nous avons ensuite rajouté le nom du programme et son extension, en clair nous obtenons le chemin
bin\Debug\programme.exe pour la cible "Debug" et le chemin bin\Release\programme.exe pour la cible "Release", en clair
on en revient au même point mais c'était juste pour vous montrer l'usage des variables d'environnement
.
www.siteduzero.com
24/31
Les variables globales
Certains trouveront bizarre de voir cette partie dans ce chapitre... malheureusement, je n'ai pas le choix car c'est
l'unique chapitre où je peux aborder les variables globales, je ne vais pas créer un nouveau chapitre uniquement pour
parler des variables globales :/ .
Pour commencer, les variables globales sont nouvelles dans Code::Blocks, mais comprenons nous : il ne s'agit pas ici des
variables globales que vous mettez dans votre code, ce sont des variables spécifiques à Code::Blocks qui n'ont rien à voir avec
votre code.
Ne confondez pas les variables globales avec les variables d'environnement ! Elles n'ont rien à voir entre elles !
Mais alors c'est quoi ces variables et à quoi elles servent
?
Il s'agit d'un type de variable qui permet d'enregistrer les chemins d'installation de vos bibliotèques, c'est beaucoup plus
pratique que de devoir configurer à chaque fois un nouveau projet pour une bibliotèque spécifique.
Ça vous intéresse ? Alors passons à la suite, et vous verrez que l'on ne peut plus s'en passer
.
Allez dans le panneau d'édition des variables globales "Settings -> Global variables". Vous voyez maintenant quelque chose
d'assez... bordelique
!
Supposons que vous vouliez installer la SDL...
Là, j'explique pour la SDL mais c'est valable pour n'importe quel autre bibliotèque supportée par Code::Blocks
.
Donc si vous voulez installer la SDL, vous allez devoir créer une variable globale nommée "sdl", pour cela cliquez sur "New"
(celui du bas) et entrez le nom de votre variable (dans notre cas "sdl").
Dans la partie basse de la fenêtre, vous verrez trois champs importants : "base", "include" et "lib"
Dans le champ "base", vous devez spécifier le dossier englobant toute la SDL (pour moi c'est "C:\SDL-1.2.11"). Les deux
champs suivants sont facultatifs uniquement dans un certain cas : il faut que les dossiers "include" et "lib" soit directement les
sous-répertoires du chemin indiqué dans "base", si ce n'est pas le cas vous devrez indiquer les chemins d'accès à ces dossiers.
Voilà ce que vous devriez normalement obtenir :
L'éditeur des variables globales
Et ensuite ? Eh bien c'est terminé ! Maintenant, tout ce que vous avez à faire c'est créer un nouveau projet de type SDL (File ->
New -> Project -> SDL project) et indiquer, lorsqu'on vous le demandera, que vous voulez utiliser la variable "sdl" en écrivant
dans le champ "Please select SDL's location" la syntaxe suivante :
Code : Autre
$(#sdl)
www.siteduzero.com
25/31
Voilà, c'est tout pour ce chapitre et je pense que ça vous suffit à vous aussi. Ce chapitre était gros mais plein de savoir
!
Vous voilà maintenant fin prêts à paramétrer correctement tous vos projets ainsi que d'installer correctement une bibliotèque,
croyez-moi ce n'est pas une perte de temps
. Ça peut être même très utile dans certains cas ! Notamment quand vous utilisez
une bibliotèque non standard.
Le prochain chapitre portera sur les différents plugins de Code::Blocks
.
Les plugins débarquent !
Les plugins... ces petits programmes qui viennent s'intégrer à un logiciel sont devenus indispensables pour Code::Blocks. En
effet, certains sont installés par défaut et ne peuvent être supprimés, en revanche pas moins d'une vingtaine de ces plugins sont
facultatifs mais ce sont eux qui font la force de Code::Blocks (j'exagère peut-être un peu oui
). Dans ce chapitre, vous
découvrirez donc les plugins les plus importants ainsi que la façon d'en récupérer de nouveaux.
Vous êtes prêts ? Let's go !
Attention ! Dans cette partie je vais vous présenter certains plugins que vous n'aurez peut-être pas si vous utiliser la
version 8.02 de Code::Blocks. Ceci sera d'ailleurs forcément le cas si, lors de l'installation vous avez choisi celle qui
est nommée "standard" ou inférieure.
Pour ceux qui possèdent les nightly builds, pas de problèmes...
www.siteduzero.com
26/31
Petit récapitulatif
Tout d'abord :
À quoi servent les plugins ?
Ce sont des petits programmes fonctionnant sur un seul et même logiciel, ils ont pour particularité d'apporter de nouvelles
fonctionnalités.
Bien, après cette explication on ne peut plus claire (et sommaire
), passons au vif du sujet : Code::Blocks et ses plugins !
Oui, Code::Blocks est bourré de plugins (installés par défaut) qui sont de plus ou moins grande utilité (parce que Tetris et
Snake c'est pas le plus important pour la programmation
!). Certains d'entre eux sont indispensables et ne peuvent être
désinstallés mais une grande partie peuvent l'être, enfin le plus important c'est de pouvoir en installer des nouveaux et
heureusement on le peut. Mais avant de s'intéresser à ceux que l'on peut ajouter il va déjà falloir voir comment se servir de
ceux que l'ont possède.
www.siteduzero.com
27/31
Présentation de l'architecture des plugins
Où sont situés les plugins ? Comment sont-ils créés ? De quelle façon peuvent-ils être paramétrés ?
Autant de questions auxquelles je vais m'efforcer de répondre... Commençons par voir comment nous pouvons les utiliser. Je
pense que vous aurez tous remarqué le menu "Plugins" dans la barre d'outils : c'est là qu'ils sont situés.
Quoi ?! Il n'y a que ça
?
Non, je vous rassure, ce ne sont que les plugins émergents mais en tout cas ce sont les plus utiles. Et c'est d'ailleurs à ce niveau
là que les plugins sont complexes : ils sont situés un peu n'importe où. En effet, l'architecture des plugins de Code::Blocks est
telle que vous pouvez faire en sorte que votre plugin soit affiché à certains endroits et pas à d'autres. Il y aura des donc des
plugins qui bénéficieront d'un panel de paramètres dans les options de Code::Blocks alors que d'autres se contenteront d'un
simple clique dans le menu "Plugins" de la barre d'outils.
Mais plutôt qu'un long discours qui vous fera dormir, passons plutôt à la pratique
.
Pour l'exemple, j'ai choisi de prendre un outil qui sera sûrement un des plus utiles pour vous tous, j'ai nommé : Source code
formatter !
Alors bon, le nom c'est bien beau mais si vous en saviez l'utilité ce serait mieux hein
? Ce plugin permet tout simplement
de réorganiser votre code en fonction de standards bien précis, en clair : il permet de modifier au-to-ma-ti-que-ment
l'indentation de votre code !
À noter que ce système d'indentation n'appartient pas à Code::Blocks, le programme permettant d'effectuer cela
appartient à MinGW, le plugin n'est qu'une interface.
Vous allez me dire : "Oui, mais j'aime bien l'indentation de mon propre code moi !" Alors utilisons un exemple : vous prenez le
code d'une autre personne (volé ou pas, c'est pas mon problème
) mais l'indentation est absolument hideuse, répugnante,
éc?urante, effrayante, etc... Dans ce cas là, vous pouvez utiliser le plugin en question afin de réorganiser tout ça selon votre
idéal !
Donc, pour illustrer cela, je vous ai pondu un code dont vous me direz des nouvelles (attention, j'ai eu du mal à faire un truc
aussi laid alors ne le sous-estimez pas
!) :
Code : C++
#include <iostream>
using namespace std;
int main() {for(int i=0;i<20;i++){cout<<"Vous avez "<<i<< " ans
!"<<endl;}}
Donc, copiez-moi ce code monstrueux dans Code::Blocks et allez dans "Plugins -> Source code formatter" et normalement ça
vous donne un beau code tout propre.
Vous aurez remarqué que seul l'indentation est modifiée : il n'y a pas d'espaces ajoutés entre une variable et le signe
équivalent "=" par exemple
.
Alors évidemment, cette indentation peut ne pas vous convenir et c'est pour cela qu'il est possible de modifier les paramètres
d'indentation soit selon les 5 types d'indentation proposés, soit selon vos propres préférences. Commencez tout d'abord par
aller dans "Settings -> Editor".
C'est là que se dévoile l'architecture complexe des plugins : chaque plugin peut, si l'auteur le souhaite, disposer d'un menu de
www.siteduzero.com
28/31
paramètrage qui est implanté dans les panels d'options de Code::Blocks ! En effet, si vous descendez le menu déroulant à
gauche jusqu'en bas, vous verrez un bouton nommé "Source Formatter", cliquez et vous obtiendrez un menu entièrement dédié
à ce plugin :
Attention ! N'allez pas croire que les menus de paramétrage des plugins sont implantables uniquement dans le
panneau "Editor", ils peuvent tout aussi bien être intégrés dans le panneau "Environment" ou autre.
Bon, tant que j'y suis, je vais vous montrer comment se servir de ce menu là mais le but est atteint : vous montrer une partie de
l'architecture des plugins.
Donc, vous remarquerez qu'il y a 3 onglets et un panel de 6 choix dans le premier onglet : ceux-ci correspondent au type
d'indentation souhaité. Le dernier choix est un choix personnalisable, en clair vous créez vous-même votre propre indentation.
Avant que vous ne commenciez à vous jetez sur la création de votre propre indentation je tiens à préciser que son paramétrage
ne se fait pas par le biais du champ de texte mais par le biais des 2 onglets restant ! Eh oui, c'est un peu plus compliqué tout de
suite hein
?
En plus vous avez pas de bol : j'ai décidé de ne pas faire d'explication sur toute cette opération ! En effet, je juge que les 5
indentations disponibles sont largement suffisantes et en plus je ne tiens pas à m'éterniser sur un seul et même plugin alors
qu'il y en a tant d'autres. J'espère que vous me comprendrez.
Dernière petite chose : parfois vous retrouverez certains plugins dans les options de vos projets. Preuve que les plugins sont
partout.
www.siteduzero.com
29/31
Quelques plugins...
Alors vous dire quelles sont les possibilités offertes par les plugins c'est bien beau mais faudrait-il encore que sachiez vous
servir de quelques-uns d'entre eux pour en avoir l'utilité... Je vais donc vous faire une petite présentation de certains plugins
plus ou moins utiles...
Les plugins présentés ne le seront pas en profondeur, je ne vais pas m'amuser à tout traduire mais par contre je vous
montrerais où sont les options
.
Les inutiles
On commence par les inutiles (parce que c'est ce qui me plaît le plus
) avec :
BYO Games
Alors celui-là je serrais prêt à mettre ma main au feu que vous l'avez déjà essayé bande de galopins ! Comme son nom l'indique
c'est un regroupement de jeux qui sont au nombre de... deux. Mais c'est pas grave, c'est plus qu'il n'en faut ! Bon, je pense que
je n'ai pas besoin de vous expliquer comment fonctionnent le Tetris ou bien le Snake hein
? Sachez simplement que ce
plugin s'ouvre toujours de la même façon que les autres : "Plugins -> BYO Games"
Concernant les options, oui, il y en a ! Et c'est d'ailleurs une très bonne chose car celles-ci servent à vous indiquer quand vous
avez dépassé un certain temps de jeu, ainsi on vous rappelle que Code::Blocks sert surtout à coder et pas à jouer, de plus vous
ne pourrez pas rejouer avant un certain temps de travail. Pour accéder aux options, allez dans "Settings -> Environment ->
C::B Games". Pas besoin de vous expliquer comment paramétrer tout cela, même vous vous pouvez y arriver ! Quoi que...
Code statistics
L'utilité de ce plugin est encore un peu faible c'est pourquoi je le met ici. Comme son nom l'indique il s'agit d'un plugin
permettant de donner des statistiques sur vos codes. Lancez-le de la même manière que les autres et vous obtiendrez des
statistiques détaillées. Vous trouverez les options de ce plugin dans "Settings -> Editor -> Code statistics settings" mais il n'y a
rien à modifier (les options du plugin sont aussi inutiles que ce dernier
).
Les utiles
Eh oui, la partie concernant les plugins inutiles est déjà finie, mais j'essayerai d'en rajouter si certains développeurs ont envie
d'en faire des nouveaux. Attaquons maintenant les plugins utiles (ça nous changera...).
To-Do List
Alors celui-là je crois que c'est mon préféré ! Pourquoi ? Tout simplement parce que tout les petits commentaires laissés dans
vos codes peuvent être répertoriés en un clique dans la To-Do List. Alors bien sûr, tous les commentaires ne sont pas listés, il
faut que ceux-ci aient une syntaxe spéciale.
Et comment je la connais ta syntaxe moi ?
Rassurez-vous, une interface a été codée pour faciliter cela, du coup la syntaxe nécessaire est écrite automatiquement. Voyons
tout de suite comment ajouter une note à un endroit de votre code, faites un clique-droit sur une page de code et cliquez sur
"Add To-Do Item...", vous obtiendrez une fenêtre semblable à celle-ci :
www.siteduzero.com
30/31
Insertion d'une To-Do list
Alors, comme vous pouvez le constater, il y a un champ "Text" pour noter tout ce que vous voulez et ensuite viennent le nom
d'utilisateur ("User"), le type de commentaire ("Type"), la priorité du commentaire ("Priority"), la position du commentaire par
rapport à votre curseur ("Position") et enfin le style de commentaire ("Comment style"). Alors je ne vais pas vous décrire
comment utiliser chacune de ces options, il vous suffit d'essayer mais par contre je tiens à dire que ce qui me paraît le plus
intéressant dans toutes ces options c'est la dernière. En effet, elle permet de modifier le style du commentaire et donc, par
exemple, lui donner le style d'un "Error", ainsi la compilation ne pourra pas être lancée tant que ce commentaire sera présent...
Pratique, si vous avez une tâche à faire avant toute compilation, vous ne risquerez pas de l'oublier.
Bon, c'est bien beau tout ça mais si c'est seulement pour créer des commentaires je savais le faire sans ce plugin
...
Non, non ! C'est là que la "To-Do List" devient utile ! Elle est capable de lister tous les commentaires qui sont dans tout vos
codes ainsi vous pouvez visionner toutes vos notes importantes en un clique ! Mais pour cela il vous faut d'abord afficher la
fenêtre qui liste tout cela : "View -> To-Do List". Et voilà ! Il ne vous reste plus qu'à cliquer sur "Refesh" pour rafraîchir toutes
les entrées et ainsi voir toutes vos notes.
La "To-Do List" en action !
À noter que les commentaires de style "error" ou "warning" ne sont pas listés par ce plugin puisque le compilateur le
fera au moment de la compilation
.
Mais il reste une dernière chose : les options de ce plugin ! Allez dans "Settings -> Environment -> To-Do List" et voilà. Là
vous aurez la possibilité de choisir si les notes doivent être rafraîchies automatiquement ou bien encore si la fenêtre "To-Do
List" doit être intégrée aux onglets du menu "Messages" (personnellement je préfère cela parce que ça prend moins de place).
Koders query
Peut-être avez-vous déjà entendu entendu parler du moteur de recherche Koders ? Non ?
Eh bien, je vais vous expliquer le principe : il permet de rechercher quasiment n'importe quel code (open source) dans lequel il
y a un exemple d'utilisation d'une fonction que vous ne connaissez pas. Alors bien sûr ce n'est pas le remède miracle et y on
trouve souvent des codes inutiles mais cela peut servir de temps en temps (faites-moi confiance, j'y ai moi-même déjà eu
recours
).
Alors que fait ce plugin ? Eh bien il est permet de lancer une recherche sur ce site mais à partir de Code::Blocks. Alors, oui, ça
n'a rien de bien révolutionnaire mais c'est quand même utile notamment grâce au fait que tout ce que vous avez sélectionné sur
votre code sera intégré dans la recherche.
Exemple : Vous surlignez une fonction qui se trouve dans votre code, alors vous faites "Clique-droit -> Search at Koders" et
voilà ! La fonction surlignée est déjà dans la recherche, vous n'avez plus qu'à spécifier le langage (informatique hein, pas votre
langue
), la licence désirée et c'est parti !
www.siteduzero.com
31/31
Manager ses plugins
Bon, je le dis tout de suite : cette partie est sans intérêt... toutefois si je l'ai faite c'est juste histoire de vous montrer comment
supprimer ou ajouter des plugins mais généralement vous n'aurez pas à faire cela (sauf si à la limite vous créez votre propre
plugin).
Le panneau permettant donc tout cela se trouve à cet endroit : "Plugins -> Manage plugins...". Vous
obtiendrez un panneau de ce style :
Comme vous pourrez le constater par vous-même, il y a une ribambelle de plugins installés ! Alors
quelles sont les actions que l'on peut effectuer sur les plugins ? Eh bien il y a la possibilité de les
activer/désactiver, en installer/désinstaller et enfin les exporter.
Pas besoin de vous expliquer comment vous servir des boutons c'est enfantin...
Sachez seulement que vous pourrez télécharger des plugins depuis le forum de Code::Blocks et que ceux-ci seront livrés sous
forme de fichier "*.cbplugin" à installer par le biais du bouton "Install New" dans le panneau présenté ci-dessus.
Et voilà c'est tout, c'était pas bien long hein
?
Au début de ce passage, je vous avais dis que celui-ci avait peu d'intérêt mais pourquoi ça ? Eh bien, premièrement,
parce que je pense que vous ne retirerez jamais de plugin déjà installé et, deuxièmement, un bon paquet de tous ces
plugins ont été développés par des membres externes au projet Code::Blocks. En clair, les meilleurs plugins proposés
par les membres finissent par être intégrés dans Code::Blocks
.
Naaaan !!!! C'est fini
?
Eh oui, c'est vrai que j'ai fait un peu léger au niveau du nombre de plugins présentés mais je ne tenais pas à m'éterniser sur
cela... je vous ai donc présenté tout ce qui est inutile ce qui me paraissait être le plus utilisé. Toutefois, je n'hésiterais pas à en
rajouter si un autre plugin me semble intéressant à présenter.
Et voilà, c'est déjà la fin. À la prochaine
.
PS : Je n'ai pas jugé utile de mettre un QCM...
Et voilà, ce tuto est maintenant terminé. Initialement, il devait y avoir deux parties de quatre chapitres chacune mais
finalement il n'y en a plus qu'une, en fait la deuxième n'aurait pas été vraiment utile...
Merci de votre lecture,
Nes'
www.siteduzero.com

Installez et maîtrisez à fond Code::Blocks

Transcription

Documents pareils

Sepur dans les starting blocks !

installation de code::blocks

Récit du voyage en Pologne des 1°L et 1°ES2.

Ce fork sert à remplacer l`éditeur de guppy par l - Claveyson

Installer les plugins de MEDIAplus v67

56 Plugins

PIC 13-03 Installer un plug-in

INSTALLATION PLUGINS Première étapes : Télécharger les plugins

fixation mât pignon