Module 1

Langage C - Niveau 1
Prsentation du langage
Campus-Booster ID : 664
www.supinfo.com
Copyright SUPINFO.
All rights reserved
Langage C Niveau 1
Objectifs de ce module
En suivant ce module vous allez:
Connatre lvolution des langages de programmation
Apprendre les principes de base du dveloppement dun programme en C
Dcouvrir le compilateur GCC et lenvironnement de dveloppement Visual Studio 2005
Langage C Niveau 1
Plan du module
Voici les parties que nous allons aborder:
Prsentation du langage Les donnes Les oprations de base Les structures de contrle
Langage C Niveau 1
Plan de la partie
Voici les chapitres que nous allons aborder: Famille de langage Historique et volution Principes de dveloppement en C Prsentation des environnements de dveloppement Structure dun programme C Note sur cette partie
Famille de langage Historique et volution

Avant 1950 : Programmation par cblage

1950 : Invention de lassembleur
Maurice V. Wilkes

1951 : Mise au point du A-0
Grace Hopper

1954 : Cration du FORTRAN
John Backus

1958 : ALGOL

1958 : Cration du LISP
John McCarthy

1959 : Cration du COBOL

1964 : BASIC
John Kemeny et Thomas Kurtz

1968 : Pascal
Niklaus Wirth

1972 : PROLOG
Alain Colmerauer
Robert Kowalski

Contexte de la naissance du langage C Projet MULTICS Connecter plusieurs ordinateurs Difficults techniques Mise en production au MIT UNICS inspir de MULTICS UNIX

1973 : Naissance du langage C
Ken Thompson
Dennis Ritchie
Brian Kernighan

Dveloppement et normalisation 1978 : The C Programming Language Grand succs ANSI C (C89) C90 ISO/IEC 9899:1999 (support limit)

1979 : ADA
Jean D. Ichbiah

1986 : C++
Bjarne Stroustrup

1995 : Java
James Gosling

2000 : C#
Anders Hejlsberg

Synthse Diffrentes gnrations de langages 1re gnration Langage machine 2me gnration Assembleur 3me gnration FORTRAN, ALGOL, Pascal, C 4me gnration RAD : Visual Studio, Delphi,

Synthse Diffrents types de langages Procduraux C, C++, PASCAL, FORTRAN Dclaratif ou logique PROLOG Fonctionnel LISP, CAML

Synthse Principaux avantages du langage C Efficacit Portabilit Diffusion Proche de la machine

Synthse Principaux inconvnients du langage C Permissivit Erreurs difficiles dtecter Possibilit de code illisible
Principes de dveloppement en C
La structure dun code C
1 2 3 4
Analyse du problme. Concevoir les algorithmes. Spcifier les structures de donnes. Ecrire le code source.
Du code source au fichier excutable
Source Prprocesseur Lorsque le code source est saisi, on lance le processus qui va nous permettre d'obtenir un excutable. Ce processus se droule en 3 phases.
Source modifi
Compilateur
Fichier objet
Editeur de liens
Fichier excutable
Cas dun code C sur plusieurs fichiers
Compilation de plusieurs fichiers sources
Sources Prprocesseur Lorsque le code source est saisi, on lance le processus qui va nous permettre d'obtenir un excutable. Ce processus se droule en 3 phases.
Source modifi
Compilateur
Fichier objet
Editeur de liens
Fichier excutable
Utilisation de bibliothques
Compilation faisant intervenir une bibliothque
Sources Prprocesseur Lorsque le code source est saisi, on lance le processus qui va nous permettre d'obtenir un excutable. Ce processus se droule en 3 phases.
Source modifi
Compilateur
Fichier objet
Biblio.
Editeur de liens
Fichier excutable
Prsentation des environnements de dveloppement

Le compilateur GCC Prsent dans la plupart des distributions Linux Ligne de commande Fichier makefile

Principales options du compilateur GCC -o gcc source.c o executable -c gcc c source.c o binaire.o

Remarques sur le compilateur GCC Compilation spare gcc -c source2.c -o bin2 gcc -c source3.c -o bin3 gcc -c source1.c bin2.o bin3.o -o exec
Extension des fichiers source (.c)

Microsoft Visual Studio 2005 Environnement de dveloppement intgr de Microsoft Permet de programmer en plusieurs langages : Visual Basic .NET C# C++ C

Microsoft Visual Studio 2005
Excuter Compile, excute et dbogue le programme.
Structure dun programme C

La notion dinstruction Programme constitu dun ensemble dinstructions Instruction termine par un point-virgule ;
Instruction 1; ... Instruction 2;

La notion de bloc Ensemble dinstructions dlimit par des accolades Chaque sous-bloc est considr comme une instruction
Bloc dinstructions
Fonction { instruction 1; instruction 2; { instruction 3; instruction 4; } }
Sous-bloc dinstructions

Les commentaires Ne sont pas analyss Aident la comprhension du code 2 types : /* ... */ et // /***************************/ /* Projet X Auteur: S.B. */ /* Date : 03/09/82 */ /***************************/ instruction 1; // commentaire instruction 2;
Ce texte nest pas analys

La fonction principale : main Point dentre de lapplication
/***************************/ /* Mon premier programme */ /* Date : 03/09/82 */ /***************************/ main () { 10 + 20; }
// instruction
Note sur cette partie
nexes An 1.1.2 1. 1 e t 1.
Langage C Niveau 1
Les donnes
Les donnes
Plan de la partie
Voici les chapitres que nous allons aborder: Les variables Les types Laffectation Les conversions implicites Loprateur sizeof Les constantes Note sur cette partie
Les donnes
Les variables
La notion de variable Zone de mmoire Stockage dinformation Nomme a-z, A-Z, 0-9, _ Ne commence pas par un chiffre Doit tre dclare Doit avoir un type type nomDeLaVariable;
Les donnes
Les variables
Dclaration des variables C89 (ANSI) : Au dbut dun bloc C90 (ISO) : Nimporte o Cours : Norme ANSI
Les donnes
Les variables
Conventions de nommage Constantes #define CONSTANTE enum { Constante } Noms vocateurs var1 nomUtilisateur Plusieurs termes deux_mots, deuxMots
Les donnes
Les types
Les types char, unsigned char char 8 bits signs -128 127 Table ASCII-7 unsigned char 8 bits non-signs 0 255 unsigned char monCar; char monCaractere;
Les donnes
Les types
Les types short, unsigned short short 8/16 bits signs (selon architecture et/ou OS) -128 127 -32 768 32 767 unsigned short 0 255 0 65 535 unsigned short monSh; short monShort;
Les donnes
Les types
Les types int, unsigned int int 16/32 bits signs (selon int monInt; architecture et/ou OS) -32 768 32 767 -2 147 483 648 2 147 483 647 unsigned int 0 65 535 0 4 294 967 295 unsigned int monInt;
Les donnes
Les types
Les types long, unsigned long long 32 bits signs -2 147 483 648 2 147 483 647 unsigned long 0 4 294 967 295 unsigned long monLon; long monLong;
Les donnes
Les types
Les types long long, unsigned long long long long 64 bits signs -9 223 372 036 854 775 808 9 223 372 036 854 775 807 unsigned long long
0 18 446 744 073 709 551 615 unsigned long monLon;
long monLong;
Les donnes
Les types
Le type float Format IEEE 754 32 bits 0-22 : 23-30 : 31 : Valeurs entre : 2-126 (2 2-23)2127 mantisse exposant signe float monFloat;
Les donnes
Les types
Le type double Format IEEE 754 64 bits 0-51 : 52-62 : 63 : Valeurs entre : 2-1022 (2 2-52)21023 mantisse exposant signe double monFloat;
Les donnes
Les types
Le type long double Format IEEE 754 80 bits 0-63 : 64-78 : 79 : Valeurs entre : 2-32766 (2 2-64)232767 Pas support par le C89 mantisse exposant signe long double monLongD;
Les donnes
Les types
Le type void Type vide Ne sert pas typer des variables Utilisations : Pointeurs Dclarations de fonctions void* monPointeur; void maFonction(void)
Les donnes
Laffectation
Affectation dune valeur une variable Aprs dclaration affectation Oprateur = Conseill dinitialiser ds la cration int a; a = 10; int b = 0;
Les donnes
Laffectation
Le cas des nombres entiers Base 10 int val = 128; Base 8 int val = 0200; Base 16 int val = 0x80;
Les donnes
Laffectation
Le cas des nombres virgule flottante Notation simple double val = 23.3; Notation scientifique float val = 7.45E-27; float val = 7.45e-27;
Les donnes
Laffectation
Les suffixes
Type long unsigned unsigned long L U UL
Suffixe
Exemple 10L 0x4U 24UL
Les donnes
Laffectation
Le cas des caractres Utilisation dapostrophes ('') Caractres affichables char carac = 'G'; Caractres non-affichables char carac = '\t';
Les donnes
Laffectation
Le cas des caractres Caractres spciaux utiles : '\n' '\r' '\t' '\0' '\\' '\'' '\"' '\x41' Nouvelle ligne Retour chariot Tabulation horizontale Caractre nul Backslash Apostrophe Guillemet Caractre ASCII 41 (A)
Les donnes
Les conversions implicites

Hirarchie de types unsigned char short unsigned short int unsigned int long unsigned long float double long double char
Les donnes

Conversions dun type lautre Affectation des valeur dun type des variables dun autre : int a = 8; double b = a;
// b = 8
Pas de problmes en descendant la pyramide, mais dans le sens inverse : float c = 0.32; long d = c;
// d = 0
Les donnes

Donnes tronques Exemple : unsigned long a = 65523; unsigned char b = a; // b = 243 Explication : 6552310 = 1111 1111 1111 00112
24310 = 1111 00112
Les donnes
Loprateur sizeof
Rcuprer la taille dune donne ou dun type Fonction sizeof
int taille = sizeof(char); // retourne 1
Les donnes
Les constantes
Les constantes dfinies par #define Directive du prprocesseur #define CST 20 Nest pas une instruction Pas de point-virgule Pas doprateur = La premire chane de caractres sera remplac par la seconde avant la compilation
Les donnes
Les constantes
Les constantes dfinies par const Instruction du compilateur const double CST = 20.3; Instruction Point-virgule Oprateur = La constante reoit une lors de la compilation et est ensuite protge contre dautres modifications Ne fait pas partie de la norme ANSI
Les donnes
nexes An 1.2.2 2. 1 e t 1.
Langage C Niveau 1
Les oprations de base
Plan de la partie
Voici les chapitres que nous allons aborder: La notion dexpression Les oprations arithmtiques Les oprations logiques Les oprateurs relationnels Le transtypage Les expressions complexes et les priorits entre oprateurs Note sur cette partie
La notion dexpression
Expression combinaison dun oprateur et dune ou deux donnes. Le rsultat de lvaluation dune expression peut devenir une oprande pour une expression englobante.
Les oprations de bases
La notion dexpression
Exemple int a = 10 + 3;
Expression 1
10 + 3
Expression 2
a = 13
Les oprations arithmtiques

Les oprateurs Oprateur Opration Addition Signe / Soustraction Multiplication Division Reste division (modulo) float a = 10; float b = 20; float c = a * b;
+ * / %

Les conversions implicites Exemple : int a = 10; long b = 20; double c = a * b;
1 2 3 4
a long a * b (long) a * b double c = 200.0

Les oprateurs combins Oprateur Opration Addition Soustraction Multiplication Division Reste division (modulo)
+= = *= /= %=
int a = 10; a += 20; // a = a + 20

Les oprateurs dincrmentation et dcrmentation Oprateur Opration Incrmentation Dcrmentation
++
int a = 0; a++; // a = 1 a--; // a = 0

Pr-incrmentation, Post-incrmentation Pr-dcrmentation, Post-dcrmentation Post int a = 1; int b = 2; int c = a++ * b; Pr int a = 1; int b = 2; int c = -a * b;
1 2
c = a * b a = a + 1
1 2
a = a - 1 c = a * b
Les oprations logiques

Les oprateurs Oprateur Opration Et logique Ou logique Ou exclusif logique Ngation logique Dcalage (shift) gauche Dcalage (shift) droite Oprateurs combins
& | ^ ~ << >>

&=, |=, ^=, <<=, >>=

Quelques exemples & char a = 10; char b = 12; char c = a & b; 1010 (a = 10) & 1100 (b = 12) -----1000 (c = 8) ^ et ~ char a = ~10; char b = 12; char c = a ^ b; 1010 -----0101 ^ 1100 -----1001 (10) (a = ~10 = 5) (b = 12) (c = 9)

Quelques exemples << char a = 10; char b = a << 2; >> char a = 10; char b = a >> 2;
1 1 0 0 0
a = 10 b 8
a 10 b = 2
1 0 0 1 0
Remarquez les pertes de donnes !
Les oprations relationnelles

Les oprateurs Oprateur Opration Egalit Ingalit Strictement suprieur Strictement infrieur Suprieur ou gal Infrieur ou gal
== != > < >= <=

Exemples int a = 10; int b = 3; int c;
c = a == b c = a != b c = a > b c = a < b c = a >= b c = a <= b
relation fausse, c = 0 relation vraie, c = 1 relation vraie, c = 1 relation fausse, c = 0 relation vraie, c = 1 relation fausse, c = 0

Les oprateurs Oprateur Opration Et logique Ou logique Ngation logique
&& || !
int a = 10; int b = 3;
int c = (a != b && a > b); // c = 1 car 10 != 3 ET 10 > 3
Le transtypage
Conversion implicite int a = 10; long b = a;
Conversion explicite (cast) (typeSouhait)donne char a = 10; double b = (double)a;
Les expressions complexes et les priorits entre oprateurs
Lopration daffectation Evaluation dune expression R-value : Droite de laffectation Partie value L-value : Gauche de laffectation Partie qui reoit le rsultat de la R-value
Les expressions complexes et les priorits entre oprateurs
Priorit des oprateurs
( ) ! ~ ++ sizeof * / % + >> << < > <= => == != & | && || =
nexes An 1. 3. 2 .3.1, 1 1.3.3 et
Langage C Niveau 1
Les structures de contrle
Plan de la partie
Voici les chapitres que nous allons aborder: Lintrt des structures de contrle if else et loprateur conditionnel (?) switch case et le break while do while for et loprateur squentiel (,) Le break, le continue et les boucles Les labels et linstruction goto Note sur cette partie
Lintrt des structures de contrle

Excution squentielle Restrictif Structures de contrle Sauts dans le programme Types de structures de contrle Sauts Conditionnels Boucles Saut Inconditionnels
if else et loprateur conditionnel (?)

if else if (condition) instruction1; else instruction2;
condition : vrai (!0) ou faux (0) instruction1 : Excute si condition vraie instruction2 : Excute si condition fausse

Mode de fonctionnement de la structure ifelse
Dbut
oui condition !=0 non instruction2 Fin instruction1

Exemple : if else int a = 10; if (a > 5) // Test 1 { printf ("a > 5"); // Si 1er test positif } else if (a < 5) // Test 2 { printf ("a < 5"); // Si test 1 ng. et // test 2 positif } else printf ("a == 5"); // Si tests 1 et 2 ng.

Loprateur conditionnel (?)
Nest pas une structure de contrle Dans certains cas, peut remplacer une structure if...else
(condition) ? (valeur si vrai) : (valeur si faux);

Exemple : oprateur conditionnel
int a = 10; int b = 20; int min = (a < b) ? a : b; // Si a < b, loprateur renvoie a, sinon b // ici min = 10
switch case et le break

switch case
variable : entier CONSTANTE_i : dfinies lors de la compilation dterminent sur quelle instruction brancher default : cas par dfaut
switch (variable) { case CONSTANTE_1: instruction1; break; case CONSTANTE_2: instruction2; default: instruction3; }

Dbut
Mode de fonctionnement de la structure switchcase

oui instruction1 break oui instruction2
valeur == CONSTANTE_1 non valeur == CONSTANTE_2 non
instruction3
Fin

Exemple : switch case switch (a) // Variable tester { case 1: case 2: // Instructions excuter si a = 1 ou 2 break; case 3: // Instructions excuter si a = 3 break; // case 4 + b: Erreur car 4 + b pas constant default: // Instructions excuter autrement }
while
La boucle while
while (condition) instruction;
condition : vrai (!0) ou faux (0) instruction : Tant que condition vraie
while
Dbut
Mode de fonctionnement de la structure while
oui condition != 0 non instruction
Fin
while
Exemple :
int i = 0; while (i < 10) // Condition tester { printf("%d\n", i); // Ecrit i lcran i++; } // Ecrit lcran les chiffres 0 9
do while
La boucle dowhile
do instruction; while (condition);

condition : vrai (!0) ou faux (0) instruction : Excute au moins une fois Et tant que condition vraie
do while
Dbut
Mode de fonctionnement de la structure dowhile
instruction
oui condition != 0 non
Fin
do while
Exemple :
int i = 11; do { printf("%d\n", i); i++; } while (i < 10); // Ecrit i lcran // Condition tester
// Ecrit lcran le chiffre 11
for et loprateur squentiel (,)

La boucle for for (initialisation; condition; modification) instruction;
Variable d'itration initialisation : affectation de valeur la variable condition : vrai (!0) ou faux (0) modification : Modification de la variable ditration

Dbut
Mode de fonctionnement de la structure for
initialisation
oui condition != 0 non instruction modification
Fin

Exemple :
int i; for (i = 10; i < 100; i += 10) { printf("%d\n", i); // Ecrit i lcran } // Ecrit lcran les chiffres de 10 90 // avec un pas de 10

Loprateur squentiel (,)
initialisation et modification peuvent contenir plusieurs instructions
Spares par des virgules (,)
int i, j; for (i = 1, j = 2; (i < 4)&&(j < 10); i++, j += 2) printf ("i=%u et j=%u\n", i, j);
Le break, le continue et les boucles

Linstruction break et les boucles Permet de quitter la boucle prmaturment int i, j = 0; for (i = 0; i < 10; i++) { if (j > 4) // on quite la boucle break; j++; }
Le break, le continue et les boucles

Linstruction continue et les boucles Permet de passer litration suivante dans une boucle int i, j = 0; for (i = 0; i < 10; i++) { if (j == 4) continue; // la suite ne sera pas // excute si j == 4 j++; }
Les labels et linstruction goto

Label : tiquette identifiant une instruction
goto permet de sauter inconditionnellement vers un label
Utilisation fortement dconseille
// boucle infinie mon_label: instruction_1; instruction_2; goto mon_label;
nexes An . 4. 2 , 4. 1, 1 1. . 4. 4 , 4. 3, 1 1. 1. 4. 6 , 1.4.5, . 4. 8 , . 7, 1 1.4 1.4.10 4. 9 e t 1.
Rsum du module
Reprsentation Reprsentation des donnes des donnes en C en C
Structures Structures de contrle de contrle
Historique des Historique des langages de langages de programmation programmation
Prsentation Prsentation des des environnements environnements de de dveloppement dveloppement
Oprateurs de base Oprateurs de base
Pour aller plus loin

Si vous voulez approfondir vos connaissances:
Publications Modules de cours
Langage C Niveau 2 Langage C Niveau 3 Langage C Niveau 4 Langage C Niveau 5 Langage C Niveau 6
Le langage C : Norme ANSI
Flicitations
Vous avez suivi avec succs le module de cours Langage C - Niveau 1
Fin

Module 1

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Module 1

Загружено:

Авторское право:

Доступные форматы

Langage C - Niveau 1

All rights reserved

Apprendre les principes de base du dveloppement dun programme en C

Dcouvrir le compilateur GCC et lenvironnement de dveloppement Visual Studio 2005

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

John Kemeny et Thomas Kurtz

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Famille de langage Historique et volution

Prsentation des environnements de dveloppement

Prsentation des environnements de dveloppement

Prsentation des environnements de dveloppement

Extension des fichiers source (.c)

Prsentation des environnements de dveloppement

Prsentation des environnements de dveloppement

Structure dun programme C

Instruction 1; ... Instruction 2;

Structure dun programme C

Fonction { instruction 1; instruction 2; { instruction 3; instruction 4; } }

Structure dun programme C

Ce texte nest pas analys

Structure dun programme C

/***************************/ /* Mon premier programme */ /* Date : 03/09/82 */ /***************************/ main () { 10 + 20; }

Note sur cette partie

Type long unsigned unsigned long L U UL

Exemple 10L 0x4U 24UL

Les conversions implicites

Les conversions implicites

Les conversions implicites

24310 = 1111 00112

int taille = sizeof(char); // retourne 1

Note sur cette partie

Les oprations de base

Les oprations de base

Les oprations de base

Les oprations de bases

Les oprations de base

Les oprations arithmtiques

Les oprations de base

Les oprations arithmtiques

a long a * b (long) a * b double c = 200.0

Les oprations de base

Les oprations arithmtiques

int a = 10; a += 20; // a = a + 20

Les oprations de base

Les oprations arithmtiques

int a = 0; a++; // a = 1 a--; // a = 0

/***************************/ /* Mon premier programme / / Date : 03/09/82 */ /***************************/ main () { 10 + 20; }