Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Informatique

Le langage C : premier programme, types, variables, opérateurs, entrées et sorties

Structure d'un programme C et compilation, types et variables, opérateurs arithmétiques, logiques et de comparaison, conversions, printf et scanf avec un exemple de résistances.

https://www.electronics-engineering.com/fr/langage-c-introduction-types-operateurs/

Pas encore de vote : soyez le premier à noter cette page.

Le C, créé par Dennis Ritchie aux Bell Labs entre 1969 et 1973 pour écrire le système d’exploitation Unix, est toujours le langage des systèmes d’exploitation, des pilotes, des micrologiciels et de presque tous les microcontrôleurs. Il est petit, rapide et proche du matériel, et c’est justement pour cela qu’il exige de la discipline : le compilateur contrôle peu et laisse la mémoire entre les mains du programmeur. Dans cette leçon nous écrivons les premiers programmes : structure, types, variables, opérateurs, entrées et sorties.

Le premier programme

#include <stdio.h>

int main(void)
{
    printf("Hello, world!\n");
    return 0;
}
  • #include <stdio.h> demande au préprocesseur d’inclure les déclarations de la bibliothèque standard d’entrée/sortie, où se trouve printf.
  • main est la fonction où commence l’exécution. Elle renvoie un int : 0 dit au système d’exploitation que tout s’est bien passé.
  • Les accolades délimitent un bloc ; chaque instruction se termine par un point-virgule.
  • \n dans la chaîne est le caractère de saut de ligne.

On compile et on exécute avec gcc hello.c -o hello et ./hello. Activez toujours les avertissements, gcc -Wall -Wextra : de nombreuses erreurs de C ne sont signalées que comme avertissements.

Du source à l'exécutable
La commande gcc lance quatre programmes à la suite : le préprocesseur cpp développe les inclusions, le compilateur cc1 traduit le C en langage d’assemblage, l’assembleur as produit le code objet, l’éditeur de liens ld le réunit à la bibliothèque standard libc et crée l’exécutable.

Types et variables

Chaque variable a un type, qui fixe combien d’octets elle occupe et comment ses bits sont interprétés, et doit être déclarée avant d’être utilisée.

TypeTaille typiqueContenu
char1 octetcaractère ou petit entier
int4 octets (2 sur certains microcontrôleurs)entier signé
long long8 octetsgrand entier signé
float4 octetsvirgule flottante, environ 7 chiffres
double8 octetsvirgule flottante, environ 16 chiffres

unsigned donne les versions non signées. sizeof(type) dit combien d’octets occupe un type sur ce système.

int n = 10;            /* declaration with initialisation */
double v = 3.3;
char c = 'A';          /* in single quotes: a character, that is the number 65 */
const double PI = 3.14159265358979;   /* constant: cannot be modified */

Attention : une variable locale non initialisée contient une valeur aléatoire, ce qui se trouvait auparavant dans cette mémoire. L’utiliser avant de lui affecter une valeur est une erreur que le compilateur ne signale pas toujours.

Les opérateurs

  • Arithmétiques : + - * / et % (reste). Entre entiers la division tronque : 7 / 2 vaut 3, 7 % 2 vaut 1. Pour obtenir 3.5 au moins un opérande doit être réel : 7.0 / 2.
  • Affectation : =, et les formes abrégées +=, -=, *= ; i++ augmente i de un.
  • Comparaison : == != < > <= >=. Elles donnent 1 (vrai) ou 0 (faux) : le C n’a pas de type booléen intégré, et toute valeur non nulle est vraie (avec <stdbool.h> on peut utiliser bool, true et false).
  • Logiques : && (et), || (ou), ! (non). Elles font un « court-circuit » : dans b != 0 && a / b > 2 la division n’est pas effectuée si b est nul.

L’erreur classique est d’écrire if (x = 5) au lieu de if (x == 5) : la première affecte 5 à x et la condition est toujours vraie. Avec -Wall le compilateur avertit.

Les conversions. Dans une expression avec des types différents, le type « plus petit » est converti dans le « plus grand » : dans n * 2.5 l’entier n devient un double. Affecter un réel à un entier supprime la partie fractionnaire : int k = 3.9; vaut 3. On peut convertir explicitement avec un cast : (double)sum / n.

Entrées et sorties

printf affiche avec un format, dans lequel les spécificateurs % indiquent où et comment insérer les valeurs : %d entier, %u non signé, %f réel, %c caractère, %s chaîne, %x hexadécimal. %.2f affiche deux décimales, %5d occupe au moins cinq caractères.

scanf lit au clavier avec le même format, mais il a besoin de l’adresse de la variable, obtenue avec & (nous verrons pourquoi dans la leçon sur les pointeurs) :

#include <stdio.h>

int main(void)
{
    double r1, r2;
    printf("Values of the two resistors in ohms: ");
    if (scanf("%lf %lf", &r1, &r2) != 2) {      /* scanf returns how many values it read */
        printf("Invalid input\n");
        return 1;
    }
    double series = r1 + r2;
    double parallel = r1 * r2 / (r1 + r2);
    printf("Series: %.1f ohm, parallel: %.1f ohm\n", series, parallel);
    return 0;
}

Avec 1000 et 2200 le programme affiche « Series: 3200.0 ohm, parallel: 687.5 ohm ». À noter %lf pour lire un double avec scanf, alors que printf n’a besoin que de %f, et le contrôle de la valeur que renvoie scanf : un programme robuste ne fait jamais confiance à ses entrées.

Le style compte

Un programme s’écrit une fois et se lit de nombreuses fois, souvent par quelqu’un d’autre. Des noms de variables qui disent ce qu’elles contiennent (voltage_mV plutôt que x), une indentation cohérente, des commentaires qui expliquent pourquoi et non quoi, des fonctions courtes. Le compilateur ignore tout cela ; celui qui doit corriger un bogue à deux heures du matin, non.

S’abonner
Notifier de
guest
1 commentaire
Le plus ancien
Plus récent Les plus votés
1
0
Vous avez apprécié cet article ? Merci de laisser un commentaire.x