super newbies en C - Page 1

Je comprends as ce qu'est un pointeur et donc à forciori je ne comprends pas à quoi ça sert.
Une bonne âme pour m'expliquer concrètement ?

Un pointeur est une variable qui ne stocke pas un contenu, mais une adresse.

Bon, déjà, il y a Thibaut qui a fait un tutorial sur les pointeurs.

Pour te donner une représentation de ce que c'est, on peut faire un parallèle entre un pointeur et un raccourci windows en quelque sorte.
Le raccourci est stocké par exemple sur ton bureau, mais il 'pointe' sur une application stockée n'importe où.
Le pointeur c'est pareil, il est stocké quelque part, et il pointe vers d'autres données.

Le raccourci contient le chemin de on application (c:WINDOWSprgram files...)
Le pointeur contient l'adresse de l'octet pointé.

On peut exécuter une application à partir du raccourci en double-cliquant dessus.
On peut lire des données à partir d'un pointeur.

oui ça c marqué dans tout les bouquins.
mais ca ne m'explique pas l'interet concret du pointeur

Ça sert à faire le genre de trucs qu'on ferait avec des indirections en BASIC.
Mais l'adresse remplace le nom de la variable (qui n'est pas connu en temps d'exécution).

c marrant les pointeurs

avec ça, tu peux faire tout ce que tu ne peux pas faire sans...




heu
j'ai dit une connerie ?

dsl, mais vous etes plutot obscur là

jacki > le lien marche pas (

personne a une copie de ce tuto ?

De toute façon, si ce qu'on t'a dit te paraît obscur, à mon avis le tuto de Thibaut le sera aussi pour toi...
Mais je n'ai pas bien compris ce que tu cherches à savoir.

ben le pointeur en général...
pas forcemment uniquement l'application en C pour ti.
apperement ca sert à transferer des variables dans des sous programmes par exemple

Ben oui, mettons que tu doives faire une fonction qui renvoie deux entiers (des coordonnées par exemple) sans utiliser de structure : comment fais-tu sans pointeurs ?

Avec des pointeurs, tu ferais quelque chose comme :

short a,b;

void MaFonction(short *a, short *b) {
 *a = ...;
 *b = ...;
 return;
}

L'appel se fait ainsi : MaFonction(&a,&b)

rien capté zdr

Peut-être qu'avec une comparaison, ça ira mieux:

En BASIC:

mafonc(a,b)
:Prgm
:...->#a
:...->#b
:EndPrgm

À appeler comme:

mafonc("var1","var2")


En C:

void mafonc(short *a, short *b) {
*a = ...;
*b = ...;
}

À appeler comme:

mafonc(&var1,&var2);

ok ça a rapport avec les variables local / pas local

Mais ce n'est qu'une des utilisations possibles des pointeurs. Mais c'est une des plus importantes.

non.

les variables sont stokées ds la mémoire à des endroits précis. et cet endroit précis a une adresse. ben un pointeur, c une variable qui contient l'adresse d'une autre variable.


pointeur = adresse variable var
ce qui donne en C :
pointeur = &var ;

contenu de var = ce qui se trouve à l'adresse stockée ds le pointeur
var = *pointeur


la déclaration c
type de variable *pointeur ; //(sachant que le pointeur lui meme est tjs constitué de 4 octets sur la plupart des machines, c à dire que c un unsigned long)
par exemple : char *pointeur ;
et pour var : char var ;

comme quoi avec un peu de perséverance on comprends tout

Imagine que la memoire est un super mega-tableau de taille 256 K.
Un pointeur c'est un indice du tableau.

Pour tout comprendre sur les pointeurs, il y a ce superbe cours : http://www.ti-fr.org/prog/index.php?do=c/tuto/pointeurs

microbug
a écrit : comme quoi avec un peu de perséverance on comprends tout

et aussi grâce à mon sens pédagogique ultra développé

erf, j'arrive trop tard, il a tout compris.
De touta façon j'arrive mal à expliquer, je me comprend tout seul, mais les autres comprennent rarement mes expliquations.

Sinon juste pour revenir sure les histoires des var locales/globales, on passe en effet l'adresse d'une var locale (déclarée dans _main par ex) à une fonction (mafonc()) par un pointeur, et du coup à partir de mafonc(), on peut tout faire tout nos opérations sur celle qui est déclaré dans _main

mais comme dit kevin, ce n'est vraiment pas l'utilisation première d'un pointeur !
Un pointeur est bien plus souvent utilisé pour referencer un tas de variables et y acceder rapidemment par arithmétique de pointeur (on passe aux adresses successives par des sommes ou des différence), voilà comment on fait dans un tableau (matrice).

Ex : l'adresse de mat[0][0] est celle contenue dans "mat" !
En fait, mat est un pointeur, pointant sur le 1er élément du tableau, dont les éléments sont tous "empilé" sur la pile (ou en RAM), donc à des adresses successives.
Par ex, pour acceder à mat[0][1], il suffit de faire *(mat + 1), on a ajouté 1, donc on est passé à l'élément suivant, et grace à l'indirection " * ", on a la valeur de cette éléments et non l'adresse.
Enfin moi je m'en sers surtout pour ça.

PS : corriger moi en cas d'erreur, j'ai écris ça vite fait, j'ai pas le temps de tout vérifier.