buffer circulaire

je débute et je découvre le langage C. J'essaie de faire qques trucs... Mais je rencontre encore de nombreuses limites à mes capacités à programmer en C.
Dernièrement, on m'a parlé de buffer circulaire. On m'a expliqué un peu prêt le principe... Toutefois, je ne vois pas trop comment en programmer un sauf en faisant p'être un tableau statique avec des pointeurs (un pour la lecture et un autre pour l'écriture sur le buffer???). Mais comment gérer les priorités ? Enfin bref tout ça pour dire que je suis en train de m'enliser!!!
Si qqu'un connaît les buffer circulaires et peut me redonner une explication un peu plus claire sur leur fonctionnement...? Ou bien, je suis ouvert aux idées et aux suggestions pour en programmer un?

merci par avance

Citation:

---

Envoyé par fumble

Dernièrement, on m'a parlé de buffer circulaire. On m'a expliqué un peu prêt le principe... Toutefois, je ne vois pas trop comment en programmer un sauf en faisant p'être un tableau statique avec des pointeurs (un pour la lecture et un autre pour l'écriture sur le buffer???).

---

C'est un bon début.

Citation:

---

Mais comment gérer les priorités ? Enfin bref tout ça pour dire que je suis en train de m'enliser!!!
Si qqu'un connaît les buffer circulaires et peut me redonner une explication un peu plus claire sur leur fonctionnement...? Ou bien, je suis ouvert aux idées et aux suggestions pour en programmer un?

---

Ecrit déjà des specificationss claires, ensuite essaie de coder quelque chose. Sur ces bases, on pourra t'aider.

voila un petit algo utilisant un buffer circulaire que j'aimerais soumettre à vos remarques. Ce programme attends et enregistre l'appuie sur des touches jusqu'a l'appui sur Entrée puis affiche les six dernières touches appuyée.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

#include<stdio.h> #include<conio.h>     ////////// char* creer_buffer(int); char* retour_buffer(char*, int, int); //////////////     int main(int argc, char** argv) {   int i; int index=0; char caractere; char* buffer=creer_buffer(6);     do { do{}while(!kbhit()); caractere=getch();   if(caractere!=13) { buffer[index]=caractere; index=(index+1)%6; }   }while(caractere!=13);   char* mot=retour_buffer(buffer,6,index); printf("\nles six dernieres touches sont : \"%s\"\n",mot); printf("buffer = %s\n", buffer);   free(buffer); free(mot); printf("\n"); system("pause"); return 0; }       ///////////////////////////// char* creer_buffer(int taille) { char* buffer=(char*)malloc(taille*sizeof(char)); return buffer; }     char* retour_buffer(char* buffer, int taille, int index) { char* mot=creer_buffer(taille+1);   int j=0; int i=index; while(j<6) { mot[j]=buffer[i]; j++; i=(i+1)%taille; } mot[taille]=0; return mot; }

---

ce code fonctionne, mais j'aimerais avoir votre avis.

Code:

---

int main(int argc, char** argv)

---

je n'en suis pas encore là en C avec le **. Je ne sais pas trop encore à koi cela correspond... mais cela doit être bien!

Code:

---

index=(index+1)%6;

---

je pense qu'ici en uilisant le modulo tu reviens au début de ton buffer ( j'essaie de comprendre ton algo, o risk d'être vu comme un idiot. Mè je vsuis en train d'apprendre le C. Alors j'essaie de comprendre...

Code:

---

}while(caractere!=13);

---

Ici 13 représente la touche "ENTREE"

Code:

---

1 2 3 4 5 6 7

char* mot=retour_buffer(buffer,6,index); printf("\nles six dernieres touches sont : \"%s\"\n",mot); printf("buffer = %s\n", buffer);   free(buffer); free(mot);

---

Ici je suis un peu perdu !!! je ne sais pas à koi cle correspond

Code:

---

system("pause");

---

cette instruction évite que l'écran se ferme de suite?

Code:

---

1 2	char* buffer=(char*)malloc(taille*sizeof(char)); return buffer;

---

Malloc sert a allouer de la mémoire en dynamique (je crois)? Alors pourquoi déterminer un buffer avec 6 caractères ? Je ne connais pas Malloc, et je souhaite comprendre comment el focntionne.

ton petit algo semble bien avec le peu que je comprend, il parait logique et tourner. Mè, ds l'immédiat, mon avis ne te servira pas à grand chose étant donné mes premiers pas ds ce fabuleux langage.

cordialement fumble

Ps: quoiqu'il en soit, si tu veux bien me fournir plus de détails sur ton algo (comment il tourne, les instructions que je ne connais pas... n'hesite surtout pas à en faire part sur le forum!)

[balise [code] ajouté par netah_25 - Merci d'y penser a l'avenir]

De mon côté, j'ai essayé de faire quelque chose sur le buffer circulaire. C'est un tableau qui nécessite 2 pointeurs : un en écriture et l'autre en lecture. Lorsque les pointeurs arrivent à la fin du parcours, ils doivent revenir au début du tableau.
Mais j'ai un problème au niveau de l'écriture dans le tableau. En effet, le tableau doit se remplir avec des données provenant d'un port et stocker la donnée dans une de ses cases. .. Et là, je ne sais pas comment faire???
Voici l'ebauche de mon alog:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

/* inclusions des en-tetes */ #include <stdio.h>   /* definition des pointeurs d'ecriture et de lecture */ char *ptr_write; char *ptr_read;   /* definition du tableau buffer, limit‚ a 8 char pour l'instant */ char array [8];   /* declaration des variables */ int i; char c;   /*fonction de lecture */ char read (int a) { ptr_read= array; //initialisation du ptr   for (a=0;a=<array[i];a++) { printf ("Valeur contenu dans le pointeur :%d\n",*ptr_read); c= *ptr_read; //enregistrement de la valeur if a=array[8] { ptr_read=array % sizeof(char)*8; } else { ptr_read++; //incrementation du ptr sur la next lecture } return 0; } }   /* fonction d'ecriture dans le tableau */ //char write (int b) /* {  ptr_write=array; //initialisation du pointeur    for (b=0;b=<array[i];b++)  {  if array[]=' '   { c= */

---

//c'est là que je bloque.

bon, j'avoue, je ne suis pas très sûr de la logique, mè il semble être correct... Je n'ai pas encore écris le main! Dans ce petit algo, se tient toutes mes connaissances actuelles en C, pour l'instant!!!
Merci par avance de tous vos commentaires et remarques, à l'égard de cet algo (avec votre plus grande indulgence s'il vous plaît) :)

[balises code ajoutées par Gangsoleil]

Citation:

---

Envoyé par le y@m's

Code:

---

1 2	do{}while(!kbhit()); caractere=getch();

---

---

Tu vient de recoder getchar() qui lui est standard :lol:

Citation:

---

Envoyé par le y@m's

Code:

---

caractere!=13

---

---

Ce n'est pas portable en plus '\n' est plus comprehensible.

Citation:

---

Envoyé par le y@m's

Code:

---

char* mot=retour_buffer(buffer,6,index);

---

---

Ce n'est pas du C++.

Citation:

---

Envoyé par le y@m's

Code:

---

char* buffer=(char*)malloc(taille*sizeof(char));

---

---

malloc peut echouer.

Citation:

---

Envoyé par le y@m's

Code:

---

while(j<6)

---

---

Pourquoi ne pas utliser taille :?:

La taille de buffer revient souvent et ceux dans plusieurs fonctions, il serait préférable d'en faire une macro (#define).
Je pense qu'il y a plus simple que la fonction retour_buffer qui, si j'ai bien compris reorganise le tableau dans l'ordre chronologique.

fumble >> je pense que tu devrait revenir avec le code complet et ouvrir un nouveau topic en cas de problème.

Citation:

---

Envoyé par le y@m's

ce code fonctionne, mais j'aimerais avoir votre avis.

---

Ca fonctionne, mais c'est un peu compliqué et pas très réutilisable...

Ca manque surtout de reflexion sur la conception. Qu'est-ce qu'un buffer circulaire ? Quelles sont les fonctions ? Quelles en sont les propriétés etc.

Un exemple de FIFO de unsigned char:

http://emmanuel-delahaye.developpez.com/clib.htm
Module FIFO

Merci pour vos remarques,
pourquoi

Code:

---

caractere!=13

---

n'est pas portable?

fumble >>

Code:

---

int main(int argc, char** argv)

---

argc et **argv permette d'utiliser d'eventuels parametres passé a ton programme.
argc=nombre de paramètre passés à l'executable (nom de l'executable compris)
**argv ou *argv[] est un tableau de chaine de caractere qui stock le nom du programme ainsi que les paramètres passés à l'executable.
expl : prog.exe est un programme auquel on passe un paramètre -> "prog parametre1"
alors argc=2, argv[0]="prog", argv[1]="parametre1"

Code:

---

1 2	free(buffer); free(mot);

---

permet de libérer la mémoir allouée par malloc.
malloc et realloc permette d'allouer dynamiquement les pointeurs tu devrez trouver facilement de la doc dessus :
http://www.lri.fr/~aze/page_c/aide_c/malloc.html
http://www.lri.fr/~aze/page_c/aide_c/realloc.html
http://emmanuel-delahaye.developpez....tes.htm#malloc (merci Emmanuel :wink: )
http://emmanuel-delahaye.developpez....es.htm#realloc (merci Emmanuel :wink: )

gege2061 a écrit:

Citation:

---

Tu vient de recoder getchar() qui lui est standard

---

Et non car avec getchar() les caracteres apparaissent à l'ecran mais pas avec

Code:

---

1 2	do{}while(!kbhit()); caractere=getch();

---

pour avoir l'equivalent de getchar() il faut remplacer getch() par getche() :wink:

Citation:

---

Envoyé par le y@m's

Merci pour vos remarques,
pourquoi

Code:

---

caractere!=13

---

n'est pas portable?

---

Il n'existe pas que la table ASCII pour le codage des caractères!

Citation:

---

Envoyé par le y@m's

gege2061 a écrit:

Citation:

---

Tu vient de recoder getchar() qui lui est standard

---

Et non car avec getchar() les caracteres apparaissent à l'ecran mais pas avec

Code:

---

1 2	do{}while(!kbhit()); caractere=getch();

---

pour avoir l'equivalent de getchar() il faut remplacer getch() par getche() :wink:

---

Bien vue :wink:

voici mon algo : :?

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

1 #include <stdio.h> 2 #include <conio.h>     3 /* definition des pointeurs d'ecriture et de lecture */ 4 char *ptr_write; 5 char *ptr_read;   6 /* definition du tableau buffer, limite a 8 char pour l'instant */ 7 char array [8];   8 /* declaration des variables */ 9 int i; 10 char c;   11 /* --------------------------------------------------------------- */ 12 /* declaration des protoypes 13 read(); 14 write();   16 /* --------------------------------------------------------------- */ 17 /* fonction main 18 main () 19 { 20 if (ptr_write=array[i]) && (ptr_read=array[i+1]) 21 {read();} 22 else {write();} 23 }   24 /* --------------------------------------------------------------- */ 25 /* fonction d'ecriture dans le tableau */ 26 write () 27 { 28 ptr_write=array; /* initialisation du pointeur */   29 printf("Pressez une touche pour continuer"); 30 for (i=0;array[i];i++) 31 { 32 while (!khbit()) /* test de saisie */ 33 { 34 c=getch(); 35 return 0; 36 } 37 ptr_write=&c; 38 printf("valeur contenu dans le buffer: %c\n",*ptr_write); 39 return 0; 40 }   41 if (i=0) 42 {ptr_write=& (array % sizeof(char) * 8);} 43 else 44 {ptr_write++;} 45 }     46 /* -------------------------------------------------------------- */ 47 /*fonction de lecture */ 48 read () 49 { 50 ptr_read= array; /* initialisation du ptr */   51 for (i=0;array[i];i++) 52 { 53 ptr_read= &c; /* enregistrement de la valeur */ 54 printf ("Valeur contenu dans le pointeur :%c\n",*ptr_read); 55 return 0; 56 }   57 if (i=array[8]) 58 {ptr_read=&(array % sizeof(char)*8);} 59 else 60 {ptr_read++;} /* incrementation du ptr sur la next lecture 61 */ 62 }

---

en compilant, il me signal des warning:
Ligne 41 & 57: possibly incorrect assignement in function write & read
et des errors:
Ligne 42 & 58:illegel use of pointer in function write & read
:(

PS: Merci à toi Le y@m's pour tes réponses à mes interrogations :D

Citation:

---

Envoyé par fumble

voici mon algo : :?
1 #include <stdio.h>
2 #include <conio.h>

---

Numérotage inutile. :tagcode:

Citation:

---

<...>

---

Tu peux commencer par rendre ton code compilable (commentaires pas fermés, parenthèses fermantes manquantes) et par corriger tout ça:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

main.c:19: warning: type defaults to `int' in declaration of `read' main.c:19: warning: function declaration isn't a prototype main.c:19: warning: data definition has no type or storage class main.c:20: warning: type defaults to `int' in declaration of `write' main.c:20: warning: function declaration isn't a prototype main.c:20: warning: data definition has no type or storage class main.c:25: warning: return type defaults to `int' main.c:25: warning: function declaration isn't a prototype main.c: In function `main': main.c:26: warning: assignment makes pointer from integer without a cast main.c:26: warning: suggest parentheses around assignment used as truth value main.c:27: parse error before '(' token main.c:26: warning: empty body in an if-statement main.c:27: warning: assignment makes pointer from integer without a cast main.c:28: parse error before '{' token   main.c: At top level: main.c:36: parse error before string constant   main.c:36: warning: type defaults to `int' in declaration of `system' main.c:36: warning: function declaration isn't a prototype main.c:36: warning: redundant redeclaration of `system' in same scope C:/DEV-CPP/include/stdlib.h:376: warning: previous declaration of `system' main.c:36: warning: data definition has no type or storage class main.c:42: warning: return type defaults to `int' main.c:42: warning: function declaration isn't a prototype main.c: In function `write': main.c:48: warning: implicit declaration of function `khbit' main.c:58: warning: suggest parentheses around assignment used as truth value main.c:60: invalid operands to binary % main.c:60: `Cool' undeclared (first use in this function) main.c:60: (Each undeclared identifier is reported only once main.c:60: for each function it appears in.) main.c: At top level: main.c:72: warning: return type defaults to `int' main.c:72: warning: function declaration isn't a prototype main.c: In function `read': main.c:82: warning: suggest parentheses around assignment used as truth value main.c:84: invalid operands to binary % main.c:84: `Cool' undeclared (first use in this function)

---

L'opérateur de comparaison est '==' et non '='

Ton code parait extrèmement complexe, alors qu'il s'agit d'une chose assez simple en fait. Plutôt que de sauter sur le clavier et de sortir du code à tout prix, il est préférable de réfléchir 5 minutes (allez, 10) à ce qu'est un buffer circulaire, à quoi ça sert et comment on l'utilise. Les idées principales sont là (fonction d'ecriture, de lecture, pointeurs du même nom etc. Mais le tout est assez brouillon et utilise des principe peu fiables et pas réutilisables comme les globales...

Reprenons.

Un tampon circulaire est un tableau d'objets d'une taille définie accessible d'une part en écriture, d'autre part en lecture.

Il est considéré comme vide au démarrage. Il permet un certain nombre d'écriture (fonction évidemment de la taille du tableau).

Lorsque le tableau est rempli, il est alors considéré comme plein, et il devient alors impossible de stocker une donnée supplémentaire. C'est donc la fonction d'écriture qui évalue l'état 'plein'.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

IF NOT plein buffer[index_ecriture] := donnee   index_ecriture := index_ecriture + 1   IF index_ecriture = taille_tableau index_ecriture := 0; ENDIF   vide := FALSE IF index_ecriture = index_lecture plein := TRUE; ENDIF   ENDIF

---

La fonction d'écriture ne peut extraire une donnée que si le tampon n'est pas vide. Lorsqu'il a tout lu le tampon est vide.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

IF NOT vide donnee := buffer[index_lecture]   index_lecture := index_lecture + 1   IF index_lecture = taille_tableau index_lecture := 0; ENDIF   plein := FALSE IF index_ecriture = index_lecture vide := TRUE; ENDIF   ENDIF

---

Et voilà, tout est dit.

Il est d'usage, afin de permettre l'instantiation de définir une structure pour regrouper les données, de créer la structure à la demande et de définir des fonctions

• create()
• delete()
• write()
• read()
• is_full()
• is_empty()

etc. A toi d'écrire un code un peu meilleur. Je ne veux pas voir de globales...

Citation:

---

Envoyé par Emmanuel Delahaye

Tu peux commencer par rendre ton code compilable (commentaires pas fermés, parenthèses fermantes manquantes) et par corriger tout ça:

---

OK, t'as raison, je vais reprendre tranquillement mon code en essayant de le simplifier... (mè je ne comprend pas: mes commentaires sont pourtant fermés par /* et */, mes parenthèses sont aussi fermées...).

Citation:

---

Envoyé par Emmanuel Delahaye

A toi d'écrire un code un peu meilleurs. Je ne veux pas voir de globales...

---

Autre interrogation:peux-tu m'éclairer sur le sens de "globales"?

Je te remercie de tous tes conseils et toutes tes explications précieuses.
:D
bien cordialement,
fumble

Les globales c'est ça : des variables déclarées hors le code des fonctions.

Citation:

---

/* definition des pointeurs d'ecriture et de lecture */
char *ptr_write;
char *ptr_read;

/* definition du tableau buffer, limite a 8 char pour l'instant */
char array [8];

/* declaration des variables */
int i;
char c;

---

Pour les prototypes on fait mieux maintenant :

Code:

---

1 2 3 4

/* --------------------------------------------------------------- */ /* declaration des protoypes int read(void); int write(void);

---

Attention à la fonction write :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

write () 27 { 28 ptr_write=array; /* initialisation du pointeur */   29 printf("Pressez une touche pour continuer"); 30 for (i=0;array[i];i++) 31 { 32 while (!khbit()) /* test de saisie */ 33 { 34 c=getch(); 35 return 0; 36 } 37 ptr_write=&c; 38 printf("valeur contenu dans le buffer: %c\n",*ptr_write); 39 return 0; 40 }   41 if (i=0) 42 {ptr_write=& (array % sizeof(char) * 8);} 43 else 44 {ptr_write++;} /////////////////////////////////////////////////////// // ici elle ne retourne rien !!! /////////////////////////////////////////////////////// 45 }

---

Je n'ai pas vérifié pour la fonction read.

Encore une fois merci pour votre aide et vos explication... et pardonnez mon incompétence et ma curiosité (qui peut être "casse-pieds, mais j'aime bien comprendre). Cependant des questions me titillent les lèvres. Malheureusement, je ne trouve pas d'explication claire (ou du moins qui me correspondent) dans les livres...

Citation:

---

Envoyé par Trap D

Les globales c'est ça : des variables déclarées hors le code des fonctions.

---

Citation:

---

Envoyé par Emmanuel Delahaye

Je ne veux pas voir de globales...

---

et à moi, on me dit qu'il faut faire des variables globales. Alors, où est le bien et le mal dans ces deux écoles???

quant aux prototypes:

Citation:

---

Envoyé par Trap D

Code:

---

1 2 3 4

/* --------------------------------------------------------------- */ /* declaration des protoypes int read(void); int write(void);

---

---

Je souhaite que mes fonctions lisent ou écrivent un char, il faut malgré tout, les typer en int?
Si la fonction ne retourne rien, on met void ou ()?
Quand est-ce que l'on sait si on doit mettre des paramètres entrant ou sortant ? Y a-til un doc qui explique clairement et simplement les paramètres in, out ?

Par avence merci.

les variables globales sont déclarés en dehors et avant le corps du main ou des fonctions

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#include<stdio.h>     char var1;// int var2;//variables globales   fonction1();   int main() { char var3;// int var4;//variables locales   ...}   fonction1() {...}

---

La différence entre les variables locales et globales est leur portée :
une globale est "reconnu" dans tout ton code et une locale n'est "reconnu" que dans sa procedure dans mon exemple : le main ET fonction1 peuvent travailler sur var1 et var2 mais seulement le main connait var3 et var4.

le probleme avec les globales est que leur espace mémoire est réservé durant l'éxecution de TOUT ton code donc si celui-ci est un peu long et que tu a plusieurs globales, tu bouffe de la mémoire et souvent inutilement.

Citation:

---

Envoyé par le y@m's

le probleme avec les globales est que leur espace mémoire est réservé durant l'éxecution de TOUT ton code donc si celui-ci est un peu long et que tu a plusieurs globales, tu bouffe de la mémoire et souvent inutilement.

---

Ce n'est pas un malheureu int qui va te prendre toutes la mémoire, le programme avec les variables globales, c'est que tu ne sais pas dans quelle état elle sont (un peu come le chat de Schrödinger)

Citation:

---

Envoyé par fumble

et à moi, on me dit qu'il faut faire des variables globales. Alors, où est le bien et le mal dans ces deux écoles???

---

Outre la duree de vie inutilement longue des variables globales, d'autres problemes qu'elles posent sont :

* la visibilite dans tout le code : n'importe qu'elle fonction peut modifier la valeur d'une telle variable, ce qui peut coincer si une autre fonction utilise cette meme variable pour tout autre chose.
* difficulte de la maintenance : cette variable est-elle encore utile ? A qui sert elle ? Quand est elle modifiee ou lue ? etc...

Citation:

---

Envoyé par fumble

Autre interrogation:peux-tu m'éclairer sur le sens de "globales"?

---

http://emmanuel-delahaye.developpez....s.htm#globales