Tableau a double entrée ?

Résolu/Fermé
azerty572
Messages postés
1
Date d'inscription
vendredi 9 décembre 2016
Statut
Membre
Dernière intervention
9 décembre 2016
- Modifié par Chris 94 le 9/12/2016 à 21:03
mamiemando
Messages postés
31451
Date d'inscription
jeudi 12 mai 2005
Statut
Modérateur
Dernière intervention
23 septembre 2022
- 23 déc. 2016 à 11:32
Bonjour,

je souhaiterai une petite aide ou un éclairecissement.
Je vous explique mon problème :
BUT FINAL : je dois créer un programme qui permettera a une image bpm de se déplacer sur l'invite de commande d'ubuntu.

J'ai pour celà essayer déjà plusieurs manière de créer le fond, pour celà j'ai utiliser des 0. J'ai tout d'abord essayer de créer un tableau a double entrée mais je n'ai pas réussi a afficher celui-ci. J'ai donc changer de moyen pour le fond, j'ai créer le code suivant :
void main()
{
 //reboot();

 //int **fond[23][80] = {0}; //tableau fond d'écran
 int *fond = (int*) malloc(23*80*sizeof(int));
 int i = 0;
 int j = 0;

 for (i = 0; i < 80*23; i++)
 {
   if (! i%80)
   {
    printf("\n");
   }

   printf("%d", fond[i]) ;


 }

}


Celui-ci fais bien le fond que je souhaite. Le problème c'est que je ne sais pas si je peux par dessus ce printf insérer un tableau (qui correspondra à la forme de l'avion) qui prendra la place des "0".
Est-ce que celà peut marcher ? Et comment faire pour remplacer les valeurs du printf par les valeurs de mon tableau ? Suis-je obliger de générer le fond avec un autre tableau ?

Merci de vos réponses.

1 réponse

mamiemando
Messages postés
31451
Date d'inscription
jeudi 12 mai 2005
Statut
Modérateur
Dernière intervention
23 septembre 2022
7 421
Modifié par mamiemando le 23/12/2016 à 11:36
Bonjour,

Je suppose que tu voulais dire une image bmp, ou plus simplement une matrice de pixels.

Deux méthodes sont possibles :

Méthode 1 :

Tu fais un tableau de tableaux : le premier tableau aura autant de cases que ton image de lignes, et chaque tableaux contenus autant de case que tu as de colonnes.

- Inconvénient : force à faire beaucoup de malloc et (de free), ce qui ralentit le programme
- Avantage : permet d'écrire
matrix[i][j]


// Allocation
unsigned i, j, num_rows = 4, num_rows = 6;
int ** matrix = malloc(sizeof(int *) * num_rows);
for (i = 0; i < num_rows; i++) {
  matrix[i] = malloc(sizeof(int) * num_cols);
}

// Utilisation
i = 3; // 0 <= i < num_rows
j = 4; // 0 <= i < num_cols
matrix[i][j] = 42;

// Free
for (i = 0; i < num_rows; i++) {
  free(matrix[i]);
}
free(matrix);


Note que
matrix
est de type
int *
. Intuitivement
T *
peut être vu comme un tableau dont les cases sont de type
T
. En vrai c'est surtout l'adresse mémoire d'un truc supposé de type
T
. Notre premier tableau contient des tableaux (de types
int *
), il est donc lui même de type
int **
.

Méthode 2

C'est ce que tu as commencé à faire, tu travaille sur un tableau pour faire une seule allocation (et ainsi améliorer la performance). Mais ça te force à adopter une convention pour retrouver la valeur aux coordonnées (i,j). En adoptant les mêmes conventions que dans la méthode 1 :

int * matrix = malloc(sizeof(int) * num_rows * num_cols);

// Utilisation : accès à la case (i, j)
// 0 <= (i * num_cols + j) < (num_rows * num_cols)
matrix[i * num_cols + j] = 42;

free(matrix);


L'idée est de calculer un "offset" qui correspond au à la i-ème ligne. Chaque ligne contient
num_cols
élément, donc accéder au début de la i-ème ligne correspond à la case
i*num_cols
. Il ne reste plus qu'à accéder à la j-ème case de cette ligne, soit
i*num_cols + j
.

Bonne chance
0