Discussion :

[BaygonV]

Bonjour je dois utiliser un morceau de code du type :

Code :

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

1
2
3
4
5
6
 
/*...*/
#define MAX 1025
char buffer[MAX];
char* buffer_ptr;
/*...*/

J'imagine que l esprit de ces déclarations est d utiliser buffer_ptr pour pointer sur le caractere courant dans le tableau buffer pour faire un truc du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
/* ....Quelque part 'avant', dans main par exemple */
buffer_ptr = &(buffer[0]);
int AppendBuffer (const char c)
{
    *(buffer_ptr++)=c; 
 /* J ai bien conscience que je ne gere pas du tout la fin de buffer
  * C est justement autour de ca que porte ma question
  */
  return 1;
 
}

mais je ne vois pas vraiment l intérêt de procéder de la sorte par rapport à l'utilisation d'un

Code :

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

1
2
 
int buffer_index = 0;

en lieu et place du buffer_ptr et une utilisation du genre :

Code :

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

1
2
3
4
5
6
7
8
 
/* ....Quelque part 'avant', dans main par exemple */
buffer_ptr = &(buffer[0]);
int AppendBuffer (const char c)
{
    if (buffer_index < MAX) { buffer[buffer_index++]=c; return 1;}
    else {return 0;}
}

J'ai l'impression que l'utilisation de buffer_ptr ne me permet pas a elle seule de gérer un eventuel depassement de la taille du buffer et que de toutes facons, je suis obligé de définir et maintenir un buffer_index.
En plus clair (si ce n'est pas deja la cas) puis je ajouter un caractere a mon buffer en prenant en compte la taille de ce dernier et sans utiliser d'index numérique ?

J'ai la (très) désagréable impression de passer à côté d'un truc important

[gerald3d]

Je dirai que tu ne peux effectivement pas maîtriser le dépassement. Soit tu utilises un index (ce que tu proposes), soit tu fixes une valeur du dernier caractère du tableau lors de son initialisation.

À chaque inscription dans le buffer il te suffit de vérifier avant si le dit caractère n'est pas présent à l'emplacement actuel. Si oui alors tu as atteint la fin du buffer.

Ce principe est utilisé par les nombreuses fonctions type printf(); pour connaître la longueur des buffers transmis. Le caractère spécial est le "\0". Ceci sous-entend que ton tableau devra avoir la taille du texte+1 pour le caractère de fin.

[Sve@r]

Salut

L'utilisation d'un pointeur à la place d'un index n'a qu'une seule utilité: la rapidité.
En effet, dans l'écriture suivante...

Code c :

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

1
2
3
4
5
char chaine[]="Hello";
size_t i;
 
for (i=0; chaine[i] != '\0'; i++)
    printf("%c", chaine[i]);

...chaque fois que tu t'adresses à l'élément [i] (ici 2 fois), le C recalcule le déplacement de i par rapport au début de tableau. Une fois cet offset calculé, il va alors chercher le contenu de la case.

C'est pour éviter ce recalcul qu'on peut passer par un pointeur

Code c :

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

1
2
3
4
5
char chaine[]="Hello";
char *pt;
 
for (pt=chaine  /* Plus rapide que d'écrire &chaine[0] */; *pt != '\0'; pt++)
    printf("%c", *pt);

Dans cet exemple, pt est un pointeur qui s'incrémente et qui conserve, entre deux itérations, sa valeur. Il n'y a donc pas de "recalcul". Ensuite l'opération "*pt" (aller chercher le contenu de la case) reste la même que tout à l'heure.

Toutefois, à ce niveau là, le gain est minime. Parce que calculer un offset sur des char (octets) va super vite. Là où ça va vraiment jouer un rôle, ce sera avec des tableaux de structures...

Code c :

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
typedef struct {
    char nom[20 + 1];
    char prenom[20 + 1];
    unsigned short age;
} t_personne
 
t_personne tabP[]={
    {".....", "......", x},
    {".....", "......", x},
    {".....", "......", x},
    {"", "", 0},
};
 
size_t i;
t_personne *pt;
 
for (i=0; tapP[i].age != 0; i++)
    printf("Nom: %s, prénom: %s, age; %hu\n", tapP[i].nom, tabP[i].prenom, tabP[i].age);
 
for (pt=tapP; pt->age != 0; pt++)
    printf("Nom: %s, prénom: %s, age; %hu\n", pt->nom, pt->prenom, pt->age);

La première boucle prendra un temps phénoménal comparé à la seconde car déjà l'index [i] est demandé 4 fois et en plus calculer un offset sur un tableau de structures avec une taille anarchique (ici 44 octets) est super compliqué. Bon dans la réalité c'est devenu moins vrai depuis qu'il y a des optimiseurs de codes qui rajoutent des octets bidons dans la structure pour les caler sur des mots machines (ce qui accélère le calcul) mais c'est pour te montrer l'idée (et il reste quand même le fait que [i] est demandé 4 fois).
Dans la seconde boucle, magie de l'arithmétique des pointeurs, pt est toujours positionné sur le bon élément à afficher. Ne reste qu'a déréférencer les membres (avec l'opérateur flèche) mais cette opération était aussi faite dans la première boucle (avec l'opérateur point)

J'ai l'impression que l'utilisation de buffer_ptr ne me permet pas a elle seule de gérer un eventuel depassement de la taille du buffer et que de toutes facons, je suis obligé de définir et maintenir un buffer_index.

Pas forcément si tu utilises un drapeau de fin. C'est le rôle du '\0' dans une chaine de caractères et c'est ce que j'ai fait en mettant un élément supplémentaire avec age=0 dans mon tabP...

[BaygonV]

Oui j ai bien pensé a utiliser un drapeau, et en l occurence j ai bien pensé au caractere nul (les differents tutos que j ai parcourus ont l air clairs sur ce point).
Mais ca veut dire que je dois donc faire attention à ce que ce drapeau ne soit present qu'a la fin du buffer (ou da la chaine qu il est censé contenir si elle est plus petite...)
Et que donc a chaque fois que je vide le buffer je dois en quelques sorte le reinitialiser (ou l initialiser une fois au debut puis faire gaffe de virer le caractere nul qui risque d'apparaitre lorsqu il aura contenu une chaine plus petite)...
(desolé je pense tout haut)
Merci.

[gerald3d]

Ben oui. Rien n'est parfait en ce bas monde

[BaygonV]

M'en parle pas !
Au passage, et histoire de tenter de progresser plus vite, je vais tenter de donner des reponses aux questions qui me paraissent de mon niveau ici, est ce que je risque un ban si je specifie clairement que ma reponse est a prendre avec précaution (comme je l ai fait sur ce fil) ?

[Sve@r]

Mais ca veut dire que je dois donc faire attention à ce que ce drapeau ne soit present qu'a la fin du buffer (ou da la chaine qu il est censé contenir si elle est plus petite...)

C'est encore plus basique que ça: c'est la présence de ce drapeau qui symbolise la fin logique de ton ensemble...

Et que donc a chaque fois que je vide le buffer je dois en quelques sorte le reinitialiser (ou l initialiser une fois au debut puis faire gaffe de virer le caractere nul qui risque d'apparaitre lorsqu il aura contenu une chaine plus petite)...

Pas besoin de spécialement faire gaffe. Te suffit de mettre systématiquement ce flag à la fin de toute écriture sans te préoccuper des écritures précédentes. Si la nouvelle écriture prend plus de place que l'ancienne, alors le flag précédent sera automatiquement écrasé. Et si la nouvelle écriture prend moins de place alors il y aura deux flags mais seul le premier trouvé (qui sera en même temps le dernier a avoir été écrit) sera pris en compte...

M'en parle pas !
Au passage, et histoire de tenter de progresser plus vite, je vais tenter de donner des reponses aux questions qui me paraissent de mon niveau ici, est ce que je risque un ban si je specifie clairement que ma reponse est a prendre avec précaution (comme je l ai fait sur ce fil) ?

Tu ne risqueras jamais un ban pour avoir tenté d'aider quelqu'un en fonction de tes connaissances. Au pire tu risques une remarque si tu dis une connerie...

[gerald3d]

M'en parle pas !
Au passage, et histoire de tenter de progresser plus vite, je vais tenter de donner des reponses aux questions qui me paraissent de mon niveau ici, est ce que je risque un ban si je specifie clairement que ma reponse est a prendre avec précaution (comme je l ai fait sur ce fil) ?

Vouloir répondre à un post t'encourage à la rigueur. Bon maintenant tu ne tombes pas forcément juste à tous les coups (moi le premier ). Mais n'hésite pas à le faire.

[Bktero]

Au passage, et histoire de tenter de progresser plus vite, je vais tenter de donner des reponses aux questions qui me paraissent de mon niveau ici, est ce que je risque un ban si je specifie clairement que ma reponse est a prendre avec précaution (comme je l ai fait sur ce fil) ?

Tu ne risques pas de ban directement, tout simplement parce que d'abord tu passeras par la case avertissement.


Plus sérieusement, nous encourageons totalement les gens à répondre aux autres. Ca aide à progresser, ça crée de l'activité sur le forum. La seule contrainte, comme l'a dit gerald3d, c'est que ta réponse doit être constructive et surtout ne doit pas être (totalement) fausse. Cette contrainte s'applique de toute façon quelque soit l'expérience de la personne qui répond.

[BaygonV]

@Sve@r

Pas besoin de spécialement faire gaffe. Te suffit de mettre systématiquement ce flag à la fin de toute écriture sans te préoccuper des écritures précédentes. Si la nouvelle écriture prend plus de place que l'ancienne, alors le flag précédent sera automatiquement écrasé. Et si la nouvelle écriture prend moins de place alors il y aura deux flags mais seul le premier trouvé (qui sera en même temps le dernier a avoir été écrit) sera pris en compte...

Hum imaginons un buffer de 8 char efficaces donc de longeur 9 :
1 2 3 4 5 6 7 8 /0 (buffer)
j y rentre une chaine de longueur 3 :
a b c /0 5 6 7 8 /0
Mais il ne faut pas que j oublie, lorsque je rentre un caractere dans le buffer, de tester que mon pointeur ne pointe pas sur le caractere /0 auquel cas je vais signaler une erreur ou autre..
seulement en ce moment j ai un /0 dans le 4eme caractere du buffer, si je ne m occupe pas de l effacer, a la prochaine entrée des caracteres dans le buffer, la precaution sus-citée fera qu'une erreur sera declenchée si on veut rentrer un 4eme caractere non ?

[gerald3d]

Ton exemple me fait dire que l'allocation dans le tas est peut être la solution. Maintenant tu n'as peut être pas le droit ici...

[Sve@r]

Hum imaginons un buffer de 8 char efficaces donc de longeur 9 :
1 2 3 4 5 6 7 8 /0 (buffer)
j y rentre une chaine de longueur 3 :
a b c /0 5 6 7 8 /0
Mais il ne faut pas que j oublie, lorsque je rentre un caractere dans le buffer, de tester que mon pointeur ne pointe pas sur le caractere /0 auquel cas je vais signaler une erreur ou autre..
seulement en ce moment j ai un /0 dans le 4eme caractere du buffer, si je ne m occupe pas de l effacer, a la prochaine entrée des caracteres dans le buffer, la precaution sus-citée fera qu'une erreur sera declenchée si on veut rentrer un 4eme caractere non ?

Pourquoi donc ? Le fait qu'il y ait un \0 en 4° position n'est pas une erreur !!!
Toi tu cherches à utiliser ce marqueur de fin dans le sens "fin de la zone adressable ce qui permettra de détecter si on cherche à écrire au delà". Mais ça, ce n'est son rôle. Son rôle est juste d'indiquer où se termine "abc". Et c'est à toi de faire en sorte qu'il n'y ait jamais plus de 8 caractères utiles dans cette zone...

[BaygonV]

Oui tu as tout à fait raison. Mais si au moment où je "vide" mon buffer j en profite pour effacer le \0 en position 4 avant de renvoyer le pointeur sur le premier caractère de la chaîne je peux tout à fait utiliser un test du genre *ptr==0 pour justement empêcher d écrire au delà lorsque j inséré un char dans le buffer. J ai l impression de faire d une pierre deux coups.

[Sve@r]

Oui tu as tout à fait raison. Mais si au moment où je "vide" mon buffer j en profite pour effacer le \0 en position 4 avant de renvoyer le pointeur sur le premier caractère de la chaîne je peux tout à fait utiliser un test du genre *ptr==0 pour justement empêcher d écrire au delà lorsque j inséré un char dans le buffer. J ai l impression de faire d une pierre deux coups.

Moui. Mais comment feras-tu, concrètement, pour "vider" ton buffer ??? Tu es obligé de tout réinitialiser donc d'écrire 8 caractères donc de gérer le fait que tu es limité à 9 donc de mémoriser quelque part ce 9 donc de gérer toi-même le dépassement possible...

[BaygonV]

Pour vider le buffer, en admettant qu il contienne :
a b c \0 5 6 7 8 \0
alors le pointeur pointe actuellement sur le premier \0.
J envoie le buffer comme, seule la chaîne "abc" sera alors prise en compte, puis je vire le premier \0 grâce au pointeur que je renvoie sur le premier caractère du buffer.
Du coup je peux continuer à tester la présence de \0 pour détecter un dépassement de capacité.

[BaygonV]

Et oui effectivement ce comportement provoquera un sacrée bug si le pointeur se trouve sur le 9 ème caractère puisque il en effacera le drapeau.
Ce à quoi je dis que du coup ç est pas possible, ou en tout cas hors de mes capacités, de gérer le dépassement de capacité avec un pointeur seul. Il faut compter le nombre de caractères ou au moins un bool de plus. Bref. Je M incline et vais compter mes sacrés caractères. ..

[Sve@r]

Et oui effectivement ce comportement provoquera un sacrée bug si le pointeur se trouve sur le 9 ème caractère puisque il en effacera le drapeau.
Ce à quoi je dis que du coup ç est pas possible, ou en tout cas hors de mes capacités, de gérer le dépassement de capacité avec un pointeur seul. Il faut compter le nord de caractère ou au moins un bol de plus. Bref. Je M incline et vais compter mes sacrés caractères. ..

Tu verras, c'est pas trop compliqué.

Bon, ceci dit c'est faisable.
Imagine la structure suivante

Code c :

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

1
2
3
4
typedef struct {
    char *string;
    size_t len;
} t_string;

Donc tu places dans len la taille de ta zone. Puis tu implémentes des fonctions comme strcpy() ou autres qui vérifient, à chaque fois qu'elles sont appelées, si la zone à copier dépasse ou pas len.
Ainsi dans l'absolu, un truc 100% blindé c'est faisable. Mais cela n'est pas fait par défaut car il peut y avoir des cas où la vérification ne s''impose pas. Et la philosophie du C c'est "faire le minimum du minimum pour que ça soit 100% fonctionnel dans 100% des cas avec la plus grande vitesse d'exécution possible (tout en laissant au programmeur la possibilité de rajouter ses propres interfaces s'il le souhaite comme ici) sans rien vérifier car en toutes circonstances le programmeur doit savoir ce qu'il fait"...

Il y a un intervenant de ce forum qui a créé une librairie string disponible ici. Si tu t'y intéresses tu devrais trouver des trucs sympas...