pointeurs et tableaux - Page 1

Slt! J'ai un probleme, j'ai declare un tableau: short n1[20][11]
je cree un pointeur: pointeur = (int *)n1;
Ensuite j'ai: if(n1[x][y]== 7)
mais j aimerais l utilise avec le pointeur...Commment je fais?
Help me

Déjà, tu dois déclarer ton pointeur n1 en short *, pas en int *, c'est plus propre (et tu pourras aussi suprimmer le transtypage en (int *) devant n1).
Et puis pour utiliser ton tableau à deux dimentions avec un pointeur, il faut utiliser soit l'arithmétique des pointeurs : n1[5][4] <=> *(n1+5*11+4)
Soit tu déclares ton pointeur comme un pointeur sur un tableau : short (*n1)[11];
Et tu accèdes aux éléments comme avec un tableau à deux dimentions classique.

Merci bcp:ca marche!
Mais pourquoi qd j'utilise ta premiere methode, il y a ecrit: "assignment from incompatible pointer type"?
c grave?

Parce qu'en fait il faudrait mettre (char *)n1 quand tu appelles ta fonction qui prend en argument ton tableau (avec la première méthode).

Je ne comprend pas comment short (*n1)[11]; peut marcher.
Pour moi, dans ce cas, n1 est un pointeur sur un tableau, et n1[y][x] lit l'adresse du tableau à n1+y puis saute vers cette adresse pour accéder au x^ième élément
Ce qui se traduirait par un plantage très probable (adress error)

Non car n1[y] ne pointe pas vers un pointeur mais vers le premier élément du tableau contenant les [x]. C'est un tableau tout bête, pas une liste chaînée.

o fait au passage...Dans certaines sources, j'ai vu: i<<5 et ds la doc de tigcc c pas trop comprehensible(anglais)...qq'un pourrait m'expliquer?

ça effectue un décalage de i de 5 bits vers la gauche... autrement dit ça multiplie i par 2^5.

c'est un décalage binaire à gauche de 5.
par exemple, si i contient la valeur 0b00001111 au départ, apres un << 5, i deviendra 0b11100000.
En pratique, cela revient a faire une multiplication de i par 2^5 (soit 32), sauf que c'est plus rapide que de faire i *32 (meme si tigcc l'optimise tout seul)

oups.. posts croisés

soit 32

et encore un

Ça signifie "décalage vers la gauche". Par exemple, prends 5 : en binaire ça s'ecrit 00000101, si tu fais 3 décalages vers la gauche, ça donne 00101000 (soit 40)
En règle générale, faire N décalage vers la gauche revient à multiplier le nombre par BASE^N (BASE étant le nombre de chiffres consituant la base, 10 pour la base décimale, 8 pour l'octale, ...)
Dans notre cas, on a bien 5<<3 = 5*2^3 = 5*8 = 40
En fait, utiliser les décalages de bits à la place d'une mutliplication permet de gagner beaucoup en vitesse.

Houlà, vous avez eu le temps d'écrire 5 posts avant que je ne finisse le mien !
C'est parce que j'ouvre tous les topics, puis je réponds un par un (et je ne tape pas très vite non plus).

lol et un de plus... jamais deux sans trois

et après on dit que les newbies sont maltraités

zybow a écrit :
Merci bcp:ca marche! Mais pourquoi qd j'utilise ta premiere methode, il y a ecrit: "assignment from incompatible pointer type"?

Parce que tu assignes un short (*)[11] à un short *.

c grave?

Non.

Thibaut a écrit :
Je ne comprend pas comment short (*n1)[11]; peut marcher.
Pour moi, dans ce cas, n1 est un pointeur sur un tableau, et n1[y][x] lit l'adresse du tableau à n1+y puis saute vers cette adresse pour accéder au x^ième élément

Non, ce n'est pas un pointeur vers un pointeur vers un tableau, juste un pointeur vers un tableau.
short (*n)[m]; n'est pas la même chose que short **n. C'est aussi pour ça qu'il faut préciser m. C'est d'ailleurs dans la FAQ: http://tigcc.ticalc.org/doc/faq.html#37.

> ce n'est pas un pointeur vers un pointeur vers un tableau, juste un pointeur vers un tableau.

OK j'avais mal interprété Mais avec la nouvelle interprétation je ne comprend toujours pas
n1[y] : on accède au y^ième élément du tableau. OK. Mais n1[y][x] fonctionne alors que n1 a été déclaré comme pointant un tableau à UNE dimension

en mémoire une ou deux dimensions, qu'importe?

short n1[9] = {0,0,0,0,0,0,0,0,0};
short n1[3][3] = {{0,0,0},{0,0,0},{0,0,0}};

même représentation en mémoire
d'ailleurs tu dois pouvoir faire

short n1[3][3] = {0,0,0,0,0,0,0,0,0};

Tout ça je le sais
Mais apparament GCC accepte l'utilisation en 2D d'un tableau 1D. C'est ça que je ne savais pas.

C'est parce que c'est ce que le standard C prévoit.
On a souvent l'habitude de simplifier les rapports entre tableaux et pointeurs pour les débutants, et les explications simplifiées ne sont plus correctes devant un short (*n1)[11]. Un tableau n'est pas un pointeur (même s'ils sont souvent utilisables de manière interchangeable), il est juste converti vers un pointeur ou vice-versa quand c'est nécessaire. Ici, la conversion n'est pas nécessaire, donc short (*n1)[11] est différent de short **n1.

Est ce que vous pourriez m'éclairer: j'ai lu des docs sur les poiteur et je pige pas:
à quoi ca sert d'utiliser des pointeurs quand on a accès a des variables automatiques.
je vois pas l'interet de faire:
short a,b:
short *p1, *p2;
a=10;b=0;
p1=&a;p2=&b;
*p2=*p1
Alors qu'on peut faire:
b=a;
Peut-être j'ai omi qlq chose (j'imagine sinon ca serai inutile)!

Quand tu passe un parametre a une fonction:celle ci est passee par valeur.
Si tu veux directement modifier tes varaibles,tu est oblige de passer une pointeur sur ces variables.
(Tout ce qui a ete cree dans une fonction,ou un bloc,disparait en meme temps que lui)
Si par contre ca ne concerne qu'une seule variable,une simple affectation du resultat suffit.

En gros ce que tu m'as dis c'est que je peux modifier la valeur d'une variable qui se trouve dans une fonction par le moyen d'un pointeur, mais qu'une fois la fonction est terminée la modif s'annule?#confu#
J'ai bon?

Non.
Justement, si tu la modifies à travers un pointeur, la modification n'est pas annulée. C'est si tu la modifies directement qu'elle s'annule.

ah! les pointeurs compliqués du C/C++!!!

Dis voir toi... Je trouve de tes posts un peu partout sur le forum, et à 99% c'est des posts de merde. Tu m'explique à quoi ça sert une remarque comme celle que tu viens de faire ?

la fonction type utilisant des pointeurs et incapable de marchée sans:

void echange(int *pt_a,int *pt_b)
{
int temp;
temp=*pt_a;
*pt_a=*pt_b;
*pt_b=temp;
}


echange(&a,&b);[3]//Pour permuter a et b[/3]

Et les gars,en parlant de tableaux,que pensez vous de l'idee suivante pour se debarrasser de cette fichue programmation recursive:

(x1 x2 x3 ... )
|2 3 10 ... | valeurs des chiffres ci de depart
|3 5 18 ... | valeurs actuelles des ci
|7 9 22 ... | valeurs finales des ci

Ce tableau etant alloue dynamiquementour chaque chiffre supplementaire o, rajoute une colone,et on plus besoin que la fonction se rappellle elle meme!

(Je n'ai pas encore teste ce procede,mais ca ne saurait tarder)

La programmation récursive est parfois indispensable pour coder, sinon il faudrait se prendre la tête à gérer des piles de données et d'adresses de retour... aucun intérêt si la programmation récursivre évite tout ça pour un code à peine plus lent !
Tiens, la dernière question du questionnaire de sélection de Prologin :

On vous donne un tableau de 100 nombres entiers entre 0 et 100. Ecrire une fonction qui détermine s'il est possible de séparer ces nombres en deux groupes, de telle sorte que la somme des nombres de chacun des deux groupes soit égale. La fonction doit retourner vrai (ou 1) si c'est possible, faux (ou 0) sinon.

Essaie de coder la solution sans récursivité