Apprendre le langage C en 10 minutes

Petit programme

#include <stdio.h> 

int main(void)
{
    printf("Bonjour tout le monde !\n");
    return 0;
}

D'abord on inclue la bibliothèque stdio.h, responsable des entrées/sorties standards. Cela nous permettra d'utiliser la fonction printf, qui permet d'ajouter du texte dans le terminal.

Ensuite on définit la fonction appelée au démarrage du programme, main. Cette fonction renvoit un entier (int) et ne prend rien en paramètre (void). Son code est contenu dans des accolades.

Puis on appelle la fonction printf, qui va afficher la chaîne « Bonjour tout le monde ! » suivie d'un retour à la ligne (\n).

Enfin, on renvoit 0, code qui indique que tout s'est terminé normalement (return 0;)

Pour exécuter ce programme, on va le compiler:

gcc bonjour.c

La compilation donne un fichier exécutable appelé a.out

On lui donne le droite de s'exécuter avec :

chmod +x ./a.out

Puis on l'exécute avec :

./a.out

Commentaires

Les commentaires peuvent être inclus entre /* et */, dans ce cas ils peuvent s'étaler sur plusieurs lignes :

/* 
   un commentaire 
   deux commentaires
*/

Ou alors précédés de //

// un commentaire
// deux commentaires

Variables

Les variables sont identifiées par leur nom et leur type. Elles peuvent être globales ou locales, si elles sont à l'intérieur d'une fonction ou d'une partie de fonction. Elles sont initialisées grâce au symbole =

#include <stdio.h>
#include <stdlib.h>

double vitesse ; /* 'vitesse' est une variable globale de type réel */

int main(int argc, char *argv[])
{
  int bicyclette = 4; /* 'bicyclettes' est une variable de type entier locale à la fonction 'main', elle vaut 4 */
  printf("Vous avez %d vélos\n", bicyclettes);
  return 0;
}

Il existe différents types de variables, voici quelques exemples :

int (nombres entiers courts), long (longs nombres entiers), float et double pour les nombres décimaux, char pour une lettre.

Ici dans le printf, on a un % suivi d'une lettre, qui permet de dire quoi afficher. "%d" représente int, "%ld" représente long, %f float ou double.

On peut récupérer une variable avec scanf:

int main(int argc, char *argv[])
{
  int bicyclettes = 0; // On initialise la variable à 0
  
  printf("Combien de vélos sont dans votre garage ? ");
  scanf("%d", &bicyclettes); // On demande d'entrer l'âge avec scanf
  printf("Vous avez %d vélos dans votre garage.\n", bicyclettes);
       
  return 0;
}

Les pointeurs en C sont des variables spéciales qui contiennent l'adresse mémoire d'une autre variable. Ils sont utilisés pour manipuler et accéder directement à cette variable en utilisant cette adresse.

nombre correspond à la valeur de la variable et &nombre correspond à l'adresse de la variable.

Pour créer une variable de type pointeur, on rajoute le symbole * devant son nom.

int *nombre = &bicyclettes;

Fonctions

#include <stdio.h>

int factorielle(int n) {
  if (n == 0 || n == 1) {
    return 1;
  } else {
    return n * factorielle(n - 1);
  }
}

int main() {
  int num;
  
  printf("Entrez un nombre: ");
  scanf("%d", &num);
  
  int result = factorielle(num);
  
  printf("Factorielle de %d est %d\n", num, result);
  
  return 0;
}

Tableaux

Les tableaux s'initialisent comme suit:

int tableau[3];

tableau[0] = 1983;
tableau[1] = 1989;
tableau[2] = 1995;

Attention, les index des tableaux commencent à 0 et leur nom sans crochet est un pointeur sur l'adresse de la première case du tableau

printf("%d", tableau);

Si on demande la variable qui se trouve à cette adresse, on obtient la première valeur du tableau, on fera:

printf("%d", *tableau);

Ce qui correspond à

printf("%d", tableau[0]);

Pour avoir la 2e variable, on fera:

printf("%d", tableau[1]);

Chaînes de caractères

Une chaîne de caractères est un tableau de type char. Elle se termine toujours par un \0, le caractère de fin de chaîne.

char chaine[8] = "manchot"; // manchot fait 7 lettres + le caractère \0

Il existe quelques fonctions prédéfinies dans la bibliothèque pour les chaînes string.h, par exemple :

#include <stdio.h>
#include <string.h>

int main() {
    char chaine1[20] = "Hello";
    char chaine2[20] = "World";
    char resultat[40];

    // strlen: longueur d'une chaîne
    printf("Longueur de chaine1: %d\n", strlen(chaine1));
    printf("Longueur de chaine2: %d\n", strlen(chaine2));

    // strcat: concacténation de deux chaînes
    strcat(chaine1, chaine2);
    printf("Chaîne concacténée: %s\n", chaine1);

    // strcpy: copie une chaîne dans une autre
    strcpy(resultat, chaine1);
    printf("Chaîne copiée: %s\n", resultat);

    // strcmp: comparer deux chaînes
    int comparison = strcmp(chaine1, chaine2);
    if (comparison == 0) {
        printf("Les chaînes sont égales.\n");
    } else if (comparison < 0) {
        printf("chaine1 est plus petite que chaine2.\n");
    } else {
        printf("chaine1 est plus grande que chaine2.\n");
    }

    // strstr: trouver une sous sous-chaîne dans une chaîne
    char *substring = strstr(chaine1, "Léa");
    if (substring != NULL) {
        printf("Sous-chaîne trouvée: %s\n", substring);
    } else {
        printf("Sous-chaîne non trouvée.\n");
    }

    // sprintf: formater une chaîne
    int num = 42;
    sprintf(resultat, "La réponse est %d.", num);
    printf("%s\n", resultat);

    return 0;
}

On voit \n pour aller à la ligne. Un autre caractère courant dans les chaînes est \t pour la tabulation.

Opérations sur les nombres

Les opérations sur les nombres sont assez simples.

#include <stdio.h>

int main() {
    int num1, num2; // Déclaration de deux variables entières
    int somme, difference, produit, division; // Déclaration des variables pour stocker les résultats des opérations
    float divise; // Déclaration d'une variable pour stocker le résultat de la division (en raison de la précision limitée des nombres entiers)

    // Lecture des deux nombres entiers
    printf("Entrez deux nombres entiers : ");
    scanf("%d,%d", &num1, &num2);

    // Calcul des résultats des opérations
    somme = num1 + num2;
    difference = num1 - num2;
    produit = num1 * num2;
    division = (float)num1 / num2; // Calcul de la division et convertison au type flottant
    modulo = num1 % num2; // Calcul de la modulo

    // Affichage des résultats des opérations
    printf("La somme des deux nombres entiers est : %d\n", somme);
    printf("La différence entre les deux nombres entiers est : %d\n", difference);
    printf("Le produit des deux nombres entiers est : %d\n", produit);
    printf("La division de %d par %d est : %.2f\n", num1, num2, division); // Affichage de la division avec une précision de 2 chiffres décimaux
    printf("Le modulo de %d par %d est : %d\n", num1, num2, modulo); // Affichage de la modulo

    return 0;
}

Il y a aussi des raccourcis.

variable = variable + 1; équivaut à variable++

variable = variable - 1; équivaut à variable--

variable = variable * 3; équivaut à variable *= 3;

Ainsi:

int main() {
    int a = 5, b = 3;

    printf("Addition avec assignement: %d\n", a++);

    printf("Soustraction avec assignement: %d\n", a--);

    a *= b;
    printf("Multiplication avec assignement: %d\n", a);

    return 0;
}

Conditions

Voici un exemple avec if, else if et else:

if (taille == 85a)
{
    printf("Tout ce qui est petit est joli !");
}
else if (taille == 90b)
{
    printf("Tout ce qui est moyen est bien !");
}
else if (taille == 95c)
{
    printf("Quand c'est gros c'est beau !");
}
else
{
    printf("Chaque taille a son charme");
}

Le même exemple avec switch:

switch (taille)
{
case "85a":
  printf("Tout ce qui est petit est joli !");
  break;
case "90b":
  printf("Tout ce qui est moyen est bien !");
  break;
case "95c":
  printf("Quand c'est gros c'est beau !");
  break;
default:
  printf("Chaque taille a son charme");
  break;
}

On peut aussi définir les conditions avec ? et :

jours = (bissextile) ? 366 : 365;

est équivalent à

if (bissextile)
  jours = 366;
else
  jours = 365;

Boucles

Une boucle en programmation est une structure qui permet de répéter un bloc de code plusieurs fois, en fonction d'une condition. Elle permet d'exécuter des instructions de manière itérative jusqu'à ce que la condition spécifiée soit satisfaite.

La boucle "while" exécute un bloc de code tant que la condition spécifiée est vraie.

int nombre = 0;

while (nombre < 5)
{
    printf("La valeur est %d\n", nombres);
    nombres++;
}

La boucle "for" parcourt un ensemble de valeurs et exécute quelque chose pour chaque valeur.

int compteur;

for (nombre = 0 ; nombre < 5 ; nombre++)
{
    printf("La valeur est %d\n", nombre);
}