Les valeurs, types et expressions

Le but de la programmation est de manipuler des valeurs présentes dans la mémoire des ordinateurs ou fournies par l'utilisateur afin d'obtenir un résultat qui résout un problème.

La mémoire des ordinateurs ne peut cependant que stocker des 0 ou des 1, que l'on nomme bits. Cela n'est pas très pratique car en tant qu'humain, il est compliqué de raisonner avec ces valeurs binaires. C'est pourquoi, dans la grande majorité des cas, on utilise ce qu'on appelle des types. Ces types permettent aux ordinateurs de traduire des valeurs facilement compréhensibles pour les humains en des bits qui sont les seules choses que les ordinateurs peuvent comprendre. Parmis ces types, on retrouve principalement :

• l'ensemble des valeurs entières (int) : 0, 1, 10, 42, ...
• l'ensemble des flottants à simple précision (float) : 0.1, 0.25, 0.432, ...
• l'ensemble des flottants à double précision (double) : 0.0000001, 0.256789965, 0.4567890086, ...
• les valeurs booléennes (bool) : true et false
• l'ensemble des caractères alphanumériques (char) : 'a', 'b', '1', '2', ...
• les ensembles des adresses mémoires pointants vers différents types (int*, float*, char*, ...) : 0x00007FFEDEADBEEF, 0xFFFF800000123456, ...

Il est ensuite possible d'utiliser ces valeurs typées afin de réaliser des opérations qui calculent des résultats grâce à des opérateurs. On appelle cela des expressions qui, comme pour les valeurs, sont aussi typées. En fonction des types, seuls certains opérateurs peuvent être utilisés. En voici quelques exemples :

• l'addition de deux valeurs entières (opérateur +) est une expression de type int : 1 + 2
• la multiplication de deux valeurs flottantes à simple précision (opérateur *) est une expression de type float : 1.5 * 4.2
• l'égalité de deux valeurs entières (opérateur ==) est une expression de type bool : 4 == 2
• la négation d'une valeur booléenne (opérateur !) est une expression de type bool : !true

Puisque les expressions sont typées comme les valeurs, il est possible de faire des opérations sur elles aussi pour former d'autres expressions. Par exemple:

• la comparaison que 3 + 2 (type int) est égal à 4 + 1 (type int) est une expression de type bool : 3 + 2 == 4 + 1

Dans ce cas-ci, cette expression est composée des expressions 3 + 2 et 4 + 1.

Les variables, instructions et programmes

Nous avons maintenant vu à quoi correspondaient les valeurs et comment faire des opérations avec elles. Cependant, nous n'avons toujours pas vu comment manipuler la mémoire des ordinateurs pour stocker ou récupérer ces valeurs. Cela se fait grâce à ce que l'on appelle des variables et des instructions.

Vous pouvez voir une variables comme étant un emplacement dans la mémoire avec un nom qui permet de facilement y faire référence et faisant exactement la bonne taille pour stocker une valeur avec un type particulier. Les variables ont donc aussi un type et donc on peut aussi les utiliser dans des opérations pour indiquer qu'il faut utiliser une valeur stockée dans la mémoire pour la calculer. Notez que lorsqu'une variable contient une adresse mémoire, elle est généralement appelée pointeur, mais cela désigne la même chose.

Pour stocker des valeurs dans la mémoire, on utilise des instructions qui sont des lignes de code permettant d'indiquer aux ordinateurs ce qu'ils doivent faire, comme stocker des valeurs dans la mémoire, déclarer certains emplacements mémoire comme étant des variables ou évaluer des expressions. Voici quelques exemples d'instructions :

• Déclarer une variable de type int nommée x : int x;
• Affecter la valeur 5 à la variable x : x = 5;
• Affecter le résultat de l'expression 4 + 2 à la variable a : a = 4 + 2;
• Récupérer l'adresse mémoire d'une variable de type int nommée z et affecter cette adresse au pointeur ptr : int* ptr = &z;
• Déréférencer le pointeur de type int* nommé ptr pour récupérer la valeur stockée à l'adresse qu'il contient puis affecter cette valeur à la variable r : int r = *ptr;
• Affecter la valeur 42 à l'adresse mémoire pointée par le pointeur de type int* nommé ptr : *ptr = 42;

Quand l'on combine plusieurs instructions en utilisant des structures de contrôle, comme des séquences, sélections ou répétitions, on peut créer des algorithmes permettant de résoudre des problèmes. Ensuite, ces algorithmes peuvent être implémentés dans un langage de programmation pour créer des programmes.

Exemple

Voici un petit exemple de programme écrit en C et qui utilise les concepts vus précédemment pour afficher la somme de deux nombres. L'exécution de ce programme vous est montrée ci-dessous dans un outil de visualisation de code qui permet de suivre l'exécution pas à pas mais sachez que lors d'une exécution normale, le programme s'exécute d'un coup et affiche le résultat à la fin.

En plus des quelques concepts vus précédemment, ce programme utilise aussi certaines choses que nous verrons dans des chapitres ultérieurs mais qui sont nécessaires pour faire fonctionner le programme correctement. C'est notamment le cas de :

• La bibliothèque standard d'entrée/sortie qui permet d'afficher des messages à l'écran (ligne 1) : #include <stdio.h>
• La fonction principale qui permet de définir le point d'entrée du programme (ligne 3) : int main(void) { ... }
• Les instructions de retour qui permettent de quitter la fonction principale (ligne 12) : return 0;

Pour l'instant, retenez juste par coeur ces quelques choses que nous n'avons pas encore abordées en détail car il s'agit de concepts plus avancés que nous verrons dans les chapitres suivants.

Informations supplémentaires sur les instructions d'affichage et de lecture

Dans ce cours, nous allons beaucoup utiliser les instructions scanf et printf. Ce sont ce que l'on appelle des fonctions qui sont un concept que nous verrons plus en détail dans un chapitre ultérieur mais c'est important de comprendre dès maintenant à les utiliser car ce sont ces 2 instructions qui vont permettre d'intéragir avec le programme. scanf est une instruction qui permet de récupérer des entrées fournies par l'utilisateur du programme et printf, quant à lui, permet d'afficher un message à l'écran. Ces 2 instructions fonctionnent avec un système de pattern qui permet de récupérer les valeurs que l'on veut dans les entrées fournies par l'utilisateur ou d'afficher à l'utilisateur du texte avec nos valeurs aux bons endroits. Voici une liste des patterns supportés :

• %d ou %i : nombre décimal, signé
• %u : nombre décimal, non signé
• %c : caractère alphanumérique isolé
• %s : chaîne de caractères alphanumériques (valeur textuelle)
• %f : notation décimale d’une valeur réelle à simple précision
• %lf : notation décimale d’une valeur réelle à double précision
• %.1f, %.2f, ... : notation décimale d’une valeur réelle avec 1, 2, ... nombres après la virgule
• %e ou %E : notation scientifique d’une valeur réelle

Voici aussi un petit exemple de programme qui va afficher un message à l'utilisateur, qui va stocker 2 valeurs entrées par l'utilisateur dans les variables a et b puis qui va afficher la somme de a et b à l'utilisateur :

#include <stdio.h>

int main(void) {
    int a, b;
    printf("Entrez une valeur a et une valeur b, séparées par un espace:\n");
    scanf("%d %d", &a, &b);

    printf("La somme de a et b vaut %d\n", a + b);

    return 0;
}

Pour mieux comprendre ce qu'il se passe, voici une visualisation qui permet de voir ce qui est affiché à l'écran et qui montre une simplification de l'exécution de l'instruction scanf avec l'entrée 3 2 :

Bonnes pratiques

Quand vous écrivez du code, il est important de suivre certaines bonnes pratiques pour que votre code soit lisible et compréhensible par les autres.

Pour l'instant, retenez ces quelques bonnes pratiques :

• Utilisez des noms de variables explicites (si possible en anglais) en minuscule et séparés par des underscores. (Par exemple : ma_variable)
• Évitez les magic numbers (valeurs numériques utilisées sans explication) grâce à l'utilisation de constantes nommées. (Par exemple : #define MA_CONSTANTE 42)
• Commentez votre code pour expliquer les parties complexes ou non évidentes. (En particulier, expliquez le pourquoi plutôt que le comment)
• Indentez correctement votre code pour en faciliter la lecture. (A chaque ouverture d'accolade {}, il faut ajouter une indentation de 4 espaces)