ebook : Support de Cours langage C de Henri-Garreta


Télécharger ebook : Support de Cours langage C de Henri-Garreta

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Ebook - Support de Cours langage C de Henri-Garreta

...

Langage C

Inventé en 1972 par Dennis Ritchie

Langage de bas niveau

Créé pour porter des systèmes d’exploitation (Unix)

But : un compilateur peut-être écrit en 2 mois

A Permis de réécrire des programmes assembleurs

Programmation indépendante de la machine

Portable : présent sur presque toutes les architectures ayant été inventées

Utilisé du micro-controleur au super-ordinateur

Présent dans les systèmes embarqués

Sont écrits en C

Unix

Linux

Windows

Tous les Compilateurs GNU

GNOME

Les machines virtuelles JAVA ☺

Un code C optimisé permet d’obtenir le code le plus rapide

Fortran, C, C++ sont équivalents

Java est plus lent

Tiobe : popularité des langages

Très utilisé car

Bibliothèque logicielle très fournie

Nombre de concepts restreint

Permet de gérer des exécutables qui n’ont besoin de rien pour s’exécuter et pour lesquels on peut contrôler parfaitement la mémoire utilisée (noyau de Syst. Exploit.

Logiciel Embarqué)

Contrôle de bas niveau : très puissant

Avantages

Nombreux types de données.

Riche ensemble d'opérateurs et de structures de contrôle.

Bibliothèque d'exécution standard.

Efficacité des programmes.

Transportabilité des programmes (plus facile si on respecte une norme).

Liberté du programmeur.

Interface privilégiée avec Unix

Inconvénients

Pas d’objets

Pas de gestion des exceptions

Peu de contrôles (on peut tout faire : débordement de tableaux …)

Faiblement typé (on peut toujours convertir)

Peu devenir franchement complexe

Vieux langage

De très nombreux langages sont inspirés du C

C++ (C avec objets (encapsulation, héritage, généricité))

Java

PhP

Environnement de développement

Allez jeter un œil sur la page wikipedia du langage C (en français et en anglais)

Visual Studio express C++ est gratuit!

Avec DreamSpark (anciennement MSDNAA) vous avez le droit d’avoir plein de choses gratuitement : Windows, Visual

Studio …

Mail à Fabrice Huet (Fabrice.Huet@sophia.inria.fr)

Langage normalisé (C99)

Langage C : pour débuter

Un programme C est constitué d'un ou plusieurs fichiers sources suffixés par .c et .h, dans le(s)quel(s) une unique fonction main doit apparaître (ce sera le point d'entrée du programme).

Seules des fonctions peuvent être définies.

Pour définir une procédure, il faut déclarer une fonction renvoyant le type spécial void.

Pour renforcer le fait que la fonction n'a pas de paramètres, mettre void entre les parenthèses

...

Un premier exemple

int main (void) {

int i;

int x = 3;

int y = 4; /* y doit être positif */

double z = 1.0;

i = 0;

while (i < y) {

z = z * x;

i = i + 1;

}

return 0;

}

Quelques règles

Ce n’est pas obligatoire dans le langage mais suivez ces règles :

On met toujours des {}: if (x > 3) {y = 4;}

On évite plusieurs instructions sur la même ligne

i=i+1; j=j+2; // on sépare sur 2 lignes

On évite plusieurs déclarations sur la même ligne

int i, j=2, k=5; // a éviter

Quelques règles

Les variables sont écrites uniquement en minuscule

Les macros ou constantes définies à l’aide de #define sont toutes en majuscules

Les noms de fonctions commencent par une minuscule

Les noms de fonctions utilisent l’une des 2 formes

Tout en minuscule avec des _ pour séparer

fahrenheit_to_celcius

En « collant » tout et mettant des majuscules pour séparer les mots

fahrenheitToCelcius

On compile et on exécute

On compile et on exécute.

Compilation :

Avec un compilateur (gcc)

On prend le fichier source en entrée (monfichier.c)

En sortie cela crée un fichier a.out (sous Linux, monfichier.exe sous windows)

gcc -Wall -pedantic -ansi foo.c

Ce programme C calcule x

y, x et y étant donnés

(x vaut 3, et y vaut 4). Il n'affiche cependant rien du tout...

Affichage (écriture)

int x;

fprintf(stdout, "%d ",x);

Ecrit un entier dans le fichier stdout (sortie standard)

printf("%d ",x);

Ecrit directement sur la sortie standard

On affiche quelque chose

#include <stdio.h>

int main (void) {

int x = 3;

int y = 4;

double z = 1.0;

fprintf(stdout," x = %d, y = %d", x, y);



while (y > 0) {

z *= x;

y -= 1;

}

fprintf(stdout, " , z = %.2f \ n", z);

return 0;

}

Compilation et exécution

On compile et on exécute.

gcc -Wall -pedantic -ansi foo.c

a.out

x = 3, y = 4, z = 81.00

Le programme calcule 3

4 et affiche les valeurs de x, y et z.

En C, il n'y a pas d'instructions d'E/S. En revanche, il existe des fonctions de bibliothèque, dont le fichier de déclarations s'appelle stdio.h (standard input-output. .h pour « headers ».

Les fonctions de bibliothèque d'E/S font partie de la

bibliothèque C: libc

Compilation et exécution

Le compilateur C utilisé est celui du projet : gcc.

Du fichier source au fichier exécutable, différentes étapes sont effectuées :

le préprocesseur cpp;

le compilateur C cc traduit le programme source en un programme équivalent en langage d'assemblage;

l'assembleur as construit un fichier appelé objet contenant le code machine correspondant;

l'éditeur de liens ld construit le programme exécutable à partir des fichiers objet et des bibliothèques (ensemble de fichiers objets prédéfinis).

Compilation et exécution

Les fichiers objets sont suffixés par .o sous Unix et .obj sous Windows

Les librairies sont suffixées par .a .sl .sa sous Unix et par

.lib sous Windows

Les librairies chargées dynamiquement (lors de l’exécution du programme et non aps lors de l’édition de liens) sont suffixées par .so sous Unix et .dll sous

Windows.

Options du compilateur

Quelques options du compilateur

-c : pour n'obtenir que le fichier objet (donc l'éditeur de liens n'est pas appelé).

-E : pour voir le résultat du passage du préprocesseur.

-g : pour le débogueur symbolique (avec les noms des fonctions).

-o : pour renommer la sortie.

-Wall : pour obtenir tous les avertissements.

-lnom_de_bibliothèque : pour inclure une bibliothèque précise.

-ansi : pour obtenir des avertissements à certaines extensions non ansi de gcc.

-pedantic : pour obtenir les avertissements requis par le C standard strictement \ansi.

Calcul d’une puissance

#include <stdio.h>

double puissance (int a, int b) {

/* Rôle : retourne a^b (ou 1.0 si b < 0) */

double z = 1.0;

while (b > 0) {

z *= a; b -= 1;

}

return z;

} int main (void) {

fprintf(stdout," 3^4 = %.2f \ n",puissance(3, 4));

fprintf(stdout," 3^0 = %.2f \ n",puissance(3, 0));

return 0;

Définition de fonctions

En C, on peut définir des fonctions.

La fonction principale main appelle la fonction puissance, afin de calculer 3^4 et affiche le résultat. Elle appelle aussi la fonction puissance avec les valeurs 3 et 0 et affiche le résultat.

Remarque : Pour compiler, là encore, il n'y a aucun changement.

gcc -Wall -pedantic -ansi foo.c

a.out

3^4 = 81.00

3^0 = 1.00

Déclarations : prototype

double puissance (int a, int b) {

/* corps de la fonction puissance

déclarations

instructions */

}

Si on utilise une fonction avant sa définition alors il faut la déclarer en utilisant ce que l’on appelle un prototype :

double puissance (int, int);

Le compilateur en a besoin pour s’y retrouver

L'utilisation de prototypes permet une détection des erreurs sur le type et le nombre des paramètres lors de l'appel effectif de la fonction.

Lecture au clavier

int x;

fscanf(stdin, "%d ", &x);

Lit un entier dans le fichier stdin (entrée standard)

scanf("%d ", &x);

Lit directement sur l’entrée standard

Puissance : lecture au clavier

#include <stdio.h>

double puissance (int a, int b) {

/* Rôle : retourne a^b (ou 1.0 si b < 0) */

double z = 1.0;

while (b > 0) {

z *= a;

b -= 1;

}

return z;

}

int main (void) {

int x;

int y;

fprintf(stdout, " x = ");

fscanf(stdin, "%d ", &x);

fprintf(stdout, " y = ");

fscanf(stdin, "%d ", &y);

fprintf(stdout," x = %d, y = %d, x^y = %.2f \ n ",x, y,puissance(x, y));

return 0;

}

Lecture au clavier

Dans les précédentes versions, pour modifier les valeurs de x et de y, il fallait modifier le texte source du programme, le recompiler et l'exécuter.

En C, on peut demander à l'utilisateur des valeurs sur l'entrée standard.

gcc -Wall -pedantic -ansi foo.c

a.out

x = 3

y = 4

x = 3, y = 4, x^y = 81.00

Un autre exemple

Écrire sur la sortie standard ce qui est lu sur l'entrée standard (l'entrée et la sortie standard sont ouvertes par défaut).



En pseudo-langage :

variable c : caractère

début

lire(c)

tantque non findefichier(entrée) faire écrire(c)

lire(c)

fintantque

fin

En C :

#include <stdio.h>

int main (void) {

char c;

c = fgetc(stdin);

while (c != EOF) {

fputc(c, stdout);

c = fgetc(stdin);

}

return 0;

}

En C : (en plus court)

#include <stdio.h>

int main (void) {

char c;

while ((c = fgetc(stdin)) != EOF){

fputc(c, stdout);

}

return 0;

}

Un autre exemple

Compter le nombre de caractères lus sur l'entrée standard et écrire le résultat sur la sortie standard.

En pseudo-langage :

variable nb : entier

début

nb := 0

tantque non fdf(entrée) faire

nb := nb + 1

fintantque

afficher(nb)

fin

Une première version

Une première version (les fonctions non déclarées avant leur utilisation sont considérées comme renvoyant un entier) :

#include <stdio.h>

long compte (void); /* déclaration de compte */

/* Rôle : compte le nombre de caractères lus sur l’entrée standard jusqu’à une fin de fichier */

int main (void) {

fprintf(stdout, "nb de caractères = %ld \ n", compte());

return 0;

}

long compte (void) { /* définition de compte */

long nb;

nb = 0;

while (fgetc(stdin) != EOF){

nb += 1;

}

return nb;

}

En C :

#include <stdio.h>

extern long compte (void);

/* Rôle : compte le nombre de caractères lus sur l’entrée

standard jusqu’à une fin de fichier */

int main (void) {

fprintf(stdout, "nb de caractères = %ld \ n", compte());

return 0;

}

long compte (void) {

long nb = 0;

for (; fgetc(stdin) != EOF; nb++){

/* Rien */;

}

return nb;

}

Compilation séparée

On veut réutiliser le plus possible les codes existants

On organise le code : on le sépare par thème, par module :

Les fonctions de maths

Les fonctions d’entrée/sortie (affichage/saisie)

On met un ensemble de code source de fonctions (définition des fonctions) dans le même fichier .c

Pour donner accès aux autres à ces fonctions, on doit donner leur signature (type de retour, nombre de paramètres, type des paramètres) = déclaration. On met ces déclarations dans un fichier publique le .h

Compilation séparée

fichier math.h : fichier de « déclarations»

double puissance (int , int);

/* Rôle : retourne a^b (ou 1.0 si b < 0) */

Compilation séparée

fichier math.c : fichier de « définitions»

#include "math.h"

double puissance (int a, int b) {

double z = 1.0;

while (b > 0) {

z *= a;

b--;

}

return z;

}

Fichier essai.c : fichier principal

#include <stdio.h>

#include <stdlib.h>

#include "math.h"

int main (int argc, char *argv[]) {

if (argc != 3) {

fprintf(stderr, " usage: %s x y>=0 (x^y ) \ n", argv[0]);

return 1;

}

int x = atoi(argv[1]);

int y = atoi(argv[2]);

if (y < 0) {

fprintf(stderr, " usage: %s x y>=0 (x^y ) \ n", argv[0]);

return 2;

}

printf("x = %d, y = %d, z = %.2f \n" ,x, y, puissance(x, y));

return 0;

}

 



231