Bonjour tous

Alors voilà, je suis en train d´apprendre le langage C et j´ai donc inévitablement vu le chapitre des pointeurs.

Ce qui est bien, c´est que j´ai compris le principe, soulagement donc. J´ai compris qu´on pouvait faire un pointeur sur une variable en le déclarant comme cecic (par exemple):
long Variable = 1;
long *Pointeur = NULL;
Pointeur = &Variable;
Donc maintenant la valeur de *Pointeur est 1.

J´ai compris aussi qu´on pouvait pointer sur une sous-variable d´une structure comme ceci:

struct Structure
{
long Sousvariable1 = 1;
long Sousvariable2 = 2;
};

int main(truc-bidules habituels)
{
long *Pointeur = NULL;
struct Structure Variable;
Pointeur = &Variable;
}

Ici (*Pointeur).Sousvariable vaut 1.

Maintenant j´aimerais savoir comment faire pour trouver une valeur dans un tableau en utilisant un pointeur?

Par exemple soit un tableau:
long Tableau[100] = {45,6,78,132 ... 85};

Soit un pointeur:
long *Pointeur = NULL;

Si l´on fait:
Pointeur = &Tableau;
Ca aurait été trop facile de faire *Pointeur[2] pour trouver 78 par exemple.

Mais alors comment faire?

J´attends votre aide avec impatience

Perso, ce que je fais, dans ce cas la, c´est faire :

Pointeur = &tableau[0];

--> je me mets sur le premier élément du tableau
ensuite, si tu veux l´élément i, tu fais
- soit :

• (Pointeur+i);

- soit :
Pointeur[i];
comme un tableau : car pointeur et tableau sont bien similaires en fait
tu peux meme faire :
Pointeur = tableau;
ce qui revient au meme que
Pointeur = &tableau[0];
(meme si moi je prefere utiliser la forme avec le & et les [] )

Ah ouais pas bête!

Ca implique juste la création d´un type int pour le i :s

Enfin tant pis, merci beaucoup pour la réponse

pour bien confirmer que c´est pareil, tu remarqueras les egalité suivante:
toto[4] == *(toto+4) == *(4+toto) == 4[toto]

sisi, je vous assure!

Ah bin c´est mieux ça!

Mais juste une question, pourquoi alors ça ne marcherait pas avec *toto[4]?

si toto est un pointeur sur variable, alors *toto renvoit la valeur de variable, si variable est un tableau, alors *toto[4] serait la cinquième valeur, et tout le monde serait content!

toto est un pointeur mais toto[0] est une variable. Donc *toto==toto[0] et toto=&toto[0]

Oui mais dans ce cas, pourquoi *toto[2] ne renverrait-il pas la troisième valeur de tableau[]? Je veux dire... pourquoi les créateurs de C n´ont-ils pas pensé à simplifier ça?

ce n´est pas un problème de simplifier ou pas. Ce qu´il y a là est très logique :

toto est un pointeur donc tu peut regarder toto[2] qui te donne la troisième valeur du tableau toto, ou alors *toto qui te donne la valeur pointé par toto (ou lapremière valeur du tableau si c´est un tableau).

Mais si tu fait *toto[2] qui est équivalent à *(toto[2]) alors tu veux regarder la variable pointé par le pointeur toto[2], il faut donc que toto[2] soit un pointeur et donc que toto soit un tableau de pointeur et pas juste un tableau donc un pointeurs vers des pointeurs.

C´est tout à fait possible d´écrire *toto[2], mais ça n´a pas le sens que tu attend.

Le C est un langage puissant et non pas un langage simplifié. Pour pouvoir écrire toutes sorte de chose il faut une syntaxe rigoureuse (ou chaque opérateur à un sens précis), si toto[2] veut dire quelque chose, *toto[2] ne peut pas être la même chose.

Ah oui ok!

J´ai souvent tendance à oublier qu´un pointeur a une cible unique...

Enfin bon ça rentre, merci beaucoup pour les réponses^^