update

DEV.1.1/CM3/Makefile

@@ -0,0 +1,40 @@
+### VARIABLES ###
+ 
+CC = gcc
+CFLAGS = -Wall \
+        -ansi \
+         -pedantic
+         
+EXE = exe
+OFILES = ex3.o \
+         queue.o \
+      
+### BUT PAR DEFAUT ###
+ 
+but : ${EXE}
+
+### REGLES ESSENTIELLES ###
+
+${EXE} : ${OFILES}
+	$(CC) $(CFLAGS) -o ${EXE} ${OFILES}
+
+
+ex3.o : queue.h 
+
+queue.o : queue.h 
+
+### REGLES OPTIONNELLES ###
+
+run : but
+	./${EXE}
+
+clean :
+	-rm -f ${OFILES} ${EXE}
+
+mrproper : clean but
+ 
+### BUTS FACTICES ###
+ 
+.PHONY : but clean mrproper
+ 
+### FIN ###

DEV.1.1/CM3/ex2.c

@@ -22,12 +22,10 @@ int main(int argc, char *argv[]) {
         return EXIT_FAILURE;
     }
 
-    size_t read;
+    
     /* réecriture du texte dans le fichier temporaire en remplaçant les points d'interrogation grecs par des points-virgules*/
     while(1){
-        read = fread(buffer, sizeof(*buffer),file)
-        if("0xCD" || "0xBE")
-    if () {
+        if(fread(file) == "0xCD" || "0xBE"){
         perror("Erreur d'écriture dans le fichier temporaire");
         fclose(file);
         fclose(tempFile);

DEV.1.1/CM3/ex3.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "queue.h"
+
+int main(int argc, char *argv[]){
+	int i, ignores, somme;
+
+	for(i=0;i<=argc;i++){
+		if(argv[i]<10){
+
+		}else if(argv[i]>="a" || argv[i]<="z"){
+			while(argv[i]!=" "){
+				ignores = ignores + argv[i];
+			}
+			ignores = ignores + " ";
+
+		}else if(argv[i]<0 || argv[i]>0){
+			while(argv[i]!=" "){
+			somme = somme + argv[i];
+		}
+	}
+
+	}
+
+	printf("somme : %d\n", somme);
+	printf("ignorés : %s\n", ignores)
+}

DEV.1.1/CM3/queue.c

@@ -0,0 +1,69 @@
+#include <stdlib.h>
+#include "queue.h"
+
+struct s_link {
+  unsigned value;
+  struct s_link *next;
+};
+
+typedef struct s_link link;
+
+struct s_queue {
+  link *first; /* sortie */
+  link *last;  /* entrée */
+};
+
+
+/* crée une file vide */
+queue create_queue(void) {
+  return (queue) calloc(1, sizeof(struct s_queue));
+}
+
+/* ajoute un élément à la file. Renvoie 0 en cas d'échec */
+int enqueue(queue the_queue, unsigned the_value) {
+  link *new = (link*) malloc(sizeof(link));
+  if (new == NULL) {
+    return 0;
+  }
+  new->value = the_value;
+  new->next = NULL;
+  if (the_queue->last == NULL) {
+    the_queue->first = new;
+  } else {
+    the_queue->last->next = new;
+  }
+  the_queue->last = new;
+  return 1;
+}
+
+/* renvoie 1 si la file est vide */
+int empty(queue the_queue) {
+  return the_queue->first == NULL;
+}
+
+/* retire un élément de la file. Renvoie l'élément retiré, ou -1 en cas d'échec */
+long dequeue(queue the_queue) {
+  if(the_queue->first == NULL) {
+    return -1;
+  }
+  link l = *(the_queue->first);
+  free(the_queue->first);
+  the_queue->first = l.next;
+  if (the_queue->first == NULL) {
+    the_queue->last = NULL;
+  }
+  return l.value;
+}
+
+/* détruit une file en libérant les ressources associées */
+void destroy_queue(queue the_queue) {
+  link *current, *saved;
+
+  current = the_queue->first;
+  while(current != NULL) {
+    saved = current->next;
+    free(current);
+    current = saved;
+  }
+  free(the_queue);
+}

DEV.1.1/CM3/queue.h

@@ -0,0 +1,22 @@
+#ifndef QUEUE_H
+#define QUEUE_H
+
+/* le type queue représente une file */
+typedef struct s_queue *queue;
+
+/* crée une file vide. Renvoie NULL en cas d'échec */
+queue create_queue(void);
+
+/* ajoute un élément à la file. Renvoie 0 en cas d'échec */
+int enqueue(queue, unsigned);
+
+/* renvoie 1 si la file est vide */
+int empty(queue);
+
+/* retire un élément de la file. Renvoie l'élément retiré, ou -1 en cas d'échec */
+long dequeue(queue);
+
+/* détruit une file en libérant les ressources associées */
+void destroy_queue(queue);
+
+#endif /* QUEUE_H */

DEV.1.1/Piles_et_Files/fonct.c

@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAX_SIZE 50
+
+typedef struct {
+    char tab[MAX_SIZE];
+    int indice_debut;
+    int indice_fin;
+    int taille;
+} pile;
+
+typedef struct maillon_s {
+    char valeur;
+    struct maillon_s* suivant;
+} maillon;
+
+typedef struct {
+    maillon* tete;
+    maillon* queue;
+} file;
+
+void push_pile(pile* p, char valeur) {
+    if (p->taille < MAX_SIZE) {
+        p->tab[p->taille++] = valeur;
+    } else {
+        printf("Erreur: pile pleine\n");
+    }
+}
+
+char pop_pile(pile* p) {
+    if (p->taille > 0) {
+        return p->tab[--p->taille];
+    }
+    printf("Erreur: pile vide\n");
+    return '\0';
+}
+
+int empty_pile(pile* p) {
+    return p->taille == 0;
+}
+
+void enqueue_file(file* f, char valeur) {
+    maillon* nouveau = (maillon*)malloc(sizeof(maillon));
+    if (nouveau == NULL) {
+        printf("Erreur: allocation memoire\n");
+        exit(EXIT_FAILURE);
+    }
+    nouveau->valeur = valeur;
+    nouveau->suivant = NULL;
+    if (f->queue == NULL) {
+        f->tete = f->queue = nouveau;
+    } else {
+        f->queue->suivant = nouveau;
+        f->queue = nouveau;
+    }
+}
+
+char dequeue_file(file* f) {
+    if (f->tete == NULL) {
+        printf("Erreur: file vide\n");
+        return '\0';
+    }
+    maillon* temp = f->tete;
+    char valeur = temp->valeur;
+    f->tete = f->tete->suivant;
+    if (f->tete == NULL) {
+        f->queue = NULL;
+    }
+    free(temp);
+    return valeur;
+}
+
+int empty_file(file* f) {
+    return f->tete == NULL;
+}
+
+int main(void) {
+    pile p = {{0}, 0, 0, 0};
+    file f = {NULL, NULL};
+    char ordre[2];
+
+    printf("La pile et la file attendent vos ordres \n > ");
+    while (scanf("%1s", ordre) == 1) {
+        if (ordre[0] == 'q') {
+            printf("Au revoir\n");
+            break;
+        } else if (ordre[0] == '+') {
+            scanf(" %c", &ordre[1]);
+            push_pile(&p, ordre[1]);
+            enqueue_file(&f, ordre[1]);
+        } else if (ordre[0] == '-') {
+            printf("Pop: %c\n", pop_pile(&p));
+            printf("Dequeue: %c\n", dequeue_file(&f));
+        } else {
+            printf("Commande invalide\n");
+        }
+        printf("\nLa pile et la file attendent vos ordres \n > ");
+    }
+
+    return EXIT_SUCCESS;
+}

DEV.1.1/Piles_et_Files/fonct_file.c

@@ -0,0 +1,70 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct maillon_s {
+    char valeur;
+    struct maillon_s* suivant;
+} maillon;
+
+typedef struct {
+    maillon* tete;
+    maillon* queue;
+} file;
+
+void enqueue_file(file* f, char valeur) {
+    maillon* nouveau = (maillon*)malloc(sizeof(maillon));
+    if (nouveau == NULL) {
+        printf("Erreur: allocation memoire\n");
+        exit(EXIT_FAILURE);
+    }
+    nouveau->valeur = valeur;
+    nouveau->suivant = NULL;
+    if (f->queue == NULL) {
+        f->tete = f->queue = nouveau;
+    } else {
+        f->queue->suivant = nouveau;
+        f->queue = nouveau;
+    }
+}
+
+char dequeue_file(file* f) {
+    if (f->tete == NULL) {
+        printf("Erreur: file vide\n");
+        return '\0';
+    }
+    maillon* temp = f->tete;
+    char valeur = temp->valeur;
+    f->tete = f->tete->suivant;
+    if (f->tete == NULL) {
+        f->queue = NULL;
+    }
+    free(temp);
+    return valeur;
+}
+
+int empty_file(file* f) {
+    return f->tete == NULL;
+}
+
+int main(void) {
+    file f = {NULL, NULL};
+    char ordre[2];
+
+    printf("La file attend vos ordres \n > ");
+    while (scanf("%1s", ordre) == 1) {
+        if (ordre[0] == 'q') {
+            printf("Au revoir\n");
+            break;
+        } else if (ordre[0] == '+') {
+            scanf(" %c", &ordre[1]);
+            enqueue_file(&f, ordre[1]);
+        } else if (ordre[0] == '-') {
+            printf("Dequeue: %c\n", dequeue_file(&f));
+        } else {
+            printf("Commande invalide\n");
+        }
+        printf("\nLa file attend vos ordres \n > ");
+    }
+
+    return EXIT_SUCCESS;
+}

DEV.1.1/Piles_et_Files/fonct_pile.c

@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MAX_SIZE 50
+
+typedef struct {
+    char tab[MAX_SIZE];
+    int taille;
+} pile;
+
+void push_pile(pile* p, char valeur) {
+    if (p->taille < MAX_SIZE) {
+        p->tab[p->taille++] = valeur;
+    } else {
+        printf("Erreur: pile pleine\n");
+    }
+}
+
+char pop_pile(pile* p) {
+    if (p->taille > 0) {
+        return p->tab[--p->taille];
+    }
+    printf("Erreur: pile vide\n");
+    return '\0';
+}
+
+int empty_pile(pile* p) {
+    return p->taille == 0;
+}
+
+int main(void) {
+    pile p = {{0}, 0};
+    char ordre[2];
+
+    printf("La pile attend vos ordres \n > ");
+    while (scanf("%1s", ordre) == 1) {
+        if (ordre[0] == 'q') {
+            printf("Au revoir\n");
+            break;
+        } else if (ordre[0] == '+') {
+            scanf(" %c", &ordre[1]);
+            push_pile(&p, ordre[1]);
+        } else if (ordre[0] == '-') {
+            printf("Pop: %c\n", pop_pile(&p));
+        } else {
+            printf("Commande invalide\n");
+        }
+        printf("\nLa pile attend vos ordres \n > ");
+    }
+
+    return EXIT_SUCCESS;
+}