Voir la source de Apprendre le langage C en 10 minutes

Le langage C a la réputation d'être compliqué, pourtant, c'est plutôt faux. Nous allons voir comment apprendre ses bases en seulement 10 minutes! Il ne s'agit pas de tout savoir, mais de découvrir le langage par l'exemple. Ensuite, c'est la pratique qui vous fera progresser! À vos marques, prêts, partez!

== Petit programme ==

Commençons par regarder ce petit programme :

<syntaxhighlight lang="C">
#include <stdio.h> 

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

D'abord on inclut la bibliothèque ''stdio.h'', responsable des entrées et des sorties standards. Cela nous permet 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 à Linux que tout s'est terminé normalement (''return 0;'')

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

<syntaxhighlight lang="bash">gcc bonjour.c</syntaxhighlight>

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

On le la,ce avec :

<syntaxhighlight lang="bash">
$ ./a.out

Bonjour tout le monde !
</syntaxhighlight>

== Commentaires ==

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

<syntaxhighlight lang="C">
/* 
   un commentaire 
   deux commentaires
*/
</syntaxhighlight>

Ou alors on précède chaque ligne de deux slashs // :

<syntaxhighlight lang="C">
// un commentaire
// deux commentaires
</syntaxhighlight>

== Variables et pointeurs ==

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

<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

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

int main(int argc, char *argv[])
{
  int bicyclettes = 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;
}
</syntaxhighlight>
<syntaxhighlight lang="text">
Vous avez 4 vélos
</syntaxhighlight>

Il existe différents types de variables, voici quelques exemples : ''int'' pour les nombres entiers courts, ''long'' pour les longs nombres entiers, ''float'' et ''double'' pour les nombres décimaux, ''char'' pour une lettre.

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''.

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.

Ainsi, ''bicyclettes'' correspond à la valeur de la variable et ''&bicyclettes'' correspond à l'adresse de cette même variable.

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

<syntaxhighlight lang="C">int *bicyclettes = &bicyclettes;</syntaxhighlight>

Les pointeurs semblent un peu archaïques et compliqués au début, mais on s'habitude vite.

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

<syntaxhighlight lang="C">
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;
}
</syntaxhighlight>
<syntaxhighlight lang="text">
Combien de vélos sont dans votre garage ? 6
Vous avez 6 vélos dans votre garage.
</syntaxhighlight>

== Tableaux ==

Les tableaux s'initialisent comme suit:

<syntaxhighlight lang="C">
int tableau[3];

tableau[0] = 1983;
tableau[1] = 1989;
tableau[2] = 1995;
</syntaxhighlight>

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 :

<syntaxhighlight lang="C">printf("%d", tableau);</syntaxhighlight>
<syntaxhighlight lang="text">1400</syntaxhighlight>

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

<syntaxhighlight lang="C">printf("%d", *tableau);</syntaxhighlight>
<syntaxhighlight lang="text">1983</syntaxhighlight>

Ce qui correspond à :

<syntaxhighlight lang="C">printf("%d", tableau[0]);</syntaxhighlight>
<syntaxhighlight lang="text">1983</syntaxhighlight>

Pour avoir la 2e variable, on fera :

<syntaxhighlight lang="C">printf("%d", tableau[1]);</syntaxhighlight>
<syntaxhighlight lang="text">1989</syntaxhighlight>

Le C a aussi les listes chaînées, les tables de hachage et les piles et les files.

== 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.

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

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

<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main() {
    char chaine1[20] = "Bonjour";
    char chaine2[20] = "Léa";
    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;
}
</syntaxhighlight>
<syntaxhighlight lang="text">
Longueur de chaine1 : 7
Longueur de chaine2 : 4
Chaîne concacténée : BonjourLéa
Chaîne copiée : BonjourLéa
chaine1 est plus petite que chaine2.
Sous-chaîne trouvée : Léa
La réponse est 42.
</syntaxhighlight>

On utilise ''\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 :

<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
    float nombre1, nombre2;
    float somme, difference, produit, quotient;

    // Saisie de deux nombres réels
    printf("Entrez le premier nombre réel: ");
    scanf("%f", &nombre1);
    printf("Entrez le deuxième nombre réel: ");
    scanf("%f", &nombre2);

    // Calculs de la somme, la différence, le produit
    somme = nombre1 + nombre2;
    difference = nombre1 - nombre2;
    produit = nombre1 * nombre2;

    // Résultats
    printf("Le résultat de l'addition est: %f\n", somme);
    printf("Le résultat de la soustraction est: %f\n", difference);
    printf("Le résultat de la multiplication est: %f\n", produit);

    // Vérifions que le 2e nombre n'est pas égal à 0 avant de diviser
    if (nombre2 != 0.0f) {
        quotient = nombre1 / nombre2;
        printf("Le résultat de la division est: %f\n", quotient);
    } else {
        printf("Erreur: Division par zéro\n");
    }

    return 0;
}
</syntaxhighlight>
<syntaxhighlight lang="text">
Entrez le premier nombre réel: 5
Entrez le deuxième nombre réel: 2
Le résultat de l'addition est: 7.000000
Le résultat de la soustraction est: 3.000000
Le résultat de la multiplication est: 10.000000
Le résultat de la division est: 2.500000
</syntaxhighlight>

Il y a aussi des raccourcis. Ainsi :

<syntaxhighlight lang="C">
int main() {
    int a = 5, b = 3;

    //a++ correspond à a = a+1
    printf("Addition avec assignement: %d\n", a++);

    //a-- correspond à a = a-1
    printf("Soustraction avec assignement: %d\n", a--);

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

    return 0;
}
</syntaxhighlight>
<syntaxhighlight lang="text">
Addition avec assignement: 5
Soustraction avec assignement: 6
Multiplication avec assignement: 15
</syntaxhighlight>

== Structures de contrôle ==

Voici un exemple avec les structures conditionnelles if, else if et else:

<syntaxhighlight lang="C">
if (strcmp(taille, "85a") == 0)
{
    printf("Tout ce qui est petit est joli !");
}
else if (strcmp(taille, "90b") == 0)
{
    printf("Tout ce qui est moyen est bien !");
}
else if (strcmp(taille, "95c") == 0)
{
    printf("Quand c'est gros c'est beau !");
}
else
{
    printf("Chaque taille a son charme");
}
</syntaxhighlight>

Veuillez noter que switch ne supporte pas les chaînes de caractères, donc il faut utiliser if à la place pour les chaînes. Un exemple similaire avec switch, avec seulement un caractère :

<syntaxhighlight lang="C">
switch (taille)
{
case 'a':
  printf("Tout ce qui est petit est joli !");
  break;
case 'b':
  printf("Tout ce qui est moyen est bien !");
  break;
case 'c':
  printf("Quand c'est gros c'est beau !");
  break;
default:
  printf("Chaque taille a son charme");
  break;
}
</syntaxhighlight>

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

<syntaxhighlight lang="C">jours = (bissextile) ? 366 : 365;</syntaxhighlight>

Ce qui est équivalent à :

<syntaxhighlight lang="C">
if (bissextile)
  jours = 366;
else
  jours = 365;
</syntaxhighlight>

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. 

<syntaxhighlight lang="C">
int nombre = 0;

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

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

<syntaxhighlight lang="C">
int compteur;

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

== Fonctions ==

Normalement, on ne met pas tout dans le ''main'' mais on décompose son code en fonctions. Voici un exemple qui calcule la factorielle d'un nombre :

<syntaxhighlight lang="C">
#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;
}
</syntaxhighlight>
<syntaxhighlight lang="bash">
Entrez un nombre: 8
Factorielle de 8 est 40320
</syntaxhighlight>

== Manipulation des fichiers ==

fopen ouvre des fichiers, fclose les ferme, fgets les lit, fputs et fprintf écrivent des chaînes de caractère dedans.
Ces fonctions prennent comme paramètre quelle permission est autorisée sur les fichiers : "r" (lecture), "w" (écriture); "r+" (lecture et écriture), "w+"  (lecture et écriture, avec suppression du contenu précédemment).

<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

int main() {
    FILE *fichier;
    char entree[100];

    // Ouvrir le fichier pour l'écriture
    fichier = fopen("lea.txt", "w");

    if (fichier == NULL) {
        printf("Erreur lors de l'ouverture du fichier\n");
        return 1;
    }

    // Écrire du texte dans le fichier en utilisant fputs
    fputs("Bonjour, Léa!\n", fichier);

    // Écrire du texte formaté dans le fichier en utilisant fprintf
    fprintf(fichier, "Linux date de : %d\n", 1991);

    // Fermer le fichier
    fclose(fichier);

    // Réouvrir le fichier pour la lecture
    fichier = fopen("lea.txt", "r");

    if (fichier == NULL) {
        printf("Erreur lors de l'ouverture du fichier\n");
        return 1;
    }

    // Lire une ligne du fichier en utilisant fgets
    fgets(entree, sizeof(entree), fichier);
    printf("Entrée: %s", entree);

    // Fermer le fichier
    fclose(fichier);

    return 0;
}
</syntaxhighlight>
<syntaxhighlight lang="text">
Entrée: Bonjour, Léa!

$ cat lea.txt 
Bonjour, Léa!
Linux date de : 1991
</syntaxhighlight>

== Mémoire ==

Une variable peut prendre plus ou moins d'espace en mémoire, notamment en fonction de son type. On peut réserver de la mémoire avec malloc() pour une variable et la libérer avec free(). 

<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    int n;

    printf("Entrez le nombre d'entiers à allouer en mémoire : ");
    scanf("%d", &n);

    // Allocation de la mémoire pour n entiers à l'aide de malloc
    ptr = (int*) malloc(n * sizeof(int));
    if (ptr == NULL) {
        printf("Erreur d'allocation de mémoire\n");
        exit(1);
    }

    // Affectation de valeurs à la mémoire allouée
    for (int i = 0; i < n; i++) {
        ptr[i] = i * i;
    }

    // Affichage du contenu de la mémoire allouée
    printf("Contenu de la mémoire allouée :\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", ptr[i]);
    }
    printf("\n");

    // Libération de la mémoire allouée à l'aide de free
    free(ptr);

    return 0;
}
</syntaxhighlight>
<syntaxhighlight lang="text">
Entrez le nombre d'entiers à allouer en mémoire : 4
Contenu de la mémoire allouée :
0 1 4 9 
</syntaxhighlight>

== Conclusion ==

Vous avez maintenant les bases du langages. Vous serez capables de lire et d'écrire de petits programmes en C. Pour progresser, rien de meilleur que la pratique. Pour aller plus loin avec le C, nous vous conseillons le livre de référence ''The C Programming Language'' (''Le langage C Norme ANSI'') par Brian Kernighan et Dennis Ritchie.

{{Développement}}

{{Copy|2024|[[Utilisateur:Jiel|Jiel Beaumadier]]|FDL}}