« Apprendre le langage C en 10 minutes » : différence entre les versions

De Lea Linux
Aller à la navigation Aller à la recherche
 
(17 versions intermédiaires par 2 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
{{Page en construction}}
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!
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!


Ligne 73 : Ligne 71 :
   return 0;
   return 0;
}
}
</syntaxhighlight>
<syntaxhighlight lang="text">
Vous avez 4 vélos
</syntaxhighlight>
</syntaxhighlight>


Ligne 102 : Ligne 103 :
   return 0;
   return 0;
}
}
</syntaxhighlight>
<syntaxhighlight lang="text">
Combien de vélos sont dans votre garage ? 6
Vous avez 6 vélos dans votre garage.
</syntaxhighlight>
</syntaxhighlight>


Ligne 119 : Ligne 124 :


<syntaxhighlight lang="C">printf("%d", tableau);</syntaxhighlight>
<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 :
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="C">printf("%d", *tableau);</syntaxhighlight>
<syntaxhighlight lang="text">1983</syntaxhighlight>


Ce qui correspond à :
Ce qui correspond à :


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


Pour avoir la 2e variable, on fera :
Pour avoir la 2e variable, on fera :


<syntaxhighlight lang="C">printf("%d", tableau[1]);</syntaxhighlight>
<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.
Le C a aussi les listes chaînées, les tables de hachage et les piles et les files.
Ligne 147 : Ligne 156 :


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


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


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


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


     // strcmp: comparer deux chaînes
     // strcmp: comparer deux chaînes
Ligne 176 : Ligne 185 :
     char *substring = strstr(chaine1, "Léa");
     char *substring = strstr(chaine1, "Léa");
     if (substring != NULL) {
     if (substring != NULL) {
         printf("Sous-chaîne trouvée: %s\n", substring);
         printf("Sous-chaîne trouvée : %s\n", substring);
     } else {
     } else {
         printf("Sous-chaîne non trouvée.\n");
         printf("Sous-chaîne non trouvée.\n");
Ligne 188 : Ligne 197 :
     return 0;
     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>
</syntaxhighlight>


Ligne 200 : Ligne 218 :


int main() {
int main() {
     int num1, num2; // Déclaration de deux variables entières
     float nombre1, nombre2;
     int somme, difference, produit, division; // Déclaration des variables pour stocker les résultats des opérations
     float somme, difference, produit, quotient;
     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)
 
    // 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);


     // Lecture des deux nombres entiers
     // Calculs de la somme, la différence, le produit
     printf("Entrez deux nombres entiers : ");
    somme = nombre1 + nombre2;
     scanf("%d,%d", &num1, &num2);
     difference = nombre1 - nombre2;
     produit = nombre1 * nombre2;


     // Calcul des résultats des opérations
     // Résultats
     somme = num1 + num2;
     printf("Le résultat de l'addition est: %f\n", somme);
     difference = num1 - num2;
     printf("Le résultat de la soustraction est: %f\n", difference);
     produit = num1 * num2;
     printf("Le résultat de la multiplication est: %f\n", produit);
    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
     // Vérifions que le 2e nombre n'est pas égal à 0 avant de diviser
     printf("La somme des deux nombres entiers est : %d\n", somme);
     if (nombre2 != 0.0f) {
    printf("La différence entre les deux nombres entiers est : %d\n", difference);
        quotient = nombre1 / nombre2;
    printf("Le produit des deux nombres entiers est : %d\n", produit);
        printf("Le résultat de la division est: %f\n", quotient);
     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
     } else {
     printf("Le modulo de %d par %d est : %d\n", num1, num2, modulo); // Affichage de la modulo
        printf("Erreur: Division par zéro\n");
     }


     return 0;
     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>
</syntaxhighlight>


Ligne 245 : Ligne 276 :
}
}
</syntaxhighlight>
</syntaxhighlight>
 
<syntaxhighlight lang="text">
Addition avec assignement: 5
Soustraction avec assignement: 6
Multiplication avec assignement: 15
</syntaxhighlight>


== Structures de contrôle ==
== Structures de contrôle ==
Ligne 252 : Ligne 287 :


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


Le même exemple avec switch:
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">
<syntaxhighlight lang="C">
switch (taille)
switch (taille)
{
{
case "85a":
case 'a':
   printf("Tout ce qui est petit est joli !");
   printf("Tout ce qui est petit est joli !");
   break;
   break;
case "90b":
case 'b':
   printf("Tout ce qui est moyen est bien !");
   printf("Tout ce qui est moyen est bien !");
   break;
   break;
case "95c":
case 'c':
   printf("Quand c'est gros c'est beau !");
   printf("Quand c'est gros c'est beau !");
   break;
   break;
Ligne 290 : Ligne 325 :
</syntaxhighlight>
</syntaxhighlight>


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


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


est équivalent à :
Ce qui est équivalent à :


<syntaxhighlight lang="C">
<syntaxhighlight lang="C">
Ligne 355 : Ligne 390 :
   return 0;
   return 0;
}
}
</syntaxhighlight>
<syntaxhighlight lang="bash">
Entrez un nombre: 8
Factorielle de 8 est 40320
</syntaxhighlight>
</syntaxhighlight>


Ligne 371 : Ligne 410 :


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


     if (fichier == NULL) {
     if (fichier == NULL) {
Ligne 379 : Ligne 418 :


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


     // Écrire du texte formaté dans le fichier en utilisant fprintf
     // Écrire du texte formaté dans le fichier en utilisant fprintf
     fprintf(fichier, "La valeur de PI est environ: %.2f\n", 3.14159);
     fprintf(fichier, "Linux date de : %d\n", 1991);


     // Fermer le fichier
     // Fermer le fichier
Ligne 388 : Ligne 427 :


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


     if (fichier == NULL) {
     if (fichier == NULL) {
Ligne 404 : Ligne 443 :
     return 0;
     return 0;
}
}
</syntaxhighlight>
<syntaxhighlight lang="text">
Entrée: Bonjour, Léa!
$ cat lea.txt
Bonjour, Léa!
Linux date de : 1991
</syntaxhighlight>
</syntaxhighlight>


Ligne 446 : Ligne 492 :
}
}
</syntaxhighlight>
</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}}

Dernière version du 2 janvier 2024 à 12:18

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 :

#include <stdio.h> 

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

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:

gcc bonjour.c

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

On le la,ce avec :

$ ./a.out

Bonjour tout le monde !

Commentaires

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

/* 
   un commentaire 
   deux commentaires
*/

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

// un commentaire
// deux commentaires

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

#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;
}
Vous avez 4 vélos

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 :

int *bicyclettes = &bicyclettes;

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 :

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;
}
Combien de vélos sont dans votre garage ? 6
Vous avez 6 vélos dans votre garage.

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);
1400

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

printf("%d", *tableau);
1983

Ce qui correspond à :

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

Pour avoir la 2e variable, on fera :

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

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.

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] = "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;
}
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.

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 :

#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;
}
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

Il y a aussi des raccourcis. Ainsi :

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;
}
Addition avec assignement: 5
Soustraction avec assignement: 6
Multiplication avec assignement: 15

Structures de contrôle

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

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");
}

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 :

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;
}

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

jours = (bissextile) ? 366 : 365;

Ce qui est équivalent à :

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

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);
}

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 :

#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;
}
Entrez un nombre: 8
Factorielle de 8 est 40320

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

#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;
}
Entrée: Bonjour, Léa!

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

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().

#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;
}
Entrez le nombre d'entiers à allouer en mémoire : 4
Contenu de la mémoire allouée :
0 1 4 9

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.



@ Retour à la rubrique Développement

Copyright

© 2024 Jiel Beaumadier

Tête de GNU Vous avez l'autorisation de copier, distribuer et/ou modifier ce document suivant les termes de la GNU Free Documentation License, Version 1.2 ou n'importe quelle version ultérieure publiée par la Free Software Foundation; sans section invariante, sans page de garde, sans entête et sans page finale.