[C/C++]Tableaux static

8 mars 2006 à 20:06:37

Une peite question : peut on convertire un int[][N] en int** ?
Ou de fasson plus général, peut - on convertire un tableau static en pointeurs?

bluestorm

8 mars 2006 à 20:43:22

bah oui, tu castes (ou pas), et paf ça fait des chocapics.
Ceci dit, c'est pas vraiment une "conversion", plus une 'dégradation' si j'ai bien compris.

EnMieu

8 mars 2006 à 21:01:41

Donc : int Tab[5][8] = 0;
Et ensuite : (int**)Tab ?
Je demande parce que je n'ai jamais utiliser de tableau multidimension static

bluestorm

8 mars 2006 à 21:12:31

Bah teste, je pense que le cast est même pas nécessaire.
(et ce serait = {0})

rz0

9 mars 2006 à 7:05:02

Tu peux mais ça ne donnera rien de bon, les tableaux ne sont pas dans pointeurs ; il n'y a jamais que la première dimension qui est implicitement convertie en pointeur, les autres restent des tableaux.

bluestorm

9 mars 2006 à 17:15:07

Oui, en fait c'est plutôt (int *) tab.

EnMieu

9 mars 2006 à 20:21:08

Mais il n'est plus possible dnas ce cas de faire une fonction de tableau de dimension deux qui fonctione avec tout tableau de dimension deux...

bluestorm

9 mars 2006 à 23:04:22

Bah il faut donner la taille en argument de la fonction, et ça marche.
De toute façon t'es bien obligé de donner la taille, non ?

-ed-

10 mars 2006 à 11:01:37

Citation : EnMieu

Une peite question : peut on convertire un int[][N] en int** ?
Ou de fasson plus général, peut - on convertire un tableau static en pointeurs?

Beaucoup de confusions...

Un tableau est un objet composé d'élements identiques consécutifs.
Le nom d'un tableau a le type et l'adresse du premier élément du tableau.
Il est possible de définir un pointeur de ce type et de l'initialiser avec le nom du tableau

Exemples

int a[10];
int *p = a;

Grace aux propriétés de l'arithmétique des pointeurs, p + i et &a[i] désignent le même objet. Donc *(p + i) et a[i] ont la même valeur. de plus, la C autorise l'utilisation de la notation indexée ([i]) avec les pointeurs typés, ce qui fait que *(p + i) peut s'écrire p[i]

On peut donc utiliser indifférement a[i] ou p[i].

Mais celà ne signifie pas que l'on puisse affirmer qu'un tableau soit un pointeur.

En effet, on ne peut modifier le nom d'un tableau : a = p n'a aucun sens. De même l'opérateur sizeof ne se comporte évidemment pas du tout de la même façon avec un tableau ou avec un pointeur (je laisse le soin au lecteur de faire les essais ...)

Si le tableau a 2 dimensions, par exemple :

int a[2][3];

le type de a est 'adresse du premier element, soit int (*)[3] et non int** comme on le lit parfois.

On a donc le droit de créer un pointeur de ce type et de l'initialiser avec le nom du tableau :

int a[2][3];
int (*p)[3] = a;

On utilise ensuite indifférement a[i][j] ou p[i][j].

#include <stdio.h>

int main (void)
{
int a[2][3];
int (*p)[3] = a;

p[1][1] = 123;

printf ("%d\n"‚ a[1][1]);

return 0;
}

Music only !

EnMieu

12 mars 2006 à 19:36:50

Citation : -ed-

Beaucoup de confusions...

Un tableau est un objet composé d'élements identiques consécutifs.

Le nom d'un tableau a le type et l'adresse du premier élément du tableau.

Il est possible de définir un pointeur de ce type et de l'initialiser avec le nom du tableau

Ces trois points je els conais, depuis un momemnt.
Je cherche a obtenir un int ** pour pouvoir utiliser une fonction qui prend (int** p, int Sdim1, int Sdim2). Et oui, un int[3][8] est diférent d'un int [3][9], alors que int[4][8] est lui du même type.

-ed-

12 mars 2006 à 19:57:28

Citation : EnMieu

Citation : -ed-

Beaucoup de confusions...

Un tableau est un objet composé d'élements identiques consécutifs.

Le nom d'un tableau a le type et l'adresse du premier élément du tableau.

Il est possible de définir un pointeur de ce type et de l'initialiser avec le nom du tableau

Ces trois points je els conais, depuis un momemnt.
Je cherche a obtenir un int ** pour pouvoir utiliser une fonction qui prend (int** p, int Sdim1, int Sdim2). Et oui, un int[3][8] est diférent d'un int [3][9], alors que int[4][8] est lui du même type.

Je ne connais pas de langage 'C/C++'. Je ne parle donc que pour le C.

Si j'ai bien compris, tu veux un tableau dynamique de type T à deux dimensions (x, y, par exemple).

Pour ça, il faut créer un tableau dynamique de y pointeurs :

T **pp = malloc (sizeof *pp * y);

Et ensuite créer y tableaux de x T dont les adresses seront fangées dans le tableau de pointers crée précédemment :

size_t i;
for (i = 0; i < y; i++)
{
pp[i] = malloc (sizeof *pp[i] * x);
}

Evidemment, on a vérifié astucieusement que les allocations se sont faites correctement. Ensuite, on peut utiliser ce tableau dynamique de la façon suivante :

/* initialisation */

void init (T** pp‚ size_t x‚ size_t y)
{
size_t i;
for (i = 0; i < y; i++)
{
size_t j;
for (j = 0; j < x; j++)
{
pp[i][j] = 0;
}
}
}

Les données pp, x et y étant indissociables, une structure s'impose naturellement

struct tab2d_T
{
T** pp;
size_t x;
size_t y;
};

La fonction d'init devient :

/* initialisation */

void init (struct tab2d_T *this)
{
size_t i;
for (i = 0; i < this–>y; i++)
{
size_t j;
for (j = 0; j < this–>x; j++)
{
this–>pp[i][j] = 0;
}
}
}

Music only !

EnMieu

14 mars 2006 à 20:14:47

En fait, la création de tableau dynamique à n dimension ne me pose pas de problème(mais bon je ne me suis pas esseiller à des tableaux où n = 28635 :D)
Le problème, c'est le traitement d'un tableau static(dans un header, un tableau contien une image, il est construit de fasson static).
Moi, je voudrais créer une fonction qui blit l'image sur l'écran de la GBA, donc qui puisse prendre un pointeur et la limite des dimensions x&y. Il faudrais donc que je pratique cette convertion. Où alors que ej trouve une autre métode(c'est domage, je trouvais l'idée du header d'image plutot sympatique, et simple à utiliser...)

bluestorm

14 mars 2006 à 22:43:43

Bah avec {...} non ?

int croix[3][3] = {
{0‚ 1‚ 0}‚
{1‚ 1‚ 1}‚
{0‚ 1‚ 0}
};

EnMieu

15 mars 2006 à 14:07:53

Je doit vraiment male m'exprimer : J'ai un header avec un tableau static de dimension variable, et je veut pouvoir l'utiliser avec 1 fonction, qui vas l'aficher sur l'écran...
Je ne demande pas comment le créer -_-

Quand à créer un tableau dynamique, c'est inpenssable, car il faudrais une fonction.

-ed-

15 mars 2006 à 14:14:23

Citation : EnMieu

Je doit vraiment male m'exprimer : J'ai un header avec un tableau static de dimension variable, et je veut pouvoir l'utiliser avec 1 fonction, qui vas l'aficher sur l'écran...
Je ne demande pas comment le créer -_-

Quand à créer un tableau dynamique, c'est inpenssable, car il faudrais une fonction.

Pour un tableau, statique et variable ne vont pas ensemble. Il y a un problème de conception.

Music only !

EnMieu

17 mars 2006 à 17:59:31

Donc, comment je fait pour obtenir de mon image un tableau pouvait être utiliser par une fonction ui prend un int** ? Ou alors je prend autre chose u'un tableau... mais uoi?!(Quand au tableau à 1 dimension et où on emploi les offsets, sa ne me facilite pas la tache)

-ed-

17 mars 2006 à 20:41:27

Citation : EnMieu

Donc, comment je fait pour obtenir de mon image un tableau pouvait être utiliser par une fonction ui prend un int** ? Ou alors je prend autre chose u'un tableau... mais uoi?!(Quand au tableau à 1 dimension et où on emploi les offsets, sa ne me facilite pas la tache)

Je ne sais pas ce que tu entends par image. En tout cas, on sait faire ceci :

(pseudo-code)

int main (void)
{
size_t const X = 12;
size_t const Y = 34;

T ** pp = create_tab(X, Y, params...);

use_tab (pp, X, Y);

delete_tab(pp, X, Y);

return 0;
}

en écrivant les fonctions qui vont bien...

On peut aussi regrouper les donnéees utiles dans une structure :

struct T2
{
size_t X;
size_t Y;
T ** pp;
};

int main (void)
{
struct T2 t2;

init_tab(&t2, X, Y, params...);

use_tab (&t2);

end_tab(&t2);

return 0;
}

on peut aussi faire une version 100% dynamique... Bref, on a l'embarras du choix...

Il n'y a plus qu'à écrire les fonctions qui vont bien...

Music only !

EnMieu

20 mars 2006 à 17:46:04

Image = Pixels
J'entend la le sens propre du mot, j'ai bien une image qui est converti en un tableau statique.