Add files via upload

Corrigé_TD1/exo0.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+int main(const int argc, char *argv[] ){
+    //argc : nombre d’arguments, argv : le tableau contenant la valeur des arguments
+    int a = 1 ;
+    printf(" le chiffre est %d \n ", a);
+
+    char clavier[100];
+    printf(" Saisissez le texte : ");
+    scanf("%s", clavier);
+    printf("vous avez saisie : %s \n", clavier);
+
+    printf("\nMainenant, on va lister tous les arguments (argv)\n");
+    int i;
+    for (i = 0; i < argc; i++){
+        printf("%s \n", argv[i]);
+    }
+
+    return 0;
+}

Corrigé_TD1/exo1.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void plus(const int *a, const int *b, int *c) {
+    *c = *a + *b;
+}
+
+void moins(const int *a, const int *b, int *c) {
+    *c = *a - *b;
+}
+
+void fois(const int *a, const int *b, int *c) {
+    *c = *a * *b;
+}
+
+int main(const int argc, char const *argv[]) {
+    int x = 50;
+    int y = 20;
+    int z = 0;
+
+    plus(&x, &y, &z);
+    printf("plus \t: x=%d y=%d z=%d\n", x, y, z);
+    moins(&x, &y, &z);
+    printf("moins \t: x=%d y=%d z=%d\n", x, y, z);
+    fois(&x, &y, &z);
+    printf("fois \t: x=%d y=%d z=%d\n", x, y, z);
+
+    return 0;
+}

Corrigé_TD1/exo2.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct {
+    int x;
+    int y;
+    int z;
+} Coordonnees;
+
+void affichage(Coordonnees *c) {
+    printf("x=%d y=%d z=%d\n", c->x, c->y, c->z);
+}
+
+void initialise(Coordonnees *c) {
+    c->x = 10;
+    c->y = 5;
+    c->z = 2;
+}
+
+void addition(Coordonnees *c) {
+    c->z = c->x + c->y;
+}
+
+void multiplication(Coordonnees *c) {
+    c->z = c->x * c->y;
+}
+
+
+int main(const int argc, char *argv[]) {
+    Coordonnees ici;
+
+    printf("initialisation\n");
+    initialise(&ici);
+    affichage(&ici);
+
+    printf("addition\n");
+    addition(&ici);
+    affichage(&ici);
+
+    printf("multiplication\n");
+    multiplication(&ici);
+    affichage(&ici);
+
+    return 0;
+}

Corrigé_TD1/exo3.c

@@ -0,0 +1,57 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct {
+    int x;
+    int y;
+    int z;
+} Coordonnees;
+
+void affichage(Coordonnees *c) {
+    printf("x=%d y=%d z=%d\n", c->x, c->y, c->z);
+}
+
+void initialise(Coordonnees *c) {
+    c->x = 10;
+    c->y = 5;
+    c->z = 2;
+}
+
+void addition(Coordonnees *c) {
+    c->z = c->x + c->y;
+}
+
+void multiplication(Coordonnees *c) {
+    c->z = c->x * c->y;
+}
+
+void initialiseEtAffichage(Coordonnees *c) {
+    initialise(c);
+    affichage(c);
+}
+
+void additionEtAffichage(Coordonnees *c) {
+    addition(c);
+    affichage(c);
+}
+
+void multiplicationEtAffichage(Coordonnees *c) {
+    multiplication(c);
+    affichage(c);
+}
+
+
+int main(const int argc, char *argv[]) {
+    Coordonnees ici;
+
+    printf("initialisation\n");
+    initialiseEtAffichage(&ici);
+
+    printf("addition\n");
+    additionEtAffichage(&ici);
+
+    printf("multiplication\n");
+    multiplicationEtAffichage(&ici);
+
+    return 0;
+}

Corrigé_TD1/exo4.c

@@ -0,0 +1,75 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define NB_MIN 1
+#define NB_MAX 100
+#define TAILLE_MIN 1
+#define TAILLE_MAX 1000
+
+int randomNumber() {
+    return (rand() % (NB_MAX - NB_MIN)) + NB_MIN;
+}
+
+int saisirTailleTableau() {
+    int taille = 0;
+    printf("Saisir la taille du tableau (1 -> 1000) :\n");
+    scanf("%d", &taille);
+
+    return taille;
+}
+
+void verifierTailleTableau(const int taille) {
+    if (taille < TAILLE_MIN) {
+        printf("Nombre trop petit. Fin du programe\n");
+        exit(1);
+    }
+
+    if (taille > TAILLE_MAX) {
+        printf("Nombre trop grand. Fin du programe\n");
+        exit(1);
+    }
+}
+
+int *construireTableau(const int taille) {
+    int *tab = (int*) malloc(taille * sizeof(int));
+
+    if (tab == NULL) {
+        printf("Allocation échouée\n");
+        exit(1);
+    }
+
+    for (int i = 0; i < taille; ++i) {
+        tab[i] = randomNumber();
+    }
+
+    return tab;
+}
+
+void afficherTableau(int *tab, const int taille) {
+    printf("Affichage\n");
+
+    for (int i = 0; i < taille; ++i) {
+        printf("[%d] = %d\n", i, tab[i]);
+    }
+}
+
+void detruireTableau(int *tab) {
+    free(tab);
+    tab = NULL;
+}
+
+
+int main(const int argc, const char *argv[]) {
+    srand(time(NULL));
+
+    int tailleTableau = saisirTailleTableau();
+    verifierTailleTableau(tailleTableau);
+
+    printf("Construction d'un tableau de taille %d\n", tailleTableau);
+    int *tableau = construireTableau(tailleTableau);
+    afficherTableau(tableau, tailleTableau);
+    detruireTableau(tableau);
+
+    return 0;
+}

Corrigé_TD1/exo5.c

@@ -0,0 +1,104 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#define NB_MIN 0
+#define NB_MAX 100
+#define TAILLE_MIN 1
+#define TAILLE_MAX 1000
+
+int randomNumber() {
+    return (rand() % (NB_MAX - NB_MIN)) + NB_MIN;
+}
+
+int *constructionTableau(const int taille) {
+    int *tableau = (int *) malloc(taille * sizeof(int));
+
+    if (tableau == NULL) {
+        printf("Allocation echouée\n");
+        exit(1);
+    }
+
+    for (int i = 0; i < taille; i++) {
+        tableau[i] = randomNumber();
+    }
+
+    return tableau;
+}
+
+void destructionTableau(int *chiffres) {
+    free(chiffres);
+    chiffres = NULL;
+}
+
+void afficherTableau(int *chiffres, const int taille) {
+    printf("Affichage\n");
+
+    for (int i = 0; i < taille; i++) {
+        printf("[%d] : %d\n", i, chiffres[i]);
+    }
+}
+
+int saisirTailleTableau() {
+    int taille = 0;
+    printf("Saisir la taille du tableau (1 -> 1000) :\n");
+    scanf("%d", &taille);
+
+    return taille;
+}
+
+void verifierValiditeSaisie(const int nombre) {
+    if (nombre > TAILLE_MAX) {
+        printf("Nombre trop grand. Fin du programme\n");
+        exit(1);
+    }
+
+    if (nombre < TAILLE_MIN) {
+        printf("Nombre trop petit. Fin du programme\n");
+        exit(1);
+    }
+}
+
+void modifierTailleTableau(int *chiffres, const int nouvelleTaille, const int ancienneTaille) {
+    int *nouveau = realloc(chiffres, nouvelleTaille * sizeof(int));
+
+    if (nouveau == NULL) {
+        printf("La réallocation a échouée!\n");
+        free(nouveau);
+
+        exit(1);
+    }
+
+    // si la nouvelle taille est plus grande, on génère des nombres pour les nouvelles cases
+    if (nouvelleTaille > ancienneTaille) {
+        for (int i = ancienneTaille; i < nouvelleTaille; i++) {
+            nouveau[i] = randomNumber();
+        }
+    }
+
+    chiffres = nouveau;
+}
+
+
+int main(const int argc, char *argv[]) {
+    srand(time(NULL)); //initialise le générateur aléatoire
+
+    int tailleTableau = saisirTailleTableau();
+    verifierValiditeSaisie(tailleTableau);
+
+    printf("Construction d'un tableau de taille %d\n", tailleTableau);
+    int *tableau = constructionTableau(tailleTableau);
+    afficherTableau(tableau, tailleTableau);
+
+    int nouvelleTailleTableau = saisirTailleTableau();
+    verifierValiditeSaisie(nouvelleTailleTableau);
+
+    printf("Nouvelle taille du tableau %d\n", nouvelleTailleTableau);
+    modifierTailleTableau(tableau, nouvelleTailleTableau, tailleTableau);
+
+    afficherTableau(tableau, nouvelleTailleTableau);
+    destructionTableau(tableau);
+
+    return 0;
+}