LA CRÉATION D’UN PROGRAMME
1.1 L’ANALYSE UNE ÉTAPE INDISPENSABLE POUR UN PROJET IMPORTANT
1.2 L’ÉDITEUR
1.3 LE PRÉCOMPILATEUR
1.4 LE COMPILATEUR
1.5 LE LINKER (EDITEUR DE LIEN)
1.6 LE DEBUGGER
1.7 LES COMMENTAIRES
1.7.1 La pertinence des commentaires
1.7.2 En-tête du programme
1.8 PREMIER PROGRAMME
1.9 RÈGLES DE PRÉSENTATION
2 LES VARIABLES
2.1 LES TYPES DE VARIABLES
2.1.1 Le type char
2.1.2 Le type int
2.1.3 Le type short
2.1.4 Le type long.
2.2 NOMBRES DE BITS
2.3 LE TYPE FLOAT (NOMBRE RÉEL)
2.4 DÉCLARATION DE VARIABLES AVEC INITIALISATION;
3 LES CONSTANTES :
4 LES CHAÎNES DE CARACTÈRES (STRINGS)
4.1 LES CARACTÈRES NON IMPRIMABLES
4.2 LA REPRÉSENTATION DES CARACTÈRES RÉSERVÉS À LA SYNTAXE DES STRINGS
4.3 UTILISATION DES CARACTÈRES DE CONTRÔLE
4.4 LE STRING DE 1 CARACTÈRE ET LE CARACTÈRE
5 LES ENTRÉES/SORTIES FORMATÉES
5.1 LA FONCTION DE LIBRAIRIE <STDIO> PRINTF()
5.1.1 Le type de l’affichage d’une valeur numérique
5.1.2 Action sur le format de l’affichage (disposition
5.1.3 Action sur le format de l’affichage ( précision)
5.2 LA FONCTION DE LIBRAIRIE <STDIO>SCANF
5.2.1 Acquisition en une fois de plusieurs variables
5.2.2 Imposition du format maximum
5.2.3 Caractère invalide dans un format :
5.2.4 La valeur de retour de scanf()
6 QUELQUES FONCTIONS DE LIBRAIRIE
6.1 LA FONCTION GETCHAR() <STDIO>
6.2 LA FONCTION DE LIBRAIRIE PUTCHAR() <STDIO>
6.3 LA FONCTION DE LIBRAIRIE STRLEN() <STRING.H>
7 LES OPÉRATEURS LES PLUS USUELS
7.1 L’AFFECTATION
7.2 LES OPÉRATEURS ARYTHMÉTIQUES.
7.3 LES OPÉRATEURS DE COMPARAISON (RELATIONNELS
8 L’INSTRUCTION IF
8.1 L’INSTRUCTION IF ELSE
9 LES OPÉRATEURS LOGIQUES
9.1.1 Deux conditions doivent être réalisées
9.1.2 La conditions 1 ou 2 doit être réalisée
9.1.3 Test avec la condition vraie => différente de 0
9.1.4 Test avec condition non vraie => égale à 0
9.1.5 Remarque sur les parenthèses.
10 L’INCRÉMENTATION ET LA DÉCRÉMENTATION
10.1 LA PRÉ INCRÉMENTATION ET LA PRÉ DÉCRÉMENTATION
10.2 LA POST INCRÉMENTATION ET LA POST DÉCRÉMENTATION
10.3 EXEMPLE AVEC PRÉ-INCRÉMENTATION
10.4 EXEMPLE AVEC POST-INCRÉMENTATION
11 OPÉRATION SUR UNE VARIABLE ET AFFECTATION
11.1 LES OPÉRATEURS D’OPÉRATION/AFFECTATION
12 COMPLÉMENT SUR L’INSTRUCTION IF
12.1 LE IF ELSE SIMPLIFIÉ
12.2 LES IF IMBRIQUÉS
13 LES CONTRÔLES DE FLUX
13.1 LA BOUCLE WHILE (TANT QUE
13.1.1 La boucle while infinie.
13.2 LA BOUCLE DO WHILE (FAIRE TANT QUE)
13.3 LA BOUCLE FOR
13.3.1 Les conditions de la boucle for
13.3.2 Exemple d’une boucle for
13.3.3 La boucle for infinie
13.3.4 La boucle for a plusieurs conditions
13.4 L’INSTRUCTION BREAK (RUPTURE
13.5 L’INSTRUCTION CONTINUE
13.6 L’INSTRUCTION GOTO(ALLER À
13.7 L’INSTRUCTION SWITCH (SÉLECTION)
14 LE TYPE ENUM (ÉNUMÉRÉ
14.1 LE SWITCH ET L’ÉNUMÉRATION
15 LES PROBLÈMES DUS À LA FONCTION SCANF(
15.1 LA MAÎTRISE DE LA CONVERSION DE TYPE
15.1.1 La fonction gets()
15.1.2 La fonction sscanf()
15.2 LA LECTURE AU VOL DU CLAVIER
15.2.1 La fonction kbhit()
15.2.2 La fonction getch()
15.2.3 La fonction putch()
15.2.4 Remarques
16 LES FONCTIONS
16.1 FONCTION SANS PARAMÈTRE
16.1.1 Invocation d’une fonction sans paramètre
16.2 FONCTION AVEC PARAMÈTRES D’ENTRÉE
16.2.1 Invocation d’une fonction avec paramètres d’entrée
16.3 FONCTION AVEC UN PARAMÈTRE DE RETOUR
16.3.1 Invocation avec récupération du paramètre de retour
16.4 FONCTION AVEC PARAMÈTRES D’ENTRÉE ET DE RETOUR
16.4.1 Invocation avec récupération du paramètre de retour
16.5 SORTIE PRÉMATURÉE D’UNE FONCTION SANS PARAMÈTRE DE RETOUR
16.6 SORTIE PRÉMATURÉE D’UNE FONCTION AVEC PARAMÈTRE DE RETOUR
16.7 DOCUMENTATION DES FONCTIONS
17 VARIABLES GLOBALES ET LOCALES
17.1 LES VARIABLES GLOBALES
17.1.1 Durée de vie des variables globales
17.1.2 Documentation des variables globales
17.2 LES VARIABLES LOCALES
17.2.1 Durée de vie des variables locales
17.3 LES VARIABLES LOCALES STATIQUES
17.3.1 Durée de vie des variables locales statiques
17.4 CHOIX DU GENRE DE VARIABLES (GLOBALES, STATIQUES, LOCALES)
17.4.1 L’usage des variables globales doit être minimum
17.4.2 Les variables locales doivent être utilisées au maximum
17.4.3 Le passage de paramètres doit être maximum
17.4.4 Utilisation des variables globales
18 LES PROTOTYPES DES FONCTIONS
18.1 LES PROTOTYPES DES FONCTIONS UTILISATEURS
18.2 LES PROTOTYPES DES FONCTIONS STANDARDS
18.3 LES PROTOTYPES DES FONCTIONS EN PROGRAMMATION MULTI-FICHIERS
19 LES DIRECTIVES DU PRÉPROCESSEUR
19.1 LA DIRECTIVE PRÉPROCESSOR #INCLUDE
19.1.1 L’inclusion des header d’une librairie standard est faite comme suit:
19.1.2 L’inclusion des header des fichiers utilisateur est faite comme suit :
19.2 LA DIRECTIVE PRÉPROCESSOR #DEFINE
19.2.1 #define en tant que définition de symboles alphanumérique
19.2.2 #define en temps que définition de symboles numériques
19.2.3 #define en temps que définition de macro-instructions
19.2.4 #define en temps que définition de macro de macro
19.3 LA DIRECTIVE PRÉPROCESSOR DE COMPILATION CONDITIONNELLE
20 LES TABLEAUX
20.1 DÉCLARATION D’UN TABLEAU À UNE DIMENSION
20.1.1 Accès à un élément du tableau
20.2 DÉCLARATION D’UN TABLEAU À PLUSIEURS DIMENSIONS
20.2.1 Accès à un élément du tableau
20.3 TABLEAUX DE CONSTANTES AVEC INITIALISATION
21 LES STRUCTURES
21.1 DÉCLARATION D’UN GENRE DE STRUCTURE
21.2 RÉSERVATION DE LA MÉMOIRE POUR UNE STRUCTURE
21.3 UTILISATION D’UNE STRUCTURE
21.4 STRUCTURE DE STRUCTURE
21.5 TABLEAU DE STRUCTURES
21.6 STRUCTURE CONTENANT DES TABLEAUX
21.7 REMARQUES
22 LES POINTEURS
22.1 DÉCLARATION D’UN POINTEUR
22.2 INITIALISATION D’UN POINTEUR
22.3 ACCÈS À UNE VARIABLE POINTÉE
22.4 REMARQUE
22.5 APPEL DE FONCTION AVEC PASSAGE DE POINTEURS EN PARAMÈTRES:
22.6 POINTEURS SUR UN TABLEAU
22.6.1 Remarque
22.7 POINTEUR SUR UNE STRUCTURE
22.7.1 Réservation en mémoire
22.7.2 Accès à un élément de la structure par le pointeur
22.8 ARITHMÉTIQUE SUR LES POINTEURS
22.8.1 L’incrémentation des pointeurs
23 STRINGS ET POINTEURS SUR DES STRINGS
24 LE CASTING(CHANGEMENT DE TYPE)
25 LA MANIPULATION DE BITS
25.1 DÉFINITION DE MASQUES
25.2 LES COMPLÉMENTS DE MASQUES
25.3 MISE À UN D’UN BIT (FONCTION OR
25.4 MISE À UN D’UN BIT EN ÉCRITURE COMPACTÉE
25.5 MISE À 0 D’UN BIT (FONCTION &)
25.6 INVERSION D’UN BIT (FONCTION EXCLUSIF OR)
25.7 DÉCALAGE À GAUCHE (MULTIPLICATION PAR UNE PUISSANCE DE 2
25.8 DÉCALAGE À DROITE (DIVISION PAR UNE PUISSANCE DE 2)
25.9 STRUCTURE DE BITS, OPTIMISATION DE LA PLACE MÉMOIRE
25.10 MANIPULATION DU CHAMP DE BITS
25.11 RÉSUMÉ DES OPÉRATEURS DE BITS
25.11.1 Remarques
26 L’UNION
26.1 ACCÈS AUX MÊME DONNÉES SOUS DEUX FORMES DIFFÉRENTES
26.2 ECONOMIE DE LA PLACE MÉMOIRE
26.3 ACCÈS À UN ÉLÉMENT DE L’UNION
26.4 ACCÈS AUX BITS D’UN MON
27 L’ALLOCATION DYNAMIQUE DE LA MÉMOIRE
27.1 LES DANGERS DE L’ALLOCATION DYNAMIQUE DE LA MÉMOIRE
27.2 L’OPÉRATEUR SIZEOF (TAILLE DES DONNÉES
27.3 L’ALLOCATION DE MÉMOIRE DYNAMIQUE MALLOC (STDLIB.H)
27.4 UTILISATION DE LA MÉMOIRE DYNAMIQUE
27.5 LA LIBÉRATION DE LA MÉMOIRE DYNAMIQUE FREE (STDLIB.H)
28 LES FICHIERS
28.1 LES TYPES GÉNÉRAUX DE FICHIERS
28.2 L’ACCÈS DIRECT ET SÉQUENTIEL EN LANGAGE C
28.3 DÉCLARATION D’UN POINTEUR DE FICHIER
28.4 OUVERTURE D’UN FICHIER, FONCTION FOPEN( )
28.4.1 Les mode d’ouverture d’un fichier
28.5 FERMETURE D’UN FICHIER (FCLOSE)
28.6 IMPLÉMENTATION AVEC DISTINCTION DES FICHIER TEXTE OU BINAIRE…
28.7 ECRITURE ET LECTURE DE BLOCS BINAIRE SANS FORMATAGE
28.7.1 Ecriture binaire dans un fichier (fwrite)
28.7.2 Lecture d’un fichier (fread)
28.8 LES FICHIERS ASCII (TEXTE)
28.9 ENTRÉE SORTIE D’UN CARACTÈRE
28.9.1 Ecrit un caractère dans un fichier
28.9.2 Lit un caractère dans un fichier
28.10 ENTRÉE SORTIE D’UN STRING
28.10.1 Ecrit une chaîne de caractères (string) dans un fichier
28.10.2 Lit une chaîne de caractères d’un fichier
28.11 ENTRÉE SORTIE FORMATÉE
28.11.1 La fonction fscanf
28.11.2 La fonction fprintf
28.12 LES FICHIERS PRÉDÉFINIS
28.13 ACCÈS DIRECT DES FICHIERS
28.13.1 Sélection d’un enregistrement
28.13.2 Test de fin de fichier
28.13.3 Position du pointeur dans un fichier
29 LE TYPEDEF
30 LES POINTEURS DE FONCTIONS
30.1 EXEMPLE AVEC UN TABLEAU DE POINTEURS DE FONCTIONS
30.2 PASSAGE D’UN POINTEUR DE FONCTION EN PARAMÈTRE À UNE FONCTION

L’analyse une étape indispensable pour un projet important.

C’est la phase la plus importante lors de la réalisation d’un programme informatique. Un projet important qui ne commence pas par une analyse sérieuse est destiné à de grandes difficultés ou à l’échec. Les coûts de développements de logiciels sont très élevés, le temps investi dans cette analyse permettra de diminuer le temps de développement global.

L’éditeur
Crée les fichiers sources *.c et les fichiers header *.h

Le précompilateur
Il transforme le code source C en code source C pur en exécutant les directives du précompilateur.

Le compilateur
Il transforme le code C pur en code objet relogeable *.obj

Le linker (Editeur de lien)
Il relie les fichiers objets et les librairies utilisateurs et systèmes pour créer le fichier exécutable *.exe

Le debugger
Permet de tester le programme.

Les commentaires
Il existe deux méthodes pour écrire des commentaires en C. Le commentaire délimité par /* indiquant le début et */ indiquant la fin du commentaire qui peut être sur plusieurs lignes.
/* J’affirme que cette ligne est un commentaire pouvant se répartir sur plusieurs lignes.*/ Il est aussi possible d’avoir un commentaire se terminant par la fin de ligne. (attention, ne fonctionne par sur tous les compilateurs).
// Ce commentaire se termine à la fin de la ligne.
// Il ne fonctionne pas sur tous les compilateurs (issu du C++)

La pertinence des commentaires
Documenter un programme est une nécessité. Cette documentation doit permettre de comprendre pour pouvoir exécuter des modifications et des corrections de bugs éventuels.

En-tête du programme.
Le programme doit commencer par un en-tête, il doit comprendre au minimum le nom de l’entreprise, l’auteur du programme, le nom du fichier, la description du projet, la date de création, les versions avec une description des modifications ainsi que la date.

Premier programme
/*******************************************************************
Fichier: PrPrg.cpp
Auteur: JMC
Description: Premier exemple de programme
Version: 1.0
Modifications: pas de modification
*******************************************************************/
#include <stdio.h> // accès à la librairie standard input/output
/*******************************************************************
programme principal
*******************************************************************/
void main (void) // fonction main obligatoire
{ // début de bloc
unsigned char MonChar; // Variable locale de type caractère
printf(« Voulez vous afficher Hello ? [O/N] \n »);
MonChar = getchar(); // lecture d’un caractère du clavier
if(MonChar == ‘O’) // test si le caractère lu est O
printf(« Hello »); // Si O => Affichage à écran
} // fin de bloc
/*******************************************************************
end
*******************************************************************/

Règles de présentation
L’écriture en C est très compacte. Il faut tout faire pour rendre le programme le plus lisible possible. Pour faciliter la compréhension des logiciels, beaucoup d’entreprises éditent des règles de codage interne. Voici quelques règles de présentation des programmes.
•Avoir une présentation cohérente tout au long du projet
•Aligner dans la verticale les accolades de début et fin de bloc
•Indenter les lignes à l’intérieur d’un bloc
•Ne pas mélanger sur une même ligne un test et une instruction.
•Ecrire une seule instruction par ligne.

Les variables

Les variables permettent de stocker les données en RAM. Par défaut les variables sont signées Pour gagner un bit supplémentaire on peut déclarer des variables non signées en ajoutant le préfixe unsigned. Tous les types de variables permettent d’effectuer des calculs ou des opérations logiques.
Attention : Les tailles des variables peuvent changer en fonction de l’implémentation Il faut vérifier la taille dans la documentation du compilateur.

Les types de variables
Le type char
Elle peut contenir au minimum 1 caractère du système.
char peut être utilisé pour des opérations arithmétiques.Si les caractères sont en ASCII => char est un byte (octet).
char ma_data; // ou signed char)
unsigned char ma_data; //

….

Si le lien ne fonctionne pas correctement, veuillez nous contacter (mentionner le lien dans votre message)
La pratique du langage C (405 KO) (Cours PDF)