On va donc reprendre...
Quand tu fais un code du genre
ton compilateur prévois de la place pour mettre 100 valeurs de type float statiquement.
C'est statique, c'est à dire que tu ne peux pas décider de redimentionner ton tableau (pour, par exemple, pouvoir mettre 200 valeurs)
Bien sur, tu peux décider d'écrire un code du genre de
mais, si tu l'a prévu pour 100 valeurs, il la valeur se trouvera...en dehors de l'espace alloué à ton tableau, ce qui provoquera un comportement aléatoire, vu qu'on ne peut pas savoir ce qui se trouvera à cet endroit précis de la mémoire.
Donc, la solution quand tu veux pouvoir bénéficier d'un tableau dont tu ne connais pas la taille au départ, c'est de faire une "allocation dynamique".
Le résultat de l'allocation dynamique doit etre envoyé, non pas sur une variable, mais sur quelque chose qui est en mesure de prendre comme valeur une adresse mémoire.
Ce quelque chose s'appelle un pointeur.
Tu peux faire exactement les meme opérations arithmétique sur les pointeurs que sur une variable de type float, mais, il faut savoir que, si tu ne dis pas d'e travailler sur "l'élément pointé par" ton pointeur, tu modifiera en fait l'adresse mémoire sur laquelle il garde un oeil, avec tout les problèmes que cela peut comporter, à savoir qu'il ira "chatouiller" des adresses mémoires qui servent sans doute à autre chose.
un peu de code pour la compréhension
1
2
3
4
|
int mavar=10; //mavar est un entier, il est déclaré et on lui donne directement la valeur 10
int *ptr=NULL;//on déclare un pointeur de type entier, et, pour éviter les problème, on le fait pointer sur une adresse "safe"
ptr=&mavar;//on assigne l'adresse à laquelle se trouve mavar à ptr |
tu dispose toujours de ton entier, grace à mavar tu peux donc écrire
qui fera que mavar vaudra 25 maintenant
mais tu peux aussi utiliser le pointeur, pour cela il faut lui dire d'utiliser "ce qui est pointé" par l'adresse mémoire qu'il connait sous la forme de
ce qui fera que mavar (qui valait 25) vaut maintenant 2
Mais, ptr est également tout à fait indépendant de mavar...Simplement, il se fait qu'à un moment précis, l'adresse qu'il contient est celle de mavar.
Si tu écris un code
ca aura pour effet que ptr contiendra l'adresse mémoire... qui est juste apres celle ou se trouve la valeur de mavar (et dont on ne sait à priori pas ce qu'elle contient)
Maintenant que nous avons une idée un peu claire de ce qu'est un pointeur, on peut voir comment lui faire allouer de la mémoire dynamiquement.
Si tu écris un code
ptr=malloc(100*sizeof(int));
ca "travaillera "en deux temps
- L'ordinateur cherche un endroit en mémoire suffisemment grand pour contenir de manière contigue 100 valeurs de type entier différentes
- ptr prend la valeur de l'adresse mémoire
(il y a un phénomene de réservation, mais, j'ai décidé de le laisser sur le coté 
)
Seulement, il peut arriver que... l'ordinateur ne trouve pas la place en mémoire demandée... c'est moche...
Si c'est le cas, il renverra une valeur NULL (que ptr prendra).
La première chose qu'il faut faire, pour éviter des catastrophes, c'est de vérifier si ptr est différent de NULL, et de ne travailler avec lui QUE s'il a effectivement une valeur différente de NULL sous la forme de
1
2
3
4
5
6
7
8
9
|
if(ptr!=NULL)
{
//ici, c'est bon
}
else
{
// aie... ici c'est pas bon
} |
Quand il s'agit de passer un argument à une fonction, ben... relis mes posts précédents
Pour ce qui est enfin des pointeurs de pointeurs, il s'agit simplement de pointeurs qui pointent sur un autre pointeur, mais le raisonnement est identique...
EDIT==>Quand je met du code, ce n'est pas pour rien...
Lis surtout les commentaires qui sont ajoutés (ce qui suit //) C'est surtout cela qui t'aidera à comprendre
Envoyé par stokastik
A méditer: La solution la plus simple est toujours la moins compliquée
Répondre avec citation
), mais c'est bien expliqué.
Partager