3
28

Premiers pas de C

Installez l'environnement de programmation en C/C++ sur Linux ou Windows puis éditez, compilez, exécutez et déboguez votre premier programme.

Installation

Linux

Le compilateur gcc de GNU est normalement déjà installé. Vérifiez en tapant la commande gcc -v. Vérifiez aussi que la commande make et le débogueur gdb sont sur votre système. Si nécessaire, installez l'environnement de programmation en C avec la commande suivante :

$ sudo apt-get install gcc gdb make

Pour installer l'environnement de programmation en C++, tapez la commande suivante :

$ sudo apt-get install g++

Installez les pages du manuel pour développeur :

$ sudo apt-get install manpages manpages-dev

Si vous préférez lire la traduction en français :

$ sudo apt-get install manpages-fr manpages-fr-dev

Vérifiez :

$ man 3 printf

NOTE : Le paramètre 3 accède directement à la section 3 du manuel sur les appels à la bibliothèque. Essayez man man pour plus d'explications.

Windows

Installez MinGW (Minimalist GNU for Windows) dans C:\MinGW. Suivez les instructions d'installation de MinGW et de MSYS avec mingw-get. Téléchargez le paquet w32API et copiez les dossiers appelés include et lib dans C:\MinGW.

Après que MinGW a été installé, créez un raccourci sur le bureau. Configurez la cible pour qu'elle exécute l'ordre C:\MinGW\msys\1.0\msys.bat. Renommez le raccourci Msys . Changez l'icône en sélectionnant cmd.exe dans le dossier %windir%\system.

Si vous préférez le processeur de commandes de Windows, ouvrez le Panneau de configuration, double-cliquez sur Système puis cliquez sur l'onglet Avancé et enfin sur le bouton Variables d'environnement. Modifiez la variable PATH qui donne la liste des dossiers contenant des commandes. Ajoutez les dossiers C:\MinGW\bin et C:\MinGW\msys\1.0\bin en séparant bien chaque nom de dossier par un ; (POINT-VIRGULE). Démarrez un processeur de commandes et vérifiez que la commande gcc du compilateur C est bien trouvée :

C:\Documents and Settings\frasq\Mes documents\C>gcc -v

Vous pouvez aussi installer la toute dernière version gratuite de l'environnement de développement C/C++ de Microsoft disponible ici.

Après que le Toolkit a été installé, créez un fichier appelé env.bat dans votre dossier C avec le contenu suivant :

  1. @ECHO off
  2.  
  3. ECHO Microsoft Visual C++ Toolkit (PATH INCLUDE LIB)
  4.  
  5. REM The paths to Microsoft Visual Studio and Microsoft SDKs\Windows depend on the version of the Toolkit.
  6.  
  7. SET PATH=%ProgramFiles%\Microsoft Visual Studio 10.0\VC\bin;%ProgramFiles%\Microsoft Visual Studio 10.0\Common7\IDE;%SystemRoot%\system32;%SystemRoot%
  8. SET INCLUDE=%ProgramFiles%\Microsoft Visual Studio 10.0\VC\include
  9. SET LIB=%ProgramFiles%\Microsoft Visual Studio 10.0\VC\lib;C:\Program Files\Microsoft SDKs\Windows\v7.0A\Lib

Ce fichier regroupe une série de commandes qui initialisent les variables d'environnement PATH, INCLUDE et LIB. PATH liste les répertoires contenant des commandes comme cl, link ou make du Toolkit, et les commandes de Windows. INCLUDE indique au compilateur où se trouvent les fichiers inclus dans un code source. LIB donne la liste des répertoires contenant des librairies de fichiers compilés nécessaires à la fabrication des exécutables. Adaptez env.bat selon la version du Toolkit installée sur votre système.

  1. ECHO Git (PATH HOME)
  2. SET PATH=%PATH%;%ProgramFiles%\Git\bin
  3. SET HOME=%HOMEPATH%

Le reste du fichier permet d'accéder à Git et définit la variable HOME utile à beaucoup de programmes portés d'Unix.

Créez un raccourci dans le même dossier. Configurez la cible pour qu'elle exécute l'ordre %comspec% /k env.bat. Cette ligne lance le processeur de commandes en lui demandant de commencer par exécuter le contenu du fichier env.bat. Renommez le raccourci Visual C++ Toolkit Command Prompt.

Double-cliquez sur le raccourci pour lancer le processeur de commandes. Vérifiez que la commande cl du compilateur C est bien dans le PATH :

C:\Documents and Settings\frasq\Mes documents\C>echo %PATH%
C:\Program Files\Microsoft Visual Studio 9.0\VC\bin;C:\Program Files\Microsoft Visual Stud
io 9.0\Common7\IDE;C:\WINDOWS\system32;C:\WINDOWS
C:\Documents and Settings\frasq\Mes documents\C>cl
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077 for 80x86
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.

usage: cl [ option... ] filename... [ /link linkoption... ]
Premier programme

Créez un dossier appelé C où vous enregistrerez tous vos programmes en C. Créez un autre dossier appelé Hello dans C. Démarrez un éditeur de texte - gedit pour Linux, textpad ou notepad++ pour Windows ou encore mieux, utilisez Eclipse - et créez le fichier hello.c dans le dossier C/Hello avec le contenu suivant :

  1. #include <stdio.h>
  2.  
  3. main() {
  4.     printf("Hello from C!\n");
  5.     return 0;
  6. }

NOTE : Ne tapez pas les numéros de ligne.

Linux

Compilez le programme :

$ cd
$ cd C/Hello
$ ls
hello.c
$ gcc -o hello hello.c
$ ls
hello hello.c

L'option -o hello ordonne à gcc de nommer l'exécutable hello. Sans cette option, l'exécutable est nommé a.out.

$ gcc hello.c
$ ls
a.out hello hello.c
$ rm a.out

Exécutez le programme :

$ ./hello
Hello from C!

Windows

Avec MinGW, vous travaillez exactement comme sous Linux et vous compilez le programme avec gcc. Si vous avez opté pour le Toolkit de Microsoft, compilez le programme avec cl :

C:\Documents and Settings\frasq\Mes documents\C\Hello>cl hello.c
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077 for 80x86
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.

hello.c
Microsoft (R) Incremental Linker Version 7.10.3077
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:hello.exe
hello.obj
C:\Documents and Settings\frasq\Mes documents\C\Hello>hello
Hello from C!

Essayez le même programme en C++ :

  1. #include <iostream>
  2.  
  3. int main() {
  4.     std::cout << "Hello" << " " << "from C++!" << std::endl;
  5. }

Compilez et exécutez le programme :

$ cd
$ cd C/Hello
$ ls
hello.cpp
$ g++ -o hello hello.cpp
$ ./hello
Hello from C++!
Fabriquer un programme

Créez un fichier appelé makefile dans le dossier C/Hello avec le contenu suivant :

  1. ALL=hello
  2.  
  3. SRCS=hello.c
  4. OBJS=$(SRCS:.c=.o)
  5.  
  6. CC=gcc
  7. CFLAGS=-DDEBUG -g
  8. LDFLAGS=
  9.  
  10. all:    $(ALL)
  11.  
  12. $(ALL): $(OBJS)
  13.     $(CC) $^ -o $@ $(LDFLAGS)
  14.  
  15. .PHONY: clean wipe
  16.  
  17. clean:
  18.     rm -f $(OBJS)
  19.  
  20. wipe:   clean
  21.     rm -f $(ALL)
$ ls
hello hello.c makefile
$ make clean
rm -f hello.o
$ make wipe
rm -f hello.o
rm -f hello
$ ls
hello.c
$ make
gcc -DDEBUG -g -c -o hello.o hello.c
gcc hello.o -o hello
$ rm hello
$ make
gcc hello.o -o hello
$ touch hello.c
$ make
gcc -DDEBUG -g -c -o hello.o hello.c
gcc hello.o -o hello

Le déroulement du makefile montre comment gcc est exécuté une première fois avec l'option -c pour seulement compiler le fichier source hello.c et produire le code objet hello.o et une seconde fois pour lier le fichier objet hello.o avec la librairie C et produire l'exécutable hello. Si on détruit hello, make ne recompile pas hello.c pour refabriquer l'exécutable. Si hello.c change, il est bien recompilé. L'option -g demande au compilateur d'ajouter le code nécessaire pour exécuter le programme en mode debug avec gdb.

Sous Windows, si vous utilisez le Toolkit de Microsoft, la commande make s'appelle nmake et le fichier en entrée est un peu différent.

  1. APP=hello
  2.  
  3. CC=cl
  4. LINK=link
  5.  
  6. all:    $(APP).exe
  7.  
  8. $(APP).exe: $(APP).obj
  9.     $(LINK) $(APP).obj /out:$(APP).exe
  10.  
  11. clean:
  12.     del *.obj
  13.    
  14. wipe:   clean
  15.     del $(APP).exe
C:\Documents and Settings\frasq\Mes documents\C\Hello>nmake /f makefile.nmk

Les variations pour un programme en C++:

  1. APP=hello
  2.  
  3. CPP=g++
  4. CPPFLAGS=-DDEBUG -g
  5.  
  6. $(APP): $(APP).o
  7.     $(CPP) $(APP).o -o $(APP)
  8.  
  9. .PHONY: clean wipe
  10.  
  11. clean:
  12.     rm -f *.o
  13.    
  14. wipe:   clean
  15.     rm -f $(APP)
  1. APP=hello
  2.  
  3. CPP=cl
  4. CPPFLAGS=/EHsc
  5. LINK=link
  6.  
  7. $(APP).exe: $(APP).obj
  8.     $(LINK) $(APP).obj /out:$(APP).exe
  9.  
  10. clean:
  11.     del *.obj
  12.    
  13. wipe:   clean
  14.     del $(APP).exe
Déboguer un programme

Pour analyser l'exécution d'un programme pas à pas, compilez-le en mode déboggage en passant l'option -g à gcc :

$ gcc -g -o hello hello.c

Lancez le déboggeur gdb avec en argument l'exécutable :

$ gdb hello
GNU gdb (GDB) 7.1-ubuntu
Copyright (C) 2010 Free Software Foundation, Inc.
...
Reading symbols from /home/frasq/C/Hello/hello...done.
(gdb) 

NOTE : Si gcc ne trouve pas de symboles dans hello, assurez-vous de bien passer l'option -g à gcc sans l'option -s.

Placez un point d'arrêt avant le démarrage du programme :

(gdb) break main
Breakpoint 1 at 0x80483ed: file hello.c, line 4.

Lancez le programme :

(gdb) run
Starting program: /home/frasq/C/Hello/hello 

Breakpoint 1, main () at hello.c:4
4		printf("Hello from C!\n");

Listez le code source du programme au point d'arrêt :

(gdb) list 4
1	#include <stdio.h>
2	
3	main() {
4		printf("Hello from C!\n");
5		return 0;
6	}

Exécutez la ligne de code suivante :

(gdb) step
Hello from C!
5		return 0;

Continuez l'exécution du programme jusqu'à la fin :

(gdb) cont
Continuing.

Program exited normally.

Quittez gdb :

(gdb) quit
$ 

Commentaires

Pour ajouter un commentaire, cliquez ici.