22
Version 003 Tutoriel CodeBlocks, environnement de développement intégré Auteur : Jean-Louis Gutzwiller. Dernière modification : 16 février 2011 [email protected]

Tutoriel CodeBlocks, environnement de … Lancement du programme 2.1 Lancement Le lancement du programme s'obtient classiquement par : – l'activation du menu depuis l'environnement

Embed Size (px)

Citation preview

Version 003

Tutoriel

CodeBlocks, environnement de développement intégré

Auteur : Jean-Louis Gutzwiller.

Dernière modification : 16 février 2011

[email protected]

- 2 / 22 -

Table des matières1 Introduction ....................................................................................................................................5

1.1 Introduction .............................................................................................................................51.2 Objectif de ce document .........................................................................................................5

2 Lancement du programme ..............................................................................................................62.1 Lancement ...............................................................................................................................62.2 Fenêtre de démarrage ..............................................................................................................6

3 Projet ...............................................................................................................................................73.1 Introduction .............................................................................................................................73.2 Création d'un nouveau projet ..................................................................................................73.3 Association des fichiers sources au projet ..............................................................................9

3.3.1 Introduction .....................................................................................................................93.3.2 Création d'un nouveau fichier source et ajout au projet ................................................103.3.3 Ajout d'un fichier existant au projet ..............................................................................113.3.4 Suppression d'un fichier du projet .................................................................................11

3.4 Options de compilation .........................................................................................................123.4.1 Introduction ...................................................................................................................123.4.2 Flags de compilation .....................................................................................................133.4.3 Autres options de compilation .......................................................................................133.4.4 Directives de définition de macros ................................................................................143.4.5 Options pour l'édition des liens .....................................................................................14

3.5 Options de compilation globales ...........................................................................................154 Compilation et exécution du projet ..............................................................................................16

4.1 Compilation ..........................................................................................................................164.2 Lancement du programme ....................................................................................................16

5 Debug ...........................................................................................................................................175.1 Introduction ...........................................................................................................................175.2 Placer un point d'arrêt ...........................................................................................................175.3 Démarrer le programme ........................................................................................................175.4 Affichage des variables et autres informations .....................................................................18

6 Considération particulières concernant Windows ........................................................................216.1 Introduction ...........................................................................................................................216.2 Jeu de caractères ...................................................................................................................216.3 Utilisation de l'utilitaire pkg-config depuis Windows ..........................................................22

- 3 / 22 -

- 4 / 22 -

1 Introduction

1.1 IntroductionLe développement de logiciels écrits en langage C ou C++ se fait traditionnellement en utilisant un compilateur (gcc) et des outils adaptés pour faciliter la compilation (make).Les fichiers sources peuvent être écrits en utilisant un éditeur de texte (emacs, gvim, gedit sous Linux, ou notepad2 sous Windows) et les programmes seront compilés depuis un terminal ou une invite de commande en utilisant la commande « make ».

Un environnement de développement intégré permet de prendre en charge ces opérations : il regroupe donc l'édition de texte (créer le code source) et les outils de compilation (activation du compilateur gcc par exemple) directement depuis le même logiciel. Il évite ainsi le lancement d'un terminal ou d'une invite de commande pour lancer les opérations de compilation.

En outre, l'environnement de développement intégré facilite la correction du programme (debug) en lançant l'outil de debug (gdb) auquel il ajoute la convivialité de l'environnement graphique (visualisation de l'évolution des variables en temps réel, par exemple).

Note : ce document a été écrit pour la version 8 de CodeBlocks. La version actuelle est la version 10.05 qui n'est pas très différente dans le principe. Ce document n'a donc pas été remis à jour.

1.2 Objectif de ce documentCe document explique en quelques étapes très simples l'essentiel de ce qu'il faut savoir pour utiliser le programme « CodeBlocks » qui est un environnement de développement intégré sous Linux ou sous Windows.

CodeBlocks lui-même n'intègre pas le compilateur gcc ou le debugger gdb, il convient que ces deux programmes soient déjà installés pour le bon fonctionnement de CodeBlocks1.

1 Notons qu'il existe cependant un installeur pour Windows qui installe l'ensemble des programmes nécessaires.

- 5 / 22 -

2 Lancement du programme

2.1 LancementLe lancement du programme s'obtient classiquement par :

– l'activation du menu depuis l'environnement graphique :

--> Programmes -> CodeBlocks --> CodeBlocks (sous Windows)--> Applications --> Programmation --> Code::Blocks IDE (sous Linux/Gnome)

– en tapant directement depuis une invite de commande ou un terminal le nom du programme :

codeblocksCette seconde option sous-entend que la variable d'environnement PATH ait été correctement configurée afin que le programme exécutable puisse être trouvé.

2.2 Fenêtre de démarrageAprès le démarrage, le programme affiche sa première fenêtre qui est la suivante :

Figure 1 : fenêtre de démarrage de Codeblocks.

Depuis cet écran, il est possible de créer un nouveau projet, ou d'ouvrir un projet existant.

Note : il peut y avoir quelques variantes au lancement, selon la configuration de l'utilisateur.

- 6 / 22 -

3 Projet

3.1 IntroductionLa notion de projet est une notion importante sous un environnement de développement intégré. Le projet permet d'associer dans une entité unique l'ensemble des fichiers sources intervenant dans le programme et autorise donc l'invocation du compilateur depuis l'environnement de développement de sorte à obtenir une application finale unique à partir de plusieurs fichiers sources.En d'autres termes, la notion de projet sous Codeblocks permet de remplacer la notion de « makefile » qu'on utilise en ligne de commande.

Note : il reste toutefois possible de n'utiliser Codeblocks que pour l'écriture des fichiers sources et de continuer à utiliser les « makefiles » pour la compilation. Cependant, dans ces conditions, le debugger n'est plus disponible depuis l'environnement intégré.

3.2 Création d'un nouveau projetPour créer un nouveau projet, cliquer sur le lien « Create a new project » de la fenêtre de démarrage (figure 1). Choisir alors un type de projet depuis la nouvelle fenêtre :

Figure 2 : choix du type de projet.

Pour la plupart des applications réalisées en TL, on choisira le type « Console application ». Il est à noter que Codeblocks autorise la création d'application graphiques natives sous Windows (« Win3 GUI project ») ou d'application graphiques utilisant GTK sous Linux ou sous Windows (« GTK+ project »). Le choix « Console application » autorise également l'utilisation de GTK pour les applications graphiques.

- 7 / 22 -

Choisir ensuite le langage dans lequel l'application sera écrite :

Figure 3 : choix du langage.

Choisir enfin le répertoire dans lequel le projet sera placé, ainsi que le nom du projet.

Figure 4 : choix du nom du projet et du répertoire.

Le choix du répertoire de destination se fait en cliquant sur le bouton indiqué sur la figure ci-dessus. Ne pas remplir les autres champs ; ils se remplissent tout seuls.

- 8 / 22 -

Nom duprojet

Répertoirede destination

Note : le répertoire de destination choisi n'est pas directement le répertoire du projet ; il s'agit du répertoire dans lequel le projet sera créé. Le projet lui-même est un répertoire.

Dans l'exemple ci-dessus, le répertoire destination choisi est : « /usr/users/elec/gutzwiller/home/Linux/Developpement/Codeblocks ».Le nom du projet est : « monProgramme ».Codeblocks créée alors automatiquement un répertoire nommé « /usr/users/elec/gutzwiller/home/Linux/Developpement/Codeblocks/monProgramme » pour le projet.

Il est conseillé (bien que non obligatoire) de placer l'ensemble des fichiers sources dans ce répertoire.

Enfin, Codeblocks nous propose de créer deux cibles (le programme pourra être compilé sous deux modes) :

– l'une pour la mise au point (debug)

– l'une pour le programme final, une fois au point (release)

Figure 5 : choix des cibles.

Il est conseillé, en général, de choisir les deux cibles. Cependant, dans le cadre d'un TL, si le programme n'est pas destiné à être diffusé, on pourra ne choisir que la cible « debug ».

3.3 Association des fichiers sources au projet

3.3.1 Introduction

Notons qu'après la création du projet, Codeblocks a automatiquement ajouté un fichier source du

- 9 / 22 -

nom « main.c » ou « main.cpp » (selon le choix du langage C/C++). Ce fichier se trouve dans le répertoire du projet. On pourra conserver ce fichier comme fichier principal et en modifier le contenu.

Note : dans certains cas, les fichiers sources existent déjà lors de la création du projet. On pourra alors supprimer le fichier proposé par défaut par Codeblocks pour le remplacer par ses propres fichiers.

3.3.2 Création d'un nouveau fichier source et ajout au projet

Choisir dans le menu : « file -> new -> file ».

Choisir ensuite le type de fichier à créer :

Figure 6 : choix de type de fichier.

Indiquer si vous voulez créer un fichier source (C/C++ source) ou header (C/C++ header) puis répondre dans les écrans suivants aux questions : choix du langage et ajout du nouveau fichier au projet (choix des cibles), choix du nom du fichier :

Figure 7 : étapes suivantes de la création d'un fichier.

- 10 / 22 -

Cliquer icipour choisir

le nom

3.3.3 Ajout d'un fichier existant au projet

Si vos fichiers sources existent préalablement à la création du projet, vous pouvez rajouter les fichiers sources existants. À cet effet, cliquez avec le bouton droit sur votre projet et choisissez la commande « add files ».

Figure 7 : ajout d'un fichier au projet

3.3.4 Suppression d'un fichier du projet

Pour supprimer un fichier du projet, cliquez avec le bouton droit sur le nom du fichier à supprimer, puis choisissez la commande « Remove file from project » du menu.

Figure 8 : suppression d'un fichier du projet

- 11 / 22 -

Cliquez ici avecle bouton droitpour obtenir le

menu.

Cliquez ici avecle bouton droitpour obtenir le

menu.

3.4 Options de compilation

3.4.1 Introduction

L'un des principaux avantages de l'usage d'un utilitaire tel que « make » est la possibilité d'associer, en les décrivant dans le « makefile », des options de compilation qui peuvent être plus ou moins complexes.

Un environnement de développement intégré prend en charge ces options de compilation.

Dans Codeblocks, les options de compilations sont réglées depuis une fenêtre de dialogue obtenue depuis le menu « Project -> Build options... ».

Figure 9 : options de compilation

La fenêtre de réglage des options se présente comme suit :

Figure 10 : fenêtre de réglage des options de compilation

- 12 / 22 -

Cette fenêtre de dialogue présente plusieurs possibilités :

– Choix du compilateur (« Selected compiler ») : à ne pas modifier, sauf si vous avez plusieurs compilateurs d'origine différente installés sur votre machine. Vous pouvez alors choisir ici avec quel compilateur votre projet sera compilé.

– Réglages à prendre en compte (options de compilation) pour les différentes étapes : choisir l'étape avec les onglets « Compiler setting », « Linker setting », « Search directory », ...

Ces options peuvent être réglées pour :

– le projet complet

– l'une ou l'autre des cibles.

À cet effet, choisissez, dans la zone en haut à gauche, pour quelle cible les options sont activées. Les options activées pour le projet complet sont valides pour toutes les cibles, même si ces options ne sont pas activées dans les cibles.

3.4.2 Flags de compilation

Ces réglages sont accessibles depuis l'onglet principal « Compiler settings », onglet secondaire « Compiler flags ». Ils correspondent à des options de ligne de commande du compilateur de type « -g », « -Wall », ... (voir figure 10 ci-dessus).Chacune des options comporte un texte explicatif et, entre crochets, l'option qui sera effectivement ajoutée à la ligne de commande du compilateur.Les réglages par défaut utilisés par codeblocks peuvent convenir.

3.4.3 Autres options de compilation

Pour utiliser une option disponible pour le compilateur, mais qui ne serait pas présente dans la liste précédente, il est possible de l'entrer directement dans la fenêtre ci-dessous (Onglet principal « Compiler options », onglet secondaire « Other options »).

Figure 11 : autres options de compilation

- 13 / 22 -

Indiquez ici vosautres options de

compilation

Remarque : comme montré dans cet exemple, c'est en particulier à cet endroit qu'on indique les options automatiquement configurées par l'utilitaire « pkg-config » pour ce qui concerne les options de compilation. La syntaxe est (entre back-cotes) :

`pkg-config --cflags <liste des packages à utiliser>`

3.4.4 Directives de définition de macros

Ces directives correspondent à l'utilisation de l'option « -D » en ligne de commande du compilateur. Il est possible de les entrer dans la fenêtre précédente (figure 11) sous leur nom complet. Par exemple, si le compilateur doit être appelé avec la définition de la macro « _LINUX_ » en ligne de commande, la syntaxe habituelle est :

gcc ... -D_LINUX_Il est donc possible d'entrer dans la fenêtre de la figure 11 la ligne : « -D_LINUX_ »Cependant, CodeBlocks préfère utiliser l'onglet suivant comme montré à la figure 12 ci-dessous.

Figure 12 : définition de macro en ligne de commande

3.4.5 Options pour l'édition des liens

Depuis l'onglet « Linker settings », il est possible de fixer les options pour l'édition de liens.

C'est en particulier dans cette zone qu'on indique les options d'édition de liens automatiquement fournies par l'utilitaire pkg-config sous la forme :

`pkg-config --libs <liste de vos packages>`

- 14 / 22 -

Indiquez ici vosmacro, sans mettrele préfixe « -D »

Figure 13 : options pour l'édition de liens

3.5 Options de compilation globalesPar le menu « Settings -> Compiler and debugger... » on accède aux options de compilation globales. Ces options sont valables pour tous les projets de la machine. Une utilisation particulière des options globales est de permettre la définition de directives qui ne seront activées que sur la machine cible. Par exemple, sur une machine Windows, on pourra définir la macro « _POUR_WINDOWS_ », alors que sur une machine Linux, on pourra définir la macro « _POUR_LINUX_ ». Ainsi, le programme pourra effectuer des tests afin d'obtenir un comportement adapté selon qu'il est compilé sur une machine Windows ou sur une machine Linux.

Par, exemple, dans le programme en C ou C++ :

#ifdef _POUR_WINDOWS_… code à compiler sur Windows ...

#endif#ifdef _POUR_LINUX_

… code à compiler sur Linux ...#endif

- 15 / 22 -

Indiquez ici vosoptions pour

l'édition des liens

4 Compilation et exécution du projet

4.1 CompilationLa compilation peut s'obtenir par plusieurs commandes différentes :

– build -> build : Codeblocks détermine si des fichiers sources ont été modifiés et recompile si cela est nécessaire

– build -> rebuild : Codeblocks recompile la totalité du projet (sans se préoccuper des dates de modification des fichiers)

En principe, la première option permet de recompiler plus rapidement, puisque seul le nécessaire sera effectué. Codeblocks maintient automatiquement une liste de dépendance (c'est à dire qu'il sait quel fichier source affecte quelle partie du projet).

La deuxième option, bien que plus lente, permet de garantir la compilation complète (par exemple lorsque le système de datation n'est pas fiable, car le projet se trouve sur un disque monté par le réseau pour lequel la datation est approximative).

4.2 Lancement du programmeLe programme peut être lancé par la commande « build -> run ». Codeblocks ouvre alors une fenêtre terminal (ou « invite de commande » sous Windows) et l'utilisateur peut interagir avec le programme.Note : l'invite de commande sous Windows n'est lancé que si le programme est prévu pour une invite de commande. Un programme type GUI Windows ne nécessite pas d'invite de commande.

Notons que cette manière de faire exécuter le programme ne permet pas le debug. Pour vérifier ou corriger le programme, voir à la section 5 : Debug.

- 16 / 22 -

5 Debug

5.1 IntroductionLes opérations de debug sont prévues pour permettre au développeur de vérifier le déroulement correct du programme en plaçant des points d'arrêts à des positions stratégiques afin de pouvoir stopper le déroulement et observer l'état des variables.

L'ensemble des opérations de debug sont gérées depuis le menu « Debug ».

5.2 Placer un point d'arrêtPour placer ou pour supprimer un point d'arrêt, cliquez dans la zone entre le numéro de la ligne et le code source (donc juste à droite du numéro de la ligne). Un point d'arrêt apparaît sous la forme d'un point rouge.

Figure 14 : placer/supprimer un point d'arrêt

5.3 Démarrer le programmePour démarrer le programme en mode debug, il faut au préalable s'assurer que le mode debug a bien été activé (option « -g » du compilateur). Ceci sera automatiquement réalisé par Codeblocks si vous avez bien choisi la cible « Debug » (« Build target », en haut de la fenêtre, voir figure 14).

Le démarrage du programme s'obtient alors par le menu « Debug -> Start ».

Note : seul un démarrage par le menu « Debug -> Start » permet d'obtenir les opérations de debug

- 17 / 22 -

Cliquez ici pour placerou pour supprimer

le point d'arrêt.

Vérifiez que votre cibleest bien la cible pour

le debug.

(en particulier l'arrêt du programme au point d'arrêt). Un démarrage par le menu « Build -> Run » comme expliqué au paragraphe 4 (« Compilation et exécution du projet ») ne permet pas d'obtenir les fonctionnalités de debug.Remarque concernant Linux : Codeblocks fonctionne correctement depuis une session Gnome, comme décrit dans ce document. En revanche, si Codeblocks est lancé depuis un terminal X (à distance), la fenêtre terminal permettant l'interaction du programme avec l'utilisateur ne s'ouvre pas. Sous Linux, utilisez donc Codeblocks sur le poste local, et non sur un poste à distance.

Une fois le programme démarré, l'environnement de Codeblocks change d'aspect pour autoriser les fonctions suivantes :

Figure 15 : mode debug

5.4 Affichage des variables et autres informationsPar le menu « Debug -> Debugging Windows », vous pouvez faire apparaître des fenêtres supplémentaires contenant des informations à propos de votre programme. Les plus utiles sont :

– watches : permet de consulter et de modifier les variables et paramètres de fonctions

– call stack : permet de connaître la suite des fonctions appelées pour arriver à la fonction courante. Permet aussi de se placer sur un niveau quelconque, afin que les watches ne montrent plus les variables de la fonction courante, mais celles d'une fonction quelconque parmi les fonctions appelantes.

- 18 / 22 -

Le triangle jaune marquela ligne à laquelle leprogramme a été

suspendu.

Utilisez ce panneau de commande pour :- continuer l'exécution- continuer jusqu'à la ligne contenant le curseur- avancer d'une ligne- avancer d'une instruction- entrer dans une fonction- terminer la fonction courante- arrêter le programme.

Figure 16 : fenêtre d'observation une fois activées

Note : il est possible de déplacer ces fenêtres à l'intérieur de l'IDE en les glissant à l'aide de la souris.

Figure 17 : fenêtre d'observation ramenées dans l'IDE

- 19 / 22 -

Lorsque plusieurs fonctions sont activées (appels imbriqués), il est possible d'observer une fonction quelconque de la manière suivante :

Figure 18 : choix de la fonction à observer

Cliquez avec le bouton droit sur la fonction à observer (dans la fenêtre du « stack frame ») et choisir « Switch to this frame » depuis le menu contextuel qui apparaît.

- 20 / 22 -

6 Considération particulières concernant Windows

6.1 IntroductionLes systèmes d'exploitation Windows et Linux sont différents et cela peut poser des problèmes de compatibilité. Ce paragraphe décrit des considérations particulières concernant Windows lorsqu'il est souhaité de créer des projets pouvant fonctionner sur les deux architectures. La démarche adoptée ici consiste à utiliser par défaut l'architecture Linux et à adapter l'architecture Windows afin d'obtenir la compatibilité.

Si le projet est prévu pour fonctionner sur Windows uniquement, il n'est pas nécessaire d'effectuer les adaptations prévues dans ce paragraphe.

6.2 Jeu de caractèresLe jeu de caractère utilisé par défaut sous Linux est UTF-8. Il est conseillé d'utiliser le même jeu de caractères sous Windows.

Ouvrir le menu : « Settings -> Editor... ».

Figure 19 : réglage de l'éditeur

Les fichiers sources seront maintenant compatibles et s'afficheront de la même manière qu'ils soient ouverts par Codeblocks sous Windows ou sous Linux.

Remarque : pour ouvrir les mêmes fichiers sources à l'aide d'un simple éditeur de texte depuis Windows, je conseille d'utiliser « notepad2 ».

- 21 / 22 -

Cliquez sur lepremier item en

haut

Choisissez le jeude caractères UTF-8

depuis ce menu.

6.3 Utilisation de l'utilitaire pkg-config depuis WindowsL'utilisation de l'utilitaire « pkg-config » comme montré dans ce document est possible depuis Windows, à condition de l'environnement « MSYS » ait été installé. La variable PATH doit indiquer où trouver cet utilitaire. En outre, dans le cas d'utilisation de bibliothèques de fonctions rajoutées, l'ensemble des variables d'environnement normalement prévues pour trouver les éléments nécessaires doivent être configurées.

Sur les machines de Supélec servant au TL de la majeure SIR, vous pouvez faire fonctionner « pkg-config » depuis CodeBlock en effectuant les manipulations suivantes :

1. Pour un projet existant :

– ouvrez une invite de commande dans le dossier contenant votre projet CodeBlocks ;

– tapez : « mingw » ;

– tapez ensuite le nom du fichier projet (nom qui se termine par l'extension « .cbp »).

CodeBlocks s'ouvre alors pour ce projet avec les bons réglages.

2. Pour un nouveau projet :

– lancez CodeBlocks de manière traditionnelle (par le menu), et créez votre projet ;

– quitter CodeBlocks ;

– relancez CodeBlocks comme décrit ci-dessus pour un projet existant.

- 22 / 22 -