Formation de base complet sur le langage c : developpez


Télécharger Formation de base complet sur le langage c : developpez

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

Télécharger aussi :


Formation de base complet sur le langage c

...

  1. Présentation

1.1. Historique

C a été conçu afin de réécrire de façon portable et en langage évolué UNIX

! 1972 : Dennis Ritchie (Laboratoires Bell, AT&T) crée le langage C

! 1973 : UNIX est réécrit en langage C (D.Ritchie et K.Thompson)

C s'impose comme le langage de programmation sous UNIX

! 1978 : Kernighan et Ritchie publient une définition du langage C

! 1984 : Harbison et Steele publient une synthèse sur les compilateurs et dialectes

! 1989 : fin du travail de l'ANSI de normalisation du langage, de ses bibliothèques et de son environnement de compilation et d'exécution

C++, développé par B. Stroustrup (AT&T), tend à prendre maintenant le relais de C

C++ reste presque compatible avec C ANSI et apporte les concepts des langages orientés objets

1.2. Caractéristiques

langage à usage général

présent sur pratiquement toutes les machines et systèmes d'exploitation

possède des facilités naturelles d'interfaçage avec les primitives système

dispose d'une bibliothèque de fonctions et d'un grand nombre d'opérateurs

structures de contrôle permettant la programmation structurée

architecture bien adaptée à la programmation modulaire

langage relativement dépouillé

sémantiquement près du matériel

les programmes C sont efficaces : le code généré est rapide et compact

très permissif (en particulier, il est faiblement typé)

pas de dialectes : les programmes C sont relativement portables

la concision des programmes nuit à la clarté

l'absence de vérification de type diminue la détection d'erreurs à la compilation

le programmeur suit souvent des conventions non imposées par le langage

la sémantique de certains opérateurs et types n'est pas définie précisément

la sémantique est ardue pour ceux qui n'ont pas une expérience de l'assembleur

1.3. Bibliographie

Le langage C, 2e édition

  1. Kernighan & D. Ritchie Masson - 1990

première référence du C par le père du langage, réédité pour le C ANSI

Langage C - Manuel de référence

S.P. Harbison & G.L. Steele Jr.

Masson - 1990

référence technique très pointue, indispensable à ceux qui veulent réaliser un compilateur C

Langage C - Les finesses d'un langage redoutable

  1. Charbonnel

Armand Colin - Collection U - 1992

guide pédagogique, support de ce cours, exposant également les principaux pièges du langage

1.4. Les mots clés

symbole défini et réservé par le langage

auto break case char const

continue default do double else

enum extern float for goto

if int long register return

short signed sizeof static struct

switch typedef union unsigned void

volatile while

1.5. Les constantes

constante entière

1 112 -71 /* décimales */

0x12 0xFFFF 0X1A9F 0x1a9f /* hexadécimales */

012 -077 01234 /* octales */

constante réelle

  1. 97.54 0.1 2e6 -77e-7

...

1.8. Identificateurs

identifie variable, fonction, constante, type...

composé de lettres, de chiffres et de '_', le 1er caractère n'étant pas un chiffre

minuscules et majuscules significatives

ne doit pas être un mot clé

pas de limite de longueur, mais seuls les premiers caractères sont significatifs

nbcol NbCol NBCOL nb_col

déclaration

introduction d'un identificateur dans le programme

précise le type de l'identificateur

définition

un identificateur doit être défini avant d'être utilisé

le compilateur implante l'objet en mémoire

éventuellement suivie d'une initialisation

exemple d'identificateur : les noms des variables

extern int x ; /* déclare une variable entière x */

int x ; /* définit une variable entière */

int x=1 ; /* définit un entier et l'initialise à 1 */

int a=2, b, c=-1 ; /* définit 3 variables entières */

autre exemple d'identificateur : les noms des fonctions

une fonction est définie par son en-tête et son corps

ecrire()

{

puts("bonjour !") ;

}

une fonction se déclare par son en-tête suivi d'un point-virgule

la déclaration d'une fonction est appelée également prototype

ecrire() ; /* prototype de la fonction ecrire */

une fonction est appelée par son nom :

ecrire() ; /* appel de la fonction */

1.9. Structure d'un programme

succession de déclarations et de définitions de fonctions, variables et types

des commentaires et des directives pour le préprocesseur peuvent parsemer le programme

une des fonctions doit s'appeler main

l'exécution du programme = exécution de la fonction main

/* Simple programme C */

/* ------------------ */

#include <stdio.h> /* pour le préprocesseur */

int carre(int) ; /* prototype de la fonction carre */

main() /* définition de la fonction main */

{

int i,j ; /* déclaration des variables */

scanf("%d",&i) ;

j = carre(i) ;

printf("%d\n",j) ;

return 0 ;

}

int carre(int i) /* définition de la fonction carre */

{

return i*i ;

}

C

- 12 -

1.10. La bibliothèque standard

le langage ne dispose pas d'instructions d'entrées/sorties, de gestion de la mémoire, de gestion de fichiers, de calcul mathématique...



on doit faire appel à des fonctions de la bibliothèque standard C

" fonction putchar{XE "putchar"}

putchar ('C') ; /* écrit C sur la console */

" fonction puts{XE "puts"}

puts ("ceci est une chaîne de caractères") ;

/* écrit la chaîne sur la console */

...

  1. Les types de base

le type d'un objet précise :

! le mode de représentation

! la taille mémoire nécessaire à son stockage

! les opérations qui peuvent lui être appliquées types de base et les types dérivés les types de base correspondent aux unités élémentaires de stockage de l'ordinateur

2.1. Les types char, signed char et unsigned char

char est utilisé pour représenter les caractères de l'ordinateur

sa taille est 1 octet

sa valeur est un nombre correspondant au code du caractère dans le jeu de caractères de la machine

les tailles des autres types sont exprimées en terme de multiples de la taille d'un char

sizeof(char) vaut 1

signed char est toujours signé (plage de variation : 0..255)

unsigned char est toujours non signé (plage de variation : -128..127)

char c='A', cc, car=0x02 ;

char nl='\n' ;

unsigned char octet=0x02 ;

2.2. Les types int, unsigned, short et long

int convient à l'arithmétique entière signé

sa taille dépend du processeur employé

int cpt, nbMots=0, i=-123 ;

int est le type implicite en C (compris entre INT_MIN et INT_MAX)

unsigned est synonyme de unsigned int (plage 0..UINT_MAX)

short et long sont également des types entiers

short est synonyme de short int (plage : SHRT_MIN..SHRT_MAX)

long est synonyme de long int (plage de variation : LONG_MIN..LONG_MAX)

static x ; /* x est entier */

const y=11 ; /* y est entier */

unsigned int est non signé

unsigned short (plage de variation : 0..USHRT_MAX)

unsigned long (plage de variation : 0..ULONG_MAX)

unsigned u ;

short int s1, s2 ;

unsigned long ul = 123456 ;

constantes

une constante entière dont la valeur dépasse le plus grand int est de type long

sinon la constante est de type int

une constante immédiatement suivie de la lettre l ou L est de type long

45000, 07L, 0xFFFF, 0xFFFl

2.3. Les types float et double

float représente des valeurs flottantes en simple précision

sa taille est généralement de 32 bits

le type double représente des valeurs à virgule flottante en double précision

sa taille est 2*sizeof(float).

float prix, taxe, total ;

double distance=254.5 ;

2.4. Récapitulatif

type mot machine 32 bits mot machine 64 bits

char 8 bits 8 bits

short 16 bits 16 bits

int 32 bits 32 bits

long 32 bits 64 bits

float 32 bits 32 bits

double 64 bits 64 bits

2.5. Le type void

void indique un ensemble vide de valeur

une fonction de type void ne renvoie pas de valeur

un pointeur sur un type void pointe sur une zone sans type

une liste de paramètres formels égale à void indique une liste vide

  1. Les expressions

3.1. L'expression élémentaire

constante

variable

appel de fonction

3 x f()

3.2. Lvalue

expression localisée en mémoire

une lvalue possède une adresse

une variable est une lvalue

5 n'est pas une lvalue

3.3. L'expression composée

l'opérateur d'affectation

exp1=exp2 est une expression dont la valeur est exp2

la valeur de exp2 est affectée à exp1

a=2 /* cette expression vaut 2, a reçoit la valeur 2 */

a=b=0 /* équivalent à a = (b=0) */

les opérateurs arithmétiques

+ - * / % ++ --

exp1+exp2 , exp1-exp2 , exp1*exp2 , exp1/exp2 et exp1%exp2 sont des expressions dont la valeur est respectivement la somme, la différence, le produit, le quotient et le modulo des valeurs de exp1 et exp2 + et — peuvent être utilisés comme opérateurs unaires

a3 = 2*a2 - a1 +x -z

exp++ est une expression dont la valeur est exp et exp est incrémentée

++exp est une expression dont la valeur est exp+1 et exp est incrémentée

exp-- est une expression dont la valeur est exp et exp est décrémentée

--exp est une expression dont la valeur est exp-1 et exp est incrémentée

a++ --b

x + y++

3++ (2*z)++

int a, b=6 ;

a = ++b ; /* a==7 et b==7 */

a = b++ ; /* a==7 et b==8 */

++b ; /* a==7 et b==9 */

a = --b ; /* a==8 et b==8 */

a = b-- ; /* a==8 et b==7 */

les opérateurs de modification

+= -= *= /= %= ^= |= <<= >>=

exp1 op= exp2 où op est un opérateur a pour valeur exp2

exp1 op= exp2 est équivalente à exp1=exp1 op exp2

z *= 2 /* équivalent à z = z*2 */

x += 1 /* équivalent à x = x + 1 et à x++ */

  1. Le préprocesseur

prépare la source en C pour le compilateur

programme indépendant ou intégré au compilateur

en fonction des directives qu'il rencontre, le préprocesseur traite la source C et génère un texte C intermédiaire

les directives sont éliminées après leur traitement

la source intermédiaire est toujours du C et est ensuite compilée

directive = ligne commençant par #

si le dernier caractère de la ligne est \, la directive continue sur la ligne suivante

une directive peut apparaître n'importe où dans le programme source

6.1. Définir des symboles



#define symbole chaîne_de_remplacement

simple substitution de chaînes de caractères ne faisant pas intervenir les règles syntaxiques du langage C

#define PI 3.141592653589793238462643383279502884197169399

#define PIPI 2*PI

#define BEGIN {

#define END }

#define BIP_BIP BEGIN putchar('\a') ; putchar('\a') ; END

#define BANNIERE "Compilateur C - version 3.01 - 1992"

void main()

BEGIN

puts ( BANNIERE ) ;

...

if ( ... ) BIP_BIP ;

...

END

const double pi = 3.1415926535898 ;

6.2. Supprimer des symboles

#undef symbole

#undef PI

#define PI (355/113)

6.3. Inclure des fichiers

#include <nom_de_fichier>

#include "nom_de_fichier"

les directives #include peuvent être imbriqués.

6.4. Les fichiers en-têtes

stdlib.h traitements courants

stdio.h entrées/sorties

string.h manipulation de chaînes de caractères

ctype.h classification et conversion de caractères

math.h traitements mathématiques

time.h définition des types et des fonctions de manipulation du temps

limits.h définition des caractéristiques de l'implémentation (tailles des types, valeurs extrêmes...)

6.5. Exercice

exercice 4

Compléter le programme factoriel de façon à supprimer tous les avertissements du compilateur.

  1. Les instructions de contrôle

7.1. Les instructions conditionnelles

if ( expression ) instruction

if ( expression ) instruction_1 else instruction_2

if (corps==REEL || corps==COMPLEX)

if ( delta>0 )

puts("2 solutions réelles") ;

else if (delta==0)

puts("1 solution réelle double") ;

else if (corps==COMPLEX)

puts("2 solutions imaginaires") ;

else

puts("pas de solution") ;

else

{

puts("résolution non prévue") ;

exit(1) ;

}

C

- 48 -

7.2. L'instruction sélective

switch ( expression )

{

case expression_constante_1 : instructions_1

case expression_constante_2 : instructions_2

.............

}

switch ( expression )

{

case expression_constante_1 : instructions_1

case expression_constante_2 : instructions_2

.............

default : instructions_n

}

switch ( piece )

{

case 0: puts("pion noir");

break ;

case 1: puts("dame noire");

break ;

case 2: puts("pion blanc");

break ;

case 3: puts("dame blanche");

break ;

default: puts("cas non prévu") ;

exit(1) ;

}

switch ( x )

{

case 'o' :

case 'O' :

ok=1 ;

break ;

case 'n' :

case 'N' :

ok=0 ;

break ;

default :

ok=-1 ;

}

7.3. Les instructions itératives

while

while ( expression ) instruction

scanf("%d",&n) ;

while ( n<0 || n>100 )

{

puts("hors borne") ;

scanf("%d",&n) ;

}

do while

do instruction while ( expression )

do {

scanf("%d",&n) ;

if ( n<0 || n>100 ) puts("hors borne") ;

}

while ( n<0 || n>100 ) ;

for

for ( exp1 ; exp2 ; exp3 ) instruction

exp1

while ( exp2 )

{

instruction

exp3

}

for (i=0 ; i<NB ; i++ ) printf("%d ",i) ;

for ( i=1, j=0 ; i!=0 && i>j ; i*=2, j++ ) { ... }

for (;;) { ... }



444