caractéristiques du langage C

Le fichier source

Le fichier source d'un programme écrit en langage C est un simple fichier texte dont l'extension est par convention .C.
Ce fichier source doit être un fichier texte non formattés, c'est-à-dire un fichier texte dans sa plus simple expression, sans mise en forme particulière ou caractère spéciaux, c'est-à-dire qu'il contient uniquement les caractères ASCII de base.

Lorsque le programme est prêt à être "essayé", il s'agit de le compiler (le traduire en langage machine).
De nombreux compilateurs C existent: sous les systèmes de type UNIX par exemple, le compilateur C est fourni en standard, si bien que la programmation en langage C est aisé sous ce type de système. La compilation sous UNIX se fait par la ligne de commande suivante:

cc fichier.c

Aspect d'un programme en C

Un programme écrit en langage C, comporte principalement une fonction principale appelée main() renfermant les instructions qui doivent être exécutées. Celles-ci sont comprises entre des accolades qui suivent le nom de la fonction. Cela vous semble tombé du ciel si vous n'avez jamais programmé en C, mais il faut admettre pour l'instant la manière d'écrire un programme en C. La finalité de cette écriture vous sera dévoilée au cours des chapitres suivants...

Un programme C de base ressemblera donc à ceci:

main()
{
printf("Ceci est votre premier programme");
}

Le programme présenté ci-dessus contient donc une fonction principale main() (qui, rappelons-le, est essentielle car c'est par cette fonction que le programme débute son exécution) contenant une instruction imprimant à l'écran le message "Ceci est votre premier programme" grâce à la fonction printf()

Typologie

La manière d'écrire les choses en langage C a son importance. Le langage C est par exemple sensible à la casse (en anglais case sensitive), cela signifie qu'un nom contenant des majuscules est différent du même nom écrit en minuscules. Ainsi, les spécifications du langage C précisent que la fonction principale doit être appelée main() et non Main() ou MAIN().

De la même façon, on remarquera que la fonction printf() est écrite en minuscules.
D'autre part, l'instruction printf() se termine par un point-virgule. Ce détail a son importance, car en langage C, toute instruction se termine par un point-virgule.

Ajout de commentaires

Lorsqu'un programme devient long est compliqué il peut être intéressant (il est même conseillé) d'ajouter des lignes de commentaires dans le programme, c'est-à-dire des portions du fichier source qui ont pour but d'expliquer le fonctionnement du programme sans que le compilateur ne les prennent en compte (car il génèrerait une erreur).

Pour ce faire, il faut utiliser des balises qui vont permettre de délimiter les explications afin que le compilateur les ignore et passe directement à la suite du fichier.
Ces délimiteurs sont

/* et */

Un commentaire sera donc noté de la façon suivante:

Voici un commentaire!

Il y a toutefois quelques règles à respecter:


* Les commentaires peuvent être placés n'importe où dans le fichier source
* Les commentaires ne peuvent contenir le délimiteur de fin de commentaire (*/)
* Les commentaires ne peuvent être imbriqués
* Les commentaires peuvent être écrits sur plusieurs lignes
* Les commentaires ne peuvent pas couper un mot du programme en deux

Définition du préprocesseur

dans les chapitres précédents, un programme simple vous a été présenté, il s'agit du programme suivant:

main()
{
printf("Ceci est votre premier programme");
}

Dans ce programme la fonction principale main() contient une fonction appelée printf() qui a pour but d'afficher le message "Ceci est votre premier programme". En réalité le compilateur ne connait pas la fonction printf() bien qu'il s'agisse d'une fonction standard du langage C. Cette fonction est effectivement stockée dans un fichier annexe, contenant une libraie de fonctions, appelé fichier de définition (éventuellement fichier d'en-tête ou fichier header), dont l'extension est .h.
Il s'agit donc de préciser au compilateur dans quel fichier se trouve la définition de la fonction printf()...

Celle-ci se trouve dans le fichier d'en-tête appelé stdio.h.
La désignation stdio signifie Standard Input Output (en français Entrées Sorties standards), c'est-à-dire que ce fichier contient la définition de nombreuses fonctions permettant l'entrée (saisie au clavier, ...) et la sortie (affichage, sortie dans un fichier, ...) de données, dont la fonction stdio.h fait partie.

L'incorporation de la déclaration de la fonction printf() se fait au moyen de l'instruction #include (que l'on place par convention en début de fichier) suivie des balises < et > contenant le nom de fichier contenant la définition de la fonction.
Le programme ci-dessus pour pouvoir être compilé doit donc s'écrire:


#include

main()
{
printf("Ceci est votre premier programme");
}

Le fichier est maintenant apte à être compilé. Il existe d'autres commandes du préprocesseur qui seront détaillées dans ce cours.

Les instructions dédiées au préprocesseur ne se terminent pas par un point-virgule!

Phases de compilation

La compilation se fait généralement en plusieurs phases:

* le compilateur transforme le code source en code objet, et le sauvegarde dans un fichier objet, c'est-à-dire qu'il traduit le fichier source en langage machine (certains compilateurs créent aussi un fichier en assembleur, un langage proche du langage machine car possédant des fonctions très simples, mais lisible)
* le compilateur fait ensuite appel à un éditeur de liens (en anglais linker ou binder) qui permet d'intègrer dans le fichier final tous les éléments annexes (fonctions ou librairies) auquel le programme fait référence mais qui ne sont pas stockés dans le fichier source.
Puis il crée un fichier exécutable qui contient tout ce dont il a besoin pour fonctionner de façon autonome, le fichier ainsi créé possède l'extension .exe

Dans le cas du langage C, une phase supplémentaire apparaît, il s'agit du traitement du fichier par le préprocesseur C, un programme permet d'inclure dans le fichier source les éléments référencés par les instructions situées au début du fichier source (instructions précédées du caractère #). C'est donc le préprocesseur qui ajoutera dans le fichier source la définition de la fonction printf() qu'il sera allé chercher dans le fichier stdio.h grâce à l'instruction #include.

Les phases de compilation dans le cas d'un compilateur C sont donc les suivantes:

Les types de données

Les données manipulées en langage C sont typées, c'est-à-dire
que pour chaque donnée que l'on utilise (dans les variables par exemple)
il faut préciser le type de donnée, ce qui permet de connaître l'occupation mémoire
(le nombre d'octets) de la donnée ainsi que sa représentation

• des nombres: entiers (int) ou réels, c'est-à-dire à virgules (float)
  
• des pointeurs (pointer): permettent de stocker l'adresse d'une autre donnée, ils "pointent" vers une autre donnée
  

En C il existe plusieurs types entiers, dépendant du nombre d'octets sur lesquels
ils sont codés ainsi que de leur format, c'est-à-dire si ils sont signés
(possédant le signe - ou +) ou non. Par défaut les données sont signées.

Voici un tableau donnant les types de données en langage C:

Type de donnée	Signification	Taille (en octets)	Plage de valeurs acceptée
char	Caractère	1	-128 à 127
unsigned char	Caractère non signé	1	0 à 255
short int	Entier court	2	-32768 à 32767
unsigned short int	Entier court non signé	2	0 à 65535
int	Entier	2	-32768 à 32767
unsigned int	Entier non signé	2	0 à 65535
long int	Entier long	4	-2 147 483 648 à 2 147 483 647
unsigned long int	Entier long non signé	2	0 à 4 294 967 295
float	flottant (réel)	4	3.4*10-38 à 3.4*1038
double	flottant double	8	1.7*10-308 à 1.7*10308
long double	flottant double long	10	3.4*10-4932 à 3.4*104932

Nombre entier (int)

Un nombre entier est un nombre sans virgule qui peut être exprimé dans
différentes bases:

• Base décimale: L'entier est représenté par une suite de chiffre unitaires (de 0 à 9)
  ne devant pas commencer par le chiffre 0
  
• Base hexadécimale: L'entier est représenté par une suite d'unités (de 0 à 9 ou de A à F (ou a à f))
  devant commencer par 0x ou 0X
  
• Base octale: L'entier est représenté par une suite d'unités (incluant uniquement des chiffres de 0 à 7)
  devant commencer par 0
  

Les entiers sont signés par défaut, cela signifie qu'ils comportent un signe.
Pour stocker l'information concernant le signe (en binaire), les ordinateurs utilisent le complément à deux

Nombre à virgule (float)

Un nombre à virgule flottante est un nombre à virgule, il peut toutefois
être représenté de différentes façons:

• un entier décimal: 895
  
• un nombre comportant un point (et non une virgule): 845.32
  
• une fraction: 27/11
  
• un nombre exponentiel, c'est-à-dire un nombre (éventuellement à virgule)
  suivi de la lettre e (ou E), puis d'un entier correspondant à la puissance de 10
  (signé ou non, c'est-à-dire précédé d'un + ou d'un -)
  
  2.75e-2
  
  35.8E+10
  
  .25e-2
  

En réalité, les nombres réels sont des nombres à virgule flottante,
c'est-à-dire un nombre dans lequel la position de la virgule n'est pas fixe, et est
repérée par une partie de ses bits (appelée l'exposant),
le reste des bits permettent de coder le nombre sans virgule (la mantisse).

Les nombres de type float sont codés sur 32 bits dont:

• 23 bits pour la mantisse
  
• 8 bits pour l'exposant
  
• 1 bit pour le signe
  

Les nombres de type double sont codés sur 64 bits dont:

• 52 bits pour la mantisse
  
• 11 bits pour l'exposant
  
• 1 bit pour le signe
  

Les nombres de type long double sont codés sur 80 bits dont:

• 64 bits pour la mantisse
  
• 15 bits pour l'exposant
  
• 1 bit pour le signe
  

La précision des nombres réels est approchée. Elle dépend
par le nombre de positions décimales, suivant le type de réel elle sera au moins:

• de 6 chiffres après la virgule pour le type float
  
• de 15 chiffres après la virgule pour le type double
  
• de 17 chiffres après la virgule pour le type long double
  

Caractère (char)

Le type char (provenant de l'anglais character) permet de stocker la valeur
ASCII d'un caractère, c'est-à-dire un nombre entier!



Par défaut les nombres sont signés, cela signifie qu'ils comportent un signe.
Pour stocker l'information concernant le signe (en binaire), les ordinateurs utilisent le complément à deux.
Une donnée de type char est donc signée, cela ne signifie bien sûr pas que la lettre
possède un signe mais tout simplement que dans la mémoire la valeur codant le caractère peut-être
négative...

Si jamais on désire par exemple stocker la lettre B (son code ASCII est 66), on pourra
définir cette donnée soit par le nombre 66, soit en notant 'B' ou les apostrophes
simples signifient code ascii de...



Il n'existe pas de type de données pour les chaînes de caractères (suite de caractère)
en langage C. Pour créer une chaîne de caractère on utilisera donc des tableaux contenant
dans chacune de ses cases un caractère...

Créer un type de donnée

Il est possible en C de définir un nouveau type de données
grâce au mot clé typedef. Celui-ci admet la syntaxe suivante:

typedef Caracteristiques_du_type Nom_du_type
où

• Caracteristiques_du_type représente un type de données existant (par exemple float, short int, ...)
  
• Nom_du_type définit le nom que vous donnez au nouveau type de donnée
  

Ainsi l'instruction suivante crée un type de donnée Ch calqué sur le type char
typedef char Ch

Conversion de type de données

On appelle conversion de type de données le fait de modifier le type
d'une donnée en une autre. Il peut arriver par exemple que l'on veuille travailler
sur un type de variable, puis l'utiliser sous un autre type. Imaginons que l'on travaille
par exemple sur une variable en virgule flottante (type float), il se peut que l'on
veuille "supprimer les chiffres après la virgule", c'est-à-dire
convertir un float en int. Cette opération peut être réalisée
de deux manières:

• conversion implicite: une conversion implicite consiste en une modification du type
  de donnée effectuée automatiquement par le compilateur. Cela signifie que lorsque
  l'on va stocker un type de donnée dans une variable déclarée avec un autre type,
  le compilateur ne retournera pas d'erreur mais effectuera une conversion implicite de la donnée
  avant de l'affecter à la variable.
  int x;
  x = 8.324;
  x contiendra après affectation la valeur 8
  
• conversion explicite: une conversion explicite (appelée aussi opération de cast)
  consiste en une modification du type de donnée forcée. Cela signifie que l'on utilise un opérateur
  dit de cast pour spécifier la conversion.
  L'opérateur de cast est tout simplement le type de donnée, dans lequel on désire convertir une variable,
  entre des parenthèses précédant la variable.
  int x;
  x = (int)8.324;
  x contiendra après affectation la valeur 8
  

---

[Vous devez être inscrit et connecté pour voir cette image]

Le concept de variable

Une variable est un objet repéré par son nom, pouvant contenir des données, qui pourront être modifiées lors de l'exécution du programme. Les variables en langage C sont typées, c'est-à-dire que les données contenues dans celles-ci possèdent un type, ainsi elles sont donc stockées à une mémoire et occupe un nombre d'octets dépendant du type de donnée stockée.

En langage C, les noms de variables peuvent être aussi long que l'on désire, toutefois le compilateur ne tiendra compte que des 32 premiers caractères. De plus, elles doivent répondre à certains critères:

* un nom de variable doit commencer par une lettre (majuscule ou minuscule) ou un "_" (pas par un chiffre)
* un nom de variables peut comporter des lettres, des chiffres et le caractère _ (les espaces ne sont pas autorisés!)
* Les noms de variables ne peuvent pas être les noms suivants (qui sont des noms réservés):
o auto
o break
o case char const continue
o default do double
o else enum extern
o float for
o goto
o if, int
o long
o register, return
o short, signed, sizeof, static, struct, switch
o typedef
o union, unsigned
o void, volatile
o while

Nom de variable correct Nom de variable incorrect Raison
Variable Nom de Variable comporte des espaces
Nom_De_Variable 123Nom_De_Variable commence par un chiffre
nom_de_variable toto@mailcity.com caractère spécial @
nom_de_variable_123 Nom-de-variable signe - interdit
_707 transient nom réservé

Les noms de variables sont sensibles à la casse (le langage C fait la différence entre un nom en majuscule et un nom en minuscules), il faut donc veiller à utiliser des noms comportant la même casse!

La déclaration de variables

Pour pouvoir utiliser une variable, il faut la définir, c'est-à-dire lui donner un nom, mais surtout un type de donnée à stocker afin qu'un espace mémoire conforme au type de donnée qu'elle contient lui soit réservé.

Une variable de déclare de la façon suivante:
type Nom_de_la_variable;
ou bien s'il y a plusieurs variables du même type:
type Nom_de_la_variable1, Nom_de_la_variable2, ...;

Affectation d'une donnée à une variable

Pour stocker une donnée dans une variable que l'on a initialisée, il faut faire une affectation, c'est-à-dire préciser la donnée qui va être stockée à l'emplacement mémoire qui a été réservé lors de l'initialisation.

Pour cela on utilise l'opérateur d'affectation "=" :
Nom_de_la_variable = donnée;

Pour stocker le caractère B dans la variable que l'on a appelée Caractere, il faudra écrire:
Caractere = 'B';
Ce qui signifie stocker la valeur ASCII de "B" dans la variable nommée "Caractere". Il est bien évident qu'il faut avoir préalablement déclaré la variable en lui affectant le type char:
char Caractere;

Initialisation d'une variable

La déclaration d'une variable ne fait que "réserver" un emplacement mémoire où stocker la variable. Tant que l'on ne lui a pas affecté une donnée celle-ci contient ce qui se trouvait précédemment à cet emplacement, que l'on appelle garbage (en français: détritus).

On peut donc affecter une valeur initiale à la variable lors de sa déclaration, on parle alors d'initialisation:
type Nom_de_la_variable; = donnee

Par exemple:
float Toto = 125.36

Portée (visibilité) des variables

Selon l'endroit où on déclare une variable, celle-ci pourra être accessible (visible) de partout dans le code ou bien que dans une portion confinée de celui-ci (à l'intérieur d'une fonction par exemple), on parle de portée (ou visibilité) d'une variable.

Lorsqu'une variable est déclarée dans le code mêce, c'est-à-dire à l'extérieur de toute fonction ou de tout bloc d'instruction, elle est accessible de partout dans le code (n'importe quelle fonction du programme peut faire appel à cette variable). On parle alors de variable globale

Lorsque l'on déclare une variable à l'intérieur d'un bloc d'instructions (entre des accolades), sa portée se confine à l'intérieur du bloc dans lequel elle est déclarée.

* Une variable déclarée au début du code, c'est-à-dire avant tout bloc de donnée, sera globale, on pourra alors les utiliser à partir de n'importe quel bloc d'instruction
* Une variable déclarée à l'intérieur d'un bloc d'instructions (dans une fonction ou une boucle par exemple) aura une portée limitée à ce seul bloc d'instruction, c'est-à-dire qu'elle est inutilisable ailleurs, on parle alors de variable locale

Définition de constantes

Une constante est une variable dont la valeur est inchangeable lors de l'exécution d'un programme. En langage C, les constantes sont définies grâce à la directive du préprocesseur #define, qui permet de remplacer toutes les occurences du mot qui le suit par la valeur immédiatement derrière elle. Par exemple la directive:

#define _Pi 3.1415927

remplacera toutes les chaines de caractères "_Pi" par la valeur 3.1415927.

Toutefois, avec cette méthode les constantes ne sont pas typées, il faut donc utiliser la directive #define avec parcimonie...

Merci hanane ... d'ou ta c résumés !!! MERCIIII ..

de rien
les résumés sont celles de mon père quand il était étudiant (mon père un informatien XD) il a trouvé un CD qui m'a donné

c'est bien rabi ykhalihoulek,merci psq c'est intéressant et j'ai enregistré le résumé. je vois que l'informatique c'est une tradition chez vous lol!

merci
oui lol mon frère l'est aussi xDDD