Discussion :

[fumble]

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

[Emmanuel Delahaye]

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.

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.

[le y@m's]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[fumble]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

  }while(caractere!=13);

Ici 13 représente la touche "ENTREE"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

 system("pause");

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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]

[fumble]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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]

[gege2061]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Tu vient de recoder getchar() qui lui est standard

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

caractere!=13

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Ce n'est pas du C++.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

malloc peut echouer.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[gege2061]

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

[Emmanuel Delahaye]

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

[le y@m's]

Merci pour vos remarques,
pourquoi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

caractere!=13

n'est pas portable?

fumble >>

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 )
http://emmanuel-delahaye.developpez....es.htm#realloc (merci Emmanuel )

[le y@m's]

gege2061 a écrit:

Tu vient de recoder getchar() qui lui est standard

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[gege2061]

Merci pour vos remarques,
pourquoi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

caractere!=13

n'est pas portable?

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

gege2061 a écrit:

Tu vient de recoder getchar() qui lui est standard

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Bien vue

[fumble]

voici mon algo :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Emmanuel Delahaye]

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

Numérotage inutile.

<...>

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[fumble]

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

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.

bien cordialement,
fumble

[Trap D]

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

/* 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
/* --------------------------------------------------------------- */
/* declaration des protoypes
int read(void);
int write(void);

Attention à la fonction write :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[fumble]

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

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

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:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[le y@m's]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[gege2061]

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)

[gl]

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

[Emmanuel Delahaye]

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

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