Langage C : Résumé I

Chapitre 2 - Types et variables

les variables : informations que l'on stocke pour les réutiliser plus tard.

la mémoire : divisée en octets, ce qui est 8 bits qui eux mm 8x 0 ou 1.

on va diviser les infos sur plusieurs octets car on ne peut pas les entrer en entier dedans .

2.1 Codage en binaire

les nombres valent la mm chose peut importe la base. Cela représente le mm nombre de choses

c'est seulement la "traduction" pour notre "langage".

dans un ordinateur, au final, tous les nombres sont en binaire, pcq en hw on a un état électrique "haut" ou "bas".

2.2 Mémoire

chaque case mémoire a 8bits d'espace, ainsi qu'une adresse.

mais un variable peut avoir une taille plus grande que 1 octet, elle prendra juste plusieurs bytes dans la mémoire

2.3 Variable

une variable est un endroit de la mémoire ou on va mémoriser une valeur d'un certain type

d'abord on doit déclarer la variable et on peut optionnellement l'initialiser avec une certaine valeur.

pour la déclaration, on doit indiquer au compilateur le type de nos donnée. Cela permet de définir les opérations autorisées ainsi que la place que prendra les données dans la mémoire, pour pouvoir réserver la bonne taille.

la taille (en byte) est généralement une puissance de 2 : 8, 16, 32, 64 bits

p.ex si on déclare un 'int', c'est une variable de 4byte. Il y aura alors 4 byte dans la RAM qui seront "réservés" à cette variable. quand on modifie la var. on va modifier les 4 bytes alloués à celle-ci dans la ram.

Caractéristiques d'une variable :

• identificateur : c'est son nom. valeur fixe, une var ne peut pas changer de nom
• type : nature de la donnée ainsi que sa taille
• valeur : c'est les données de notre variable. cela peut varier au cours de l'exécution

Cycle de vie d'une variable:

1. déclaration : on dit on compil. le type de notre variable.
2. affectation : on dit au compil ce que l'on veut mettre dans notre variable
3. lecture : on demande quelle est la donnée qui est stockée dans notre variable
4. destruction : on libère la mémoire précédemment utilisée

noms de variable :

1. caractères maj/min
2. chiffres 0-9
3. underscore

ne pas commencer par un chiffre

et on ne peut pas utiliser les mots réservés

utiliser uniquement lowerCamelCase pour les variables

C est un langage à type faible, explicite et statique :

• faible :

  • conversions implicites INTERDITES
  • erreurs de type détectées

• explicite :

  • le prog. doit indiquer les type qu'il utilise

• statique :

  • la vérification se fait au moment de la compilation et pas pendant l'exécution, ce n'est pas un langage interprété.

2.4 Types de base

Types de base :

• entiers
• nombre à virgule
• booléen

Types dérivés :

• tableaux
• strucures
• pointeurs
• fonctions

Types des entiers:

• char : 8 bits : -128 à +127 (unsigned : 0 à 255)
• short : 16 bits : -32’768 à +32’767 (unsigned : 0 à 65’535)
• int : 32 bits : -2’147'483’648 à +2'147'483’647 (unsigned : 0 à 4’294’967’295) DEPEND DU PROCESSEUR !
• long : 32 bits : -2’147'483’648 à +2'147'483’647 (unsigned : 0 à 4’294’967’295) DEPEND DU PROCESSEUR !
• long long 64 bits : ...

Types des nombres à virgules

• float : 32 bits : 3.4E-38 à 3.4E+38
• double : 64 bits : 1.7E-308 à 1.7E+308

float (32 bits) : signe : 1bit , exposant : bit 8 bits, mantisse : 23 bits (≈ 7 chiffres significatifs) double (64 bits) signe : 1 bit, exposant : 11 bits, mantisse : 52 bits (≈ 16 chiffres significatifs)

2.5 Déclaration et affectation des variables/const

1. Utiliser des noms de variables explicites

   • plus la portée est importante, plus cela doit être explicite

2. initialiser de préférence les variables à leur déclaration

3. ⚠NE PAS UTILISER #DEFINE !!!!!

4. éviter aux maximum les constantes littérales

Chapitre 3 - Opérateurs

on utilise les opérateurs pour "mélanger" différentes données selon un schéma particulier.

3.1 Opérateurs arithmétiques

• addition : +
• soustraction : -
• multiplication : *
• division : /
• modulo : % (= reste de la division entière)

3.1.1 priorités

1. parenthèses
2. multiplications, divisions, modulo
3. addition, soustractions
4. affectation

• pour les opérateurs binaires (+, /, -, ...) dans une même classe de priorité, on lit les opération de la gauche à droite
• pour les opérateurs unaires (+=, =, /=, ...), on lit les opération de droite à gauche

3.1.2 types et domaines de définition

il ne faut pas dépasser les valeurs max et min possible d'une variable

il existe une librairie qui fournit des macros qui donne les valeurs max et min des différents type : <limits.h>

Ces valeurs dépendent de l'implémentation de la machine ou de l'archi du CPU

avec les float ou double, on a les nombres spéciaux suivants :

• valeur infinie : #INF (ou INFINITY en math.h)
• valeur indéterminée : #IND (ou NAN en math.h)

pour les entier, il n'existe pas de valeurs spéciale, mais certains bits ne sont simplement pas pris en compte.

3.1.3 Règles de conversion implicites

1. dans une affectation, type le plus précis prioritaire
2. dans une opération, on converti les type les plus faible vers les plus forts

3.1.4 Conversions explicites

modification de type réalisée par le programmeur

(<type>) <valeur>

on peut aussi utiliser des suffixes :

• . pour double
• f pour float
• u pour unsigned
• l pour long

3.2 Opérateur d'affectation et d'assignation

i = i + 1 équivalent à i += 1

i = i & j équivalent à i &= j

3.3 Opérateurs d'incrémentation

• ++ : incrément
• -- : décrément

il y a à chaque fois, deux possibilités :

1. préfixés, on incrémente puis on affecte ++a
2. postfixé, on affecte puis on incrémente a++

il faudrait toujours utiliser les opérateurs préfixés

3.4 Opérateur virgule

<opération1>, ..., <opérationN>

on évalue l'expression1, puis 2 jusqu'à N

la valeur de l'opération virgule est celle de la dernière valeur, la plus à droite

par exemple pour une boucle for :

for(int i=0, j=0; i<15; ++i, j+=2)

3.5 Opérations de comparaison

• est égal à : ==
• est différent de : !=
• supérieur (ou égal) : > (>=)
• inférieur (ou égal) : < (<=)

les opération de comparaison renvoient toujours soit true (1) soit false (0)!

exemple :

int a = 10 < 20; --> a vaut 1

int a = 10 > 20; --> a vaut 0

3.6 Opérateurs logiques

• AND : &&
• OR : ||
• NOT : !

exemple :

bool a = true || false--> a vaut true

bool a = true && false--> a vaut false

Le membre de droite n'est évalué que si nécessaire. par exemple :

bool a = false && true, on n'évalue QUE false parce que dans un AND, les deux opérandes doivent être à true, donc comme le 1er vaut false, peu importe la valeur de la 2e opérande, la condition est fausse.

3.6 Opérateurs bit-à-bit

• AND : &
• OR : |
• XOR : ^
• complément à 1 : ~

on compare chaque bit de la 1re opérande avec chaque bit de la 2e opérande, un par un.

par exemple :

int a = 0101 & 1100; a vaut 0100

3.7 Opérateurs de décalage de bit

• décalage des bits de a vers la gauche de b bits : a << b
• décalage des bits de a vers la droite de b bits : a >> b
• décalage à gauche et affectation : a <<= b
• décalage à droite et affectation : a >>= b

Chapitre 4 - Entrées / Sorties

4.1. Syntaxe de printf()

4.1.1 Affichage / saisie

• affichage d'information à l'écran : printf()

  • on peut afficher du texte ou le contenu des variables selon différents formats

• saisie de valeur à partir du clavier : scanf()

  • les valeurs saisies sont stockées dans des variables

pour utiliser ces fonctions, il faut inclure la bibliothèque stdio.h : #include <stdio.h>

4.1.2 printf : syntaxe

printf("<chaine de commande>", <Liste d'expressions>);

<chaine de commandes>

• simple texte, p.ex : hello world
• spécification du format d'affichage des variables, p. ex : %d
• caractère d'échappement, p.ex : \n

Liste d'expressions

• Liste des variables ou des expressions à afficher, précédemment notées dans la chaine de commandes avec les spécifications de formats %...

La liste d'expressions doit posséder (au moins) autant de valeurs qu'il y a de spécifications de format

Exemple :

xxxxxxxxxx
2
1
nb = 20;
2
printf("nb %d x %d\n", nb, 5+2);

renvoie : nb 20 x 7

4.2 spécifications de format

4.2.1 Caractères

• caractère simple : %c type : char
• chaine de caractères (via pointeur) : %s type : char*

4.2.2 Nombre entiers

• entier décimal signé : %d type : int
• entier hexadécimal : %x type : int
• pointeur : %p type : void *

4.2.3 Nombre à virgule flottante

• valeur signée xx.yy : %f type : float/double
• valeur signée x.yyez (x.yyEz): %e (%E) type : float/double

il existe encore d'autres types mais qui ne sont que rarement utilisés.

4.2.4 Formats d'affichage

Avec le type char :

• %c affiche le caractère Z
• %d affiche son code ASCII : 90

Avec les types réels, il est possible de donner des indications sur la largeur et la précision de la valeur.

La Largeur L fixe le nombre de caractère minimum que devra prendre notre nombre. Si la largeur est plus grande que la place que prend le nombre, des espaces sont affichés avant le nombre. La largeur comprend tous les caractères que devra afficher le nombre au minimum (valeurs décimales et point compris!)

La précision P fixe la précision, càd le nombre de décimales de notre nombre. La précision commence toujours par un point. La spécification .P indique que P décimales seront affichées.

%<L>.<P>f ou %<L>d par exemple.

exemple :

xxxxxxxxxx
7
1
float n = 123.4567;
2

3
printf("%f", n);     // 123.4567
4
printf("%6.1f", n);  // _123.4 ( _ = espace)
5
printf("%2.2f", n);  // 123.45 (la largeur L est un minimum !)
6
printf("%.3f", n);   // 123.456 (on ne précise que la précision)
7
printf("%10f", n);   // __123.4567 (on ne précise que la largeur)

4.3 caractères d'échappement

aussi appelés caractères de contrôle, ils commencent toujours par le caractère backslash : \

il permettent de faire des actions spécifiques, comme un retour à ligne, une tabulation, ... :

xxxxxxxxxx
10
1
\a Bip sonore (BEL)
2
\b Backspace (BS), revient d'un caractère en arrière
3
\n Newline (NL), saute au début de la ligne suivante
4
\r Carriage Return (CR), revient au début de la ligne
5
\t Horizontal Tab (HT), avance au "taquet" suivant
6
\\ Backslash (\), affiche un \ (barre inversée)
7
\' Single Quote ('), affiche un signe ' (apostrophe)
8
\" Double Quote ("), affiche un signe " (guillemet)
9
\0 Le caractère NUL (zéro), code ASCII 000
10
\xnnn Le caractère de code ASCII nnn (hexa), p.ex \x041 affiche 'A'

4.4 Syntaxe de scanf()

xxxxxxxxxx
1
1
scanf("<chaine de commande>", &<var1>, [...] , &<varN>);

exemple :

xxxxxxxxxx
2
1
int day, month, year;
2
scanf("%d/%d/%d", &day, &month, &year);

<chaine de commandes>

• spécification de format de lecture des variables, p.ex : %d, %f, etc...

  • elles sont les mêmes que pour printf sauf pour les types réels :
  • %f pour float
  • %lf pour double

• des caractères alphanumériques

<Liste de variables>

• Liste des variables à saisir (précédé de & pour envoyer l'adresse des variables)
• les constantes sont interdites (on ne peut pas modifier la valeur d'une constante)

Si on ajoute des caractères alphanumériques comme dans l'exemple précédent (/) il faut le taper pendant la saisie !

il faudrait donc taper par exemple 0 1 / 0 1 / 2 0 0 0 <enter>

scanf renvoie le nombre de champs remplis par l'utilisateur.

fflush(stdin) vide le buffer d'entrée

Chapitre 5 - Structures de contrôle

5.1 Branchement conditionnel

5.1.1 if

syntaxe :

xxxxxxxxxx
6
1
if (<condition>)
2
{
3
    <instruction1>;
4
    <instruction2>;
5
    ...
6
}

ou éventuellement (mais à éviter)

xxxxxxxxxx
2
1
if (<condition>)
2
    <instruction>;

La deuxième syntaxe ne fonctionne que pour une seule instruction, sinon, il faut mettre les accolades.

Attention, il n'y a pas de ; après le if, sinon les instructions à l'intérieur du bloc ne s'exécuteront pas!

5.1.2 if else

syntaxe :

xxxxxxxxxx
8
1
if (<condtition>)
2
{
3
    <bloc>
4
}
5
else
6
{
7
    <bloc>
8
}

ou éventuellement (mais à éviter)

xxxxxxxxxx
4
1
if(<condition>)
2
    <instruction>;
3
else
4
    <instruction>;

5.1.3 Remarques

• la condition est toujours entre parenthèses
• les instructions if et else ne se terminent pas par ;
• les accolades { et } définissent un bloc d'instructions
• else n'existe pas sans if
• if peut exister sans else

5.1.4 Styles de codage

Il existe plusieurs manière de placer les accolades dans le code. Cela n'influencera pas l'exécution du code mais uniquement sa lisibilité. Il n'y a pas vraiment de meilleure façon de faire, l'important est que le code soit lisible, compréhensible et d'être cohérent dans tout le programme (i.e. ne pas changer et/ou alterner de façon d'écrire)

Style Kernighan & Richtie

xxxxxxxxxx
7
1
if (x == y) {
2
    ..
3
} else if (x > y) {
4
    ..
5
} else {
6
    ..
7
}        

Style Whitesmiths

xxxxxxxxxx
12
1
if (x == y) 
2
{
3
    ..
4
} 
5
else if (x > y) 
6
{
7
    ..
8
}
9
else 
10
{
11
    ..
12
}  

5.1.5 Opérateur ternaire

L'opérateur renvoie un résultat en fonction du résultat d'une opération logique.

Syntaxe :

xxxxxxxxxx
1
1
result = <condition> ? <valueIfTrue> : <valueIfFalse>;

5.1.6 Branchement multiple switch

switch seul

Syntaxe :

xxxxxxxxxx
15
1
switch(value)
2
{
3
    case <val_A>: 
4
        <instruction_A1>;
5
        <instruction_A2>;
6
        ...
7

8
    case <val_B>: 
9
        <instruction_B1>;
10
        <instruction_B2>;
11
        ...
12
            
13
    default:
14
        <instructions>;
15
}

On va évaluer la valeur de value.

Si value == <val_A> alors on exécute toutes les instructions à partir de <instruction_A1> jusqu'à la fin.

Dès qu'on rencontre une condition vérifiée, on exécute les instructions à partir de cet endroit.

Organigramme :

switch + break

Avec le mot clé break on indique que l'on veut quitter le branchement switch. On peut alors uniquement exécuter les instructions qui correspondent à la condition testée et pas les suivantes.

Syntaxe :

xxxxxxxxxx
18
1
switch(value)
2
{
3
    case <val_A>: 
4
        <instruction_A1>;
5
        <instruction_A2>;
6
        ...
7
        break;
8

9
    case <val_B>: 
10
        <instruction_B1>;
11
        <instruction_B2>;
12
        ...
13
        break;
14
            
15
    default:
16
        <instructions>;
17
        break;
18
}

Organigramme:

5.1.7 Comparaison switch vs if..else

switch ne permet que de tester des égalités entre valeurs entière ou de type char

switch ne peut pas tester des valeurs réelles, des chaînes de caractères, des structures, des tableaux ou des intervalles de valeurs.

Un if..else peut toujours remplacer un switch mais l'inverse n'est souvent pas possible.

5.2 Boucles

5.2.1 Boucle while

Tant que la condition est vérifiée, répéter [...]

Syntaxe

xxxxxxxxxx
4
1
while(<condition>)
2
{
3
    <bloc>
4
}

Structogramme

Remarques

Avec la boucle while, tant que la condition est vraie, on exécute les instructions du bloc, mais le corps n'est pas forcément exécuté (si la condition est fausse dès le départ)

Il faut faire attention à ce que le corps de la boucle puisse modifier la condition afin de la rendre fausse, sinon on aura affaire à une boucle infinie.

5.2.2 Boucle do..while

Répéter [...] tant que la condition est vraie

Syntaxe

xxxxxxxxxx
5
1
do
2
{
3
    <bloc>
4
}
5
while(<condition>);

Structogramme

Remarques

Les instructions du blocs sont exécutées puis répétées tant que la condition est vraie.

Cela signifie que le corps de la boucle est exécuté au moins une fois (étant donné que la condition est testée en fin de boucle)

Attention : L'instruction while du do..while doit se terminer par ;

5.2.3 Boucle for

Répéter un certain nombre de fois [...]

Syntaxe

xxxxxxxxxx
4
1
for(<init> ; <condition> ; <incr>)
2
{
3
    <bloc>
4
}

Structogramme

Remarques

La boucle for permet de répéter une ou plusieurs instructions un certain nombre de fois.

On utilise un indice pour compter le nombre de fois que la boucle est effectuée.

Sa valeur doit :

• être initialisée au départ
• être modifiée à chaque passage (incrément ou décrément)
• être testée à chaque passage pour vérifier si le programme a effectué le nombre d'itérations souhaitée.

Précisions

initialisation

cette instruction doit initialiser la variable d'indice (exécutée qu'une seule fois, à l'entrée de la boucle)

Condition

cette condition doit être vraie pour que les conditions de la boucle s'exécutent

incrément

instruction qui incrémente (ou décrémente) la variable d'indice.

Fonctionnement

(1) l'expression d' est exécutée (1). (2) est testée (2). (3) Si elle est remplie, alors, l' est exécutée (3), (4) puis l'<Incrémentation> est effectuée (4) (5) est à nouveau testée (5). (8) Si la n'est pas remplie (8), la boucle for prend fin. L'instruction d'<Incrémentation> est effectuée une dernière fois avant de terminer la boucle (7). La variable utilisée prend donc la prochaine valeur supérieure à la dernière autorisée par la , sauf dans le cas où la n'est d'emblée pas remplie.

Equivalent en boucle while

La boucle for

xxxxxxxxxx
4
1
for (i=1; i<132; i+=2)
2
{
3
    <instructions>;
4
}

est équivalent avec une boucle while à

xxxxxxxxxx
6
1
i = 1;
2
while(i<132)
3
{
4
    <instructions>;
5
    i += 2;
6
}

5.2.4 Quelle boucle choisir ?

La boucle for est à privilégier quand on connait à l'avance le nombre d'itérations à effectuer.

Si on ne connait pas à l'avance le nombre d'itérations :

• On choisit do..while si le corps de la boucle doit être effectué au moins une fois
• On choisir while si on ne doit pas forcément entrer dans la boucle

5.3 Instructions de branchement inconditionnels

5.3.1 Instruction return

L'instruction return termine l'exécution de la fonction courante.

5.3.2 Fonction exit(<int>)

La fonction exit permet de terminer l'exécution où que l'on se trouve.

Elle prend un paramètre (code d'erreur entier) destiné à l'environnement d'exécution (0=OK, -1=ERR)

une directive #include <stblib.h> est nécessaire.

Cette instruction est utile pour quitter la fonction en cas d'erreur.

Autres instructions inconditionnelles

il existe également :

• break
• continue
• goto

A l'exception de l'instruction break utilisée à l'intérieur d'un branchement switch, l'utilisation de ces instructions est à bannir!

Fonctionnement

Chapitre 6 - Fonctions (partie 1)

6.1 Notion de fonction

6.1.1 Avantages de l'utilisation de fonctions

• Décomposition de longs programmes en sous-programmes
• factorisation : rassemblement de suites d'instructions identiques dispersées dans le programme, en une fonction.
• Meilleure lisibilité des programmes
• Facilitent la maintenance

6.1.2 Appel de fonction

xxxxxxxxxx
1
1
result = function(<arg1>, <arg2>, ... <argN>);

6.1.3 Définition de fonction

xxxxxxxxxx
6
1
<type> function_name(<type> arg1, <type> arg2, ...)
2
{
3
    <instructions>;
4
    
5
    return <return_value>
6
}

6.1.4 Prototype de fonction

L'en-tête de la fonction doit être connu par le compilateur avant son premier appel. Si la fonction est déclarée après son appel, il est alors nécessaire de définir son prototype avant son premier appel :

xxxxxxxxxx
16
1
/* prototype de la fonction */
2
<type> function_name(<type> arg1, <type> arg2, ...);
3

4
int main()
5
{
6
    /* appel de la fonction */
7
    function_name(1,2,3,...);
8
}
9

10
/* définition de la fonction */
11
<type> function_name(<type> arg1, <type> arg2, ...)
12
{
13
    <instructions>;
14
    
15
    return <return_value>
16
}

Si une fonction est définie dans un autre fichier, son prototype doit alors être inclus dans le fichier header (file.h) :

main.c

xxxxxxxxxx
7
1
#include "file.h"
2

3
int main()
4
{
5
    function_name(args);
6
    return 0;
7
}

file.h

xxxxxxxxxx
2
1
/* prototype de la fonction */
2
<type> function_name(<type> arg1, <type> arg2, ...);

file.c

xxxxxxxxxx
7
1
/* définition de la fonction */
2
<type> function_name(<type> arg1, <type> arg2, ...)
3
{
4
    <instructions>;
5
    
6
    return <return_value>
7
}

6.1.5 Valeur retournée

On utilise l'instruction return pour renvoyer une valeur.

L'exécution de toute fonction se termine si :

• à l'exécution d'une instruction return
• à la fin du bloc d'instruction marqué par }
• par une instruction exit

Types de retours

Types possibles :

• entiers
• réel
• pointeur
• struct
• void

Il faut toujours indiquer le type du retour.

Paramètres formels

→ paramètres indiqués dans la définition de la fonction

Fonction sans paramètre formel (void)

xxxxxxxxxx
1
1
<type> function_name(void);

Fonction avec paramètre formels

xxxxxxxxxx
1
1
<type> function_name(int a, double b, float* c, ...);

Les paramètre peuvent être de n'importe quel type.

Paramètre effectifs

→ paramètres indiqué lors de l'appel de la fonction (arguments)

Les paramètres effectifs doivent être compatible avec les paramètres formels. Cela peut être des expressions, des constantes ou des variables.

xxxxxxxxxx
1
1
function_name(a, b+c, f(4));

Si la fonction retourne une valeur, elle peut ensuite être utilisée (affectée à une variable ou être utilisée dans une autre expression)

xxxxxxxxxx
2
1
int var = function_name(a,b,c); 
2
int var = sqrt(function_name(a,b,c));

6.2 Variables locales et globales

6.2.1 Visibilité des variables

Les variables sont visibles dans le bloc où elles ont été déclarées.

Variables globales

ce sont des variables qui sont déclarées en dehors de toute fonction :

• elles sont visible partout
• elles existent jusqu'à la fin du programme

Variables locales

Elles sont déclarées dans un bloc (dans le corps d'une fonction)

• elles sont uniquement visibles dans le bloc où elles ont été déclarées
• elles masquent les variables déclarées hors du blocs
• leur durée de vie s'étend de leur déclaration jusqu'à la sortie du bloc

6.2.2 Danger des variables globales

6.2.3 Mot-clé static

Lorsqu'une variable locale est déclarée avec le mot-clé static:

• elle n'est visible que dans la fonction où elle a été déclarée (ça reste une variable locale)
• Elle conserve son contenu entre deux appels
• Est initialisée à 0 par défaut à sa première utilisation

Les variables statiques permettent de gérer la persistance tout en ayant un statut privé.

6.3 Organisation de la mémoire