Discussion :

[contremaitre]

Bonjour

Je dois acquerir des données, et supprimer les plus vieilles pour les remplacer par les plus récentes, en gardant les n dernieres données en mémoire.

J'ai bien une idée mais je voulais savoir si c'est correct.

soit des données en int, voilà comment je ferait :

initialisation

Code :

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

1
2
3
4
5
6
 
//soit TAILLE la taille d'un jeu de donnée.
//soit N le nombre de buffers à garder en mémoire
int ** buffer;
buffer = (int *)malloc(N*sizeof(int*));
//ici une boucle pour chaque buffer[i] on fait un malloc de taille sizeof(int)*TAILLE

ensuite a chaque fois qu'on enregistre de nouvelles données :
on décale les pointeurs des données.
Sachant que dans buffer[n-1] on a les données les plus récentes et dans buffer[0] les plus vieilles.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 
//on fait pointer le dernier element vers l'adresse des données les plus vieilles
buffer[N-1] = buffer[0];
//decalage des données
for(i =  0 ; i < N-1 ; i++) {
   buffer[i] = buffer[i+1];
}
 
//on fait l'acquisition des nouvelles données dans le dernier élement
acquerir_donnees(buffer[N-1]);

Est ce que c'est une bonne solution?
merci

[diogene]

Est ce que c'est une bonne solution?

Si le décalage des données ne pénalise pas trop le temps d'exécution. Sinon, pour éviter de déplacer le tableau, tu peux lui donner la forme logique d'un anneau de stockage en mémorisant l'indice de la première place libre dans le tableau et celui de la première place occupée. Les indices sont pris modulo la taille du tableau.

En partant d'une structure :

Code :

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

1
2
3
4
5
6
7
8
9
typedef struct
{
   TType** buffer;
   int  libre;  // indice de la première position disponible
   int  ancien; // indice de la première position occupée
   int vide;    // indicateur pour exprimer que le tableau est vide
   int dim ;    // dimension du tableau
   int taille;  // dimension d'une ligne du tableau ( si peut être utile)
}TBuffer;

Ecrire les fonctions CreerBuffer et DetruireBuffer

Code :

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

1
2
TBuffer  * CreerBuffer( int dim, int taille) ;
void DetruireBuffer( TBuffer * buffer) ;

Une fonction de test de tableau plein

Code :

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

1
2
3
4
int EstPlein(TBuffer * buff)
{
  return buff->libre== buff->ancien && !buff->vide;
}

Alors, les fonctions d'ajout ou de retrait sont assez simples. Par exemple

Code :

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

1
2
3
4
5
6
7
8
TType * RetirerDonnee(TBuffer * buff)
{
  int nancien = buff->ancien;
  if(buff->vide) return NULL;
  buff->ancien = (buff->ancien+1) % buff->dim;
  buff->vide = buff->ancien == buff->libre;
  return buff->buffer[nancien];
}

[contremaitre]

Merci pour cette réponse et cette idée.
Quand à :

Si le décalage des données ne pénalise pas trop le temps d'exécution.

En fait mes données sont dans le int **
Et je ne décale que les pointeurs (les int*) donc c'est pas un décalage de données mais de pointeurs. Et c'est ca qui me faisait un peu peur, de savoir si ca peut se faire de cette maniere?

[Emmanuel Delahaye]

Je dois acquerir des données, et supprimer les plus vieilles pour les remplacer par les plus récentes, en gardant les n dernieres données en mémoire.

Ce que tu veux faire s'appelle une FIFO. Il est un principe absolu en programmation : on ne déplace pas les données.

une FIFO est une structure de données élémentaire qui se construit avec

• une zone de stockage (taille fixe ou taille variable)
• un index (ou pointeur) d'écriture
• un index (ou pointeur) de lecture
• un indicateur 'vide'
• un indicateur 'plein'

Il est recommandé d'utiliser des fonctions

• initialisation()
• ecriture()
• lecture()
• test_vide()
• test_plein()

plus, éventuellement :

• creation()
• destruction()

si on est dans un contexte dynamique.

On peut aussi utiliser une liste chainée. Ce n'est pas forcément plus simple.

[contremaitre]

Ce que tu veux faire s'appelle une FIFO. Il est un principe absolu en programmation : on ne déplace pas les données.

Je suis d'accord avec cette solution mais je tiens à preciser, comme je l'ai dis dans mon message précédent, que ma solution ne déplacait pas les données.
Seulement les pointeurs vers mes données.

[Emmanuel Delahaye]

Je suis d'accord avec cette solution mais je tiens à preciser, comme je l'ai dis dans mon message précédent, que ma solution ne déplacait pas les données.

Et ça ?

Code :

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

1
2
3
4
5
6
 
buffer[N-1] = buffer[0];
//decalage des données
for(i =  0 ; i < N-1 ; i++) {
   buffer[i] = buffer[i+1];
}

[contremaitre]

Et ça ?

Code :

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

1
2
3
4
5
6
 
buffer[N-1] = buffer[0];
//decalage des données
for(i =  0 ; i < N-1 ; i++) {
   buffer[i] = buffer[i+1];
}

sachant que buffer est de type int** je déplace seulement les pointeurs, qui eux meme pointent vers les données.

[Emmanuel Delahaye]

sachant que buffer est de type int** je déplace seulement les pointeurs, qui eux meme pointent vers les données.

Ce n'est pas une bonne idée. Ca peut aller pour un petit tableau (< 20 éléments), mais ce n'est pas une solution universelle. Il vaut beaucoup mieux manipuler des index ou des pointeurs comme déjà indiqué.

[contremaitre]

merci