Voir la version complète : [NDS][Aide] Petit aide de tableau dans fonction
Bonsoir tout le monde je me permet de me tourner vers vous car j'ai quelques problemes au niveau de la programmation avec la PALIB. Je m'explique... cela est surtout un probleme de language C. Voila je voudrait utiliser une fonction qui integre un tableau[x][y] (mais tout le tableau pas seulement une valeure precise) ... mais comment faire??? Petit exemple:
void infostructure(???)
{
s32 i,j,k;
for(i=0;i<=32;i++)
{
for(j=0;j<=16;j++)
if(terrain[i][j]!=0)
{
decor[k].x=i*32;
decor[k].y=j*32;
decor[k].type=terrain[i][j];
decor[k].sprite=k;
k++;
}
}
}
L'erreur lors de la compilation est que mon tableau terrain ne semble pas etre initialiser alors qu'il l'est dans ma fonction main (je suis a peu pres sur qu'il faut que j'utilise un pointeur... par PITIER NOOON MDR)ainsi que ma structure decor
Un autre probleme... moin important celui la, est au sujet de faire un scrolling du background a l'aide du stylet... mais pas facile lorsque l'on utilise la fonction "PA_LargeScrollXY" qui accroche en haut a gauche su sprite, et donc pas tres pratique.
D'ailleur en meme temps je voulais avoir votre avis sur ma methode de travail qui consiste en fet a recuperer les infos des decors a afficher sur un terrain a l'aide d'un tableau matriciel avec un chiffre corresponsant au decors... petit exemple:
0->terrain vide
1->route
terrain[5][5];
tableau matriciel representer:
00000
11100
00100
00100
00100
Imaginons que mes sprites de decors font 32*32 ici le terrain complet ferrait donc 160*160 pixels (32*5;32*5). Pour eviter le temps d'operation je recupere seulement les valeur des decors Visible (ici seulement la route donc 1) et je les integre dans une structure... tout en recuperant leur coordonné x et y, leur type, et meme le numero du sprite... alors c'est une bonne methode???
petit exemple de recuperation de la valeur terrain[0][1]:
Position x = 0
Position y = 32
type = 1
sprite = 1
Vous me direz pourquoi ne pas le faire directement en structure... eh bas simplement que de creer une map avec un tableau matriciel est beaucoup plus simple lisible.
Ton tableau doit etre déclaré hors de ton main, sinon les autres fonctions n'y ont pas accès
Certes, mais un pointeur c'est quand même beaucoup mieux...
Tu ne peux pas passer un pointeur à deux dimensions à une fonction (ou alors oui mais la largeur est fixe).
Merci pour toutes ses reponse mais je fais comment alors pour INTEGRER tout mon tableau dans la fonction... est ce possible oui ou non et si oui comment cela est ce possible??
et pour le stylet... quelqu'un a quelque chose a me suggerer?? se serrai vrement cool
Merci encore
Ben pour ton tableau, tu dois le déclarer avant de déclarer main, en dehors de toute fonction, et ca devrait bien passer
Pour ton stylet, j'ai pas trop compris mais je ne suis pas sur que tu utilises la fonction de Scrolling comme il faut en fait
Oui merci pour le tableau ca marche niquel je viens tout juste d'essayer. Par contre maintenant c'est ma strucure qui ne passe pas... alors je me suis dit que je n'ai qu'a la mettre en dehors de main ais petit probleme:
In function 'main':
warning: unused variable 'decor'
In function 'infostructure':
error: 'decor' undeclared
En temps normal aucun probleme mais pour faire ca:
typedef struct
{s32 x,y,type,sprite;
}chemininfo;
chemininfo decor[nbdecor];
J'ai besoin de connaitre le nombre de decor qui serra calculer par une fonction dans la fonction main.. je sais pas si je me suis bien fai comprendre...
Pour le stylet en fet je voudrait que lorsque j'appui sur l'ecran avec celui ci et que je le deplace... tout le reste bouge en fonction du deplacement du stylet... lol pas facile a expliquer. En tout cas merci pour ses reponse rapide
Je te conseille d'apprendre un peu plus profondément le C, parce que ça c'est plus ou moins la base et tu risques d'être bloqué après sinon :(
//chemininfo* => pointeur vers un chemininfo. Il peut y en avoir plusieurs à la suite (tableau)
void taFonction(chemininfo *monDecor)
{
//Variante 1 (tableau)
monDecor[0].x = ...;
//Variante 2 (immédiat, s'il n'y a qu'un élément)
monDecor->x = ...;
//Variante 3 (pointeur)
(*monDecor).x = ...;
}
//Variante 1, avec un tableau
void main()
{
chemininfo decor[nbdecor];
taFonction(decor);
}
//Variante 2, il n'y en a qu'une
void main()
{
chemininfo decor;
taFonction(&decor);
}
merci pour la reponse... en fait je connais juste les bases de la programmation je vien juste de my mettre (dailleur merci molluske g jamais ossi bien compris qu'avec ton tuto palib) et g ete horrifier par les POINTEUR. pourtant c'est dommage que je m'arrete a ca parcke j'ai tout plein d'idee de programme tres interessant pour la DS. Donc si il y a des moyen permettant de contourne les pointeurs je suis preneur lol. (meme si je sais que ca rend le programme plus lent).
En tout cas c'est vrement simpa a tous de m'aider... je test et je vous donne de mes nouvelles
Bobby Sixkilla
14/09/2006, 23h24
Le langage SMS est interdit ici. Merci de respecter les règles.
Je ne comprend pas tout l'exemple que tu ma citer... c'est pas facile de s'imaginer un pointeur, je sais que d'apres ce que j'ai pu lire on peu prendre un tableau, le referencer avec & et ensuite on peut pointer sur cette reference a l'aide de * pour s'en servir... mais je n'en voi pas trop l'utiliter qui pourrait m'eclaircir?? merci beaucoup
EDIT: je pense avoir compris ton exemple et je crois d'ailleur que ca a fait TILT :w00t: Bon je vais essayer de voir ce que ca donne. Seul petit bemole... est ce queje peux utiliser plusieurs fois chemininfo pour differente fonction sans que ca ne m'efface mes donné?
EDIT2: MERCI pour tout vrement un grand merci a tous j'ai enfin reussi a faire ce que je voulais et l'exemple de Brunni ma vrement été tres utile.:)
typedef struct
{s32 x,y,type,sprite;
}chemininfo;
void main()
{
chemininfo decor[nbdecor];
infostructure(decor);
}
void infostructure(chemininfo * mondecor)
{
s32 i,j;
s32 k=0;
for(i=0;i<=32;i++)
{
for(j=0;j<=16;j++)
if(terrain[i][j]!=0)
{
mondecor[k].x=i*32;
mondecor[k].y=j*32;
mondecor[k].type=terrain[i][j];
mondecor[k].sprite=k;
k++;
}
}
}
Et ca marche vrement niquel:cry: c'est tro beau
De rien ^^
Seul petit bemole... est ce queje peux utiliser plusieurs fois chemininfo pour differente fonction sans que ca ne m'efface mes donné?
En fait le * avec ta fonction signifie que tu passes un pointeur vers un objet (ou variable) de type 'chemininfo'. C'est à dire que tu ne passes pas l'objet lui même, mais une référence vers celui-ci.
Par exemple, si je fais ceci:
void maFonction(int x)
{
x = 2;
}
void main()
{
int y = 3;
maFonction(y);
}
Comme j'ai donné 'int x', ça veut dire que je passe directement une variable (de type int) complète. En gros, lorsque je fais 'maFonction(y)', je passe une copie de 'y' à 'maFonction'. Donc si je modifie 'x' dans 'maFonction', ça ne touchera pas le 'y' de main puisque ce sont deux variables bien distinctes.
Ca pose deux problèmes:
1) Si tu veux en fait modifier le 'y' de main depuis 'maFonction' c'est impossible puisque tu modifies une copie de celle-ci (et cette copie tombe dès que 'maFonction' est terminée). Dans certains cas c'est ce qu'on veut, mais dans d'autres ce n'est pas très pratique. Imagine si j'ai une fonction qui prend un personnage et qui s'occupe de le faire avancer, si elle ne peut même pas modifier le personnage lui-même, elle ne sert pas à grand chose.
2) Dans notre cas un int prend 4 octets, c'est pas beaucoup alors on peut bien se permettre de passer une copie. Mais ton chemininfo prend déjà 16 octets et s'il fallait passer tout le tableau, ça en ferait nbdecor * 16. Ca te prendrait une place énorme, donc c'est pas une bonne idée (et c'est pour ça qu'on ne passe jamais tout un tableau à une fonction).
Maintenant si on utilise un pointeur, on donne une référence vers une variable, et non pas la variable elle-même. Par exemple, si je modifie l'exemple ci-dessus pour lui passer une référence vers ma variable:
void maFonction(int *x)
{
*x = 2;
}
void main()
{
int y = 3;
maFonction(&y);
}
Là, le * signifie que c'est un pointeur. En gros, 'x' ne contiendra pas la valeur passée, mais l'adresse de celle-ci, c'est-à-dire en gros le numéro de bloc sur lequel elle se trouve dans la mémoire de la GBA. Ce numéro qui est en général bien bizarre, on s'en fout, il sert juste à la GBA pour pouvoir retrouver la vraie variable. C'est comme si je te donne l'adresse de quelqu'un et que tu vas aller le chercher. Dans notre cas, voilà un peu ce que tout ça donne:
main:
y: 3 (y est une variable, on l'utilise normalement)
&y: 03000800 (exemple d'adresse mémoire où se trouverait 'y')
*y: impossible, 'y' n'est pas un pointeur mais une valeur
maFonction:
x: 03000800 (adresse du 'y' de main passée en paramètre avec '&y')
&x: mauvaise idée, 'x' est déjà un pointeur
*x: 3 (valeur de 'y' de main, ce qui se trouve à l'adresse pointée par 'x')
Voilà un peu l'utilité des pointeurs, en gros ça indique où se trouve une variable pour pouvoir aller la modifier directement ^^
Après pour un tableau justement ce n'est pas une variable complète telle que 'int', car d'une part elle est trop grosse et d'une autre on ne connaît en général pas sa taille à l'avance. En fait c'est une série de variables, mises à la suite. Si je fais ceci:
int tableau[10];
En fait, tableau c'est 10 variables de type 'int' placées chacune à la suite de l'autre en mémoire. Et en fait, 'tableau' est un pointeur vers la première de ces 10 variables, et en augmentant la valeur de ce pointeur tu peux accéder à toutes les autres. Exemple si le premier élément du tableau est à 03000800:
tableau: 03000800
tableau[0]: (valeur de tableau[0], ce qui se trouve à 03000800)
&tableau[0]: 03000800
&tableau[1]: 03000804 (un 'int' prend 4 octets, la prochaine est donc 4 octets plus loin)
&tableau[2]: 03000808 (etc.)
Donc vu que tableau est un pointeur, on peut aussi faire ceci:
*tableau: (valeur de tableau[0], ce qui se trouve à 03000800)
Voilà pourquoi un tableau est de toute façon un pointeur et donc qu'il n'y a pas besoin de mettre un '&' devant ^^
Et en fait on remarque que faire 'x[0]' est équivalent à '*x' et mieux que 'x[1]' est équivalent à '*(x+1)' et que 'x' est équivalent à '&x[0]' ou '&(*x)' vu que '*' et '&' s'annulent respectivement ^^
Pour le truc en bleu, en fait il faut savoir que si x vaut 03000800, 'x+1' vaut 03000804. C'est le compilo qui multiplie toujours par 4 parce que 'x' est de type 'int *' et un 'int' fait 4 octets. Mais si 'x' avait été de type 'char*' (1 octet), là 'x+1' aurait bien valu 03000801 ;)
Bref je vais m'arrêter là, si tu n'as pas compris quelque chose tu peux toujours me demander, et si tu n'as absolument rien compris je te conseille de chercher des vrais tutos ;)
Dr.Vince
16/09/2006, 14h20
si tu veux un peu plus d'infos sur le C, les pointeurs et les tableaux, tu trouveras des tutos très bien fait à cette adresse : http://c.developpez.com/cours/
Vrement merci a tous c'est super simpa de m'aider comme vous le faite et de plus vous etes tres precis. Je regarde tout ca avec attention... merci beaucoup a tous
vBulletin® v.3.7.2, Copyright ©2000-2008, Jelsoft Enterprises Ltd. Tous droits réservés - Version française vbulletin-fr.org