Gestion de matrice

Comment effectuer un "décalage" rapide de tableau (ex: Tab[11000][600]) vers la gauche, c'est à dire :
- supprimerla première colonne,
- décaler les 99 colones qui suivent,
- insérer une colonne à la fin?

Merci!

Bonjour,

La solution la plus simple qui me vient à l'esprit est la suivante :

D'abord créer le tableau dans le tas et non dans la pile :

Code:

---

1 2 3 4

int bp=0; //utilité expliquée plus loin type *tab; tab = (type*) malloc( taille_x*taille_y*sizeof(type) );

---

Pour accéder au tableau aux coordonnées (x, y) toujours utiliser cette formule :

Code:

---

1 2	tab[ ( (x+bp)%taille_x ) * taille_y + y ];

---

Ensuite pour décaler le tableau il suffit simplement de faire :

Code:

---

1 2 3

memset( tab+bp*taille_x, taille_x, 0); bp=(++bp)%taille_x;

---

Ne pas oublier de détruire le tableau à la fin

Cette solution nécéssite une variable un peu gênante mais sans elle tout est plus compliqué :o)

D'autres exemple sur en lisant les cours et tutoriels pour la programmation C : http://c.developpez.com/cours/

Bonjour!

Merci pour ta réponse!
Je vais tester lundi et essayer de comprendre ton code (je maitrise encore mal les notions de tas et de pile...)

Pourrais-tu tout de même vérifier (je ne suis pas certains d'avoir été très précis dans ma question...) que ton code effectue bien une sorte de "srolling"?
Je ne comprends pas bien, en effet, ce que devient la colonne "de droite" après memset...

CE QUE TU PROPOSES:
int bp=0; //utilité expliquée plus loin
type *tab;
tab = (type*) malloc( taille_x*taille_y*sizeof(type) );

memset( tab+bp*taille_x, taille_x, 0);
bp=(++bp)%taille_x;


CE QUE JE FAISAIS:
// 1 Je décale le tableau à gauche d'1 cran
for (x=0; x<(taille_x - 1); x++)
{
for (y=0; y<taille_y; y++)
{
tab[y][x] = tab[y][x+1];
}
}

// 2 Je remplis la colonne de droite
for (y=0; y<taille_y; y++)
{
tab[y][taille_x] = data...;
}

Pour réaliser un authentique décalage (sur la dimension de droite) sur un véritable tableau:

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

#include <string.h> //memmove et pas memcpy, car chevauchement.   const int nlig= 11000 ; const int ncol= 600 ; int Tab [nlig][ncol]= {0} ;//rempli à 0 int Tab2[ncol][nlig]= {0} ;//rempli à 0   int main(){ int lig, col ; int shiftw= 100;   //décalage "à la main" for(lig=0 ; lig<nlig ; ++lig){ for(col=0 ; col<shiftw-1 ; ++col) Tab[lig][col]= Tab[lig][col+1] ;//décalage à gauche Tab[lig][shiftw-1]= 0 ;//introduction de 0 à droite }   //décalage optimisé memmove for(lig=0 ; lig<nlig ; ++lig){ memmove(&Tab[lig][0], &Tab[lig][1], (shiftw-1)*sizeof(int)) ;//décalage à gauche Tab[lig][shiftw-1]= 0 ;//introduction de 0 à droite }   //décalage optimisé memmove+pointeurs int (*plig)[ncol] ; for(plig= &Tab[0] ; plig<&Tab[nlig] ; ++plig){ memmove(&plig[0][0], &plig[0][1], (shiftw-1)*sizeof(int)) ;//décalage à gauche Tab[lig][shiftw-1]= 0 ;//introduction de 0 à droite }   return 0; }

---

Un seul décalage conviendrait si toute le largeur du tableau était décalée.
Un tableau par indirections serait plus lent d'accès, mais les permutations de lignes entières seraient très rapides.
Le mieux, c'est bien de ne pas avoir à bouger un tableau. Tu ne peux pas t'en sortir avec des indices contraints ?

Dis-moi si tu en veux plus !

Merci à tous les deux!

Vous m'avez donné un bon coup de main (le décalage est maintenant beaucoup plus rapide qu'avec mes boucles!): je vais approfondir memset, memmove et cie, auquels je ne pensais pas du tout...

A+