Incrémentation qui passe de 4 en 4Résolu

Question

Bonjour j'ai écrit ou plutot tenté d'écrire un petit programme qui fait un dump de la mémoire malheureusement le pointeur principal 'adresse' passe de 4 en 4 et donc corrompt le dump alors qu'il est incrémenté de 1. le source est en C j'espere que le format vous conviendra, si quelqu'un pouvait m'éclairer car je suis vous l'avez compris novice, Merci, #include #include #include int peek=0; int a=0; int i=0; int n=0; int offset=0; int main(int argc, char *argv[]) { long* memoireAllouee = NULL; memoireAllouee = malloc(sizeof(char)*1000); // Allocation de la mémoire long *adresse=NULL; // Initialisation et mise a zero du pointeur adresse adresse=memoireAllouee; // Récupération de l'adresse de la plage mémoire allouée printf("plage mémoire allouee %lx val adresse %lx ",memoireAllouee,adresse); system("PAUSE"); for (n = 0 ; n<255 ; n++) // Boucle verticale du dump { printf("n %ld adresse %lu memoireAllouee %ld ",n,adresse,memoireAllouee); for (i = 0 ; i < 60; i++) // Boucle horizontale du dump { peek=*(adresse+i); if (peek >= 32 && peek <=22255) { printf("%c",peek); // Affiche le contenue de l'adresse mémoire } else { printf("peek(%ld)",peek); // Affiche le contenue de l'adresse mémoire } } printf("% " ); // Retour à la ligne en fin d'affichage adresse=adresse+1; // Incrémentation de 1 du pointeur adresse } system("PAUSE"); return 0; }

DeAtHCrAsH · Accepted Answer

En fait si tu veux, l'adresse du pointeur est codé sur 4 octets (système 32 bits), donc un long ou un int.
Après selon le type de pointeur déclarée, l'incrémentaton va se faire au cas par cas.

En gros si tu veux incrémenter de 1 octet, faut que tu utilises un type dont le sizeof(..) vaut 1 octet, ce qui est le cas des char et byte.
- sizeof(byte) sizeof(char) 1 octet => Donc l'incrémentation du pointeur se fera octet par octet- sizeof(int) sizeof(long) 4 octets => Donc l'incrémentation du pointeur se fera par passe de 4 octets

Et ainsi de suite.

Voili voilou chef.

Shell

cs_N3oPhyte · Answer

Désolé j'avais modifié le source pour tracer, le voici à nouveau sans le if #include #include #include int peek=0; int a=0; int i=0; int n=0; int offset=0; int main(int argc, char *argv[]) { long* memoireAllouee = NULL; memoireAllouee = malloc(sizeof(char)*1000); // Allocation de la mémoire long *adresse=NULL; // Initialisation et mise a zero du pointeur adresse adresse=memoireAllouee; // Récupération de l'adresse de la plage mémoire allouée printf("plage mémoire allouee %lx val adresse %lx ",memoireAllouee,adresse); system("PAUSE"); for (n = 0 ; n<255 ; n++) // Boucle verticale du dump { printf("n %ld adresse %lu memoireAllouee %ld ",n,adresse,memoireAllouee); for (i = 0 ; i < 60; i++) // Boucle horizontale du dump { peek=*(adresse+i); //if (peek >= 32 && peek <=22255) //{ printf("%c",peek); // Affiche le contenue de l'adresse mémoire //} //else // { //printf("peek(%ld)",peek); // Affiche le contenue de l'adresse mémoire //} } printf("% " ); // Retour à la ligne en fin d'affichage adresse=adresse+1; // Incrémentation de 1 du pointeur adresse } system("PAUSE"); return 0; }

gamemonde · Answer

for (i = 0 ; i < 60; i++)               // Boucle horizontale du dump
 {
    peek++;
}

cs_rt15 · Answer

Salut,


J'ai comme l'impression que tu veux afficher des octets, alors que tu utilise un pointeur sur des long.
long *adresse=NULL; 


Avec ça, si tu fais adresse++, adresse est en fait incrémenté de siezeof(long)


Si tu veux des octets, déclare des char * et des char.
<hr size="2" width="100%" />3ème année en ecole d'ingé d'info cherche stage de 4 mois à partir du 01/04/08

cs_N3oPhyte · Answer

Merci RT15 ça marche,

par contre si j'ai une adresse qui est codé sur un octet ca vas pas le faire!
donc je comprends plus, et pourtant ça marche.

le pointeur adresse est censé reprendre le pointeur de malloc soit memoireAllouee

ça veut dire que si tu pointe sur une adresse avec un pointeur déclaré en long tu bouge de 4 octets en 4 octets à l'intérieur de la ram? 

mais comment un pointeur peut il être en char!!!!

désolé de vous solliciter ;) encore merci RT15

DeAtHCrAsH · Answer

Un pointeur est toujours codé sur 4 octets, soit la taille d'un int (ou d'un long sur système 32 bits).sizeof(char *) sizeof(int *) sizeof(long *) = ....

Shell

cs_N3oPhyte · Answer

Ok je comprends que le pointeurs soit codé sur 4 octets pour accéder à la mémoire complète mais ça n'explique pas que l'ont ne puisse pas l'incrémenter de 1? ou je dit une grosse bétise?

de même la syntaxe printf("%c",*(adresse+i)); est valable pour avoir le contenu du de l'adresse du pointeur (*adresse+i))?? ou je fait fausse route

Merci de votre aide, c'est sympa d'avoir un contact avec des gens qui maitrise,

cs_rt15 · Answer

On peut l'incrémenter de 1, mais il faut caster.

L'incrémentation de la taille du type pointé est une fonctionnalité du langage C sensée faciliter le travail avec les pointeurs... Quand on incrémente des pointeurs, c'est généralement pour parcourir des tableaux. Donc passer de case en case en incrémentant de 1 leur a semblé plus simple que d'incrémenter de sizeof le type du tableau.

C'est un peu pareil quand tu fais tab[i], tu fais pas tab[sizeof(MonTypeDeCase) * i]. Pourtant, en interne, c'est globalement ce qui se ferat.

DeAtHCrAsH · Answer

Si ca peut t'aider voici une petite explication plus claire.

Exemple 1:
Un entier est codé sur 4 octets.
Si je déclare un tableau de 2 entiers, j'occuperai donc un espace mémoire de 8 octets.
Mes deux éléments de mon tableau sont tous deux accessible par un pointeur chacun.

Si je prend le pointeur du premier élément et que je l'incrémente de 1, alors je passe à mon deuxième élément, soit 4 octets plus loin.

=> L'incrémentation de pointeur d'entier se fait donc par passe de 4 octets.

Exemple 2:

Un char est codé sur 1 octet.
Si je déclare un tableau de 2 char, j'occuperai donc un espace mémoire de 2 octets.
Mes deux éléments de mon tableau sont tous deux accessible par un pointeur chacun.

Si je prend le pointeur du premier élément et que je l'incrémente de 1, alors je passe à mon deuxième élément, soit 1 octet plus loin.

=> L'incrémentation de pointeur de char se fait donc par passe de 1 octet.

Conclusion générale :
Quand tu incrémentes un pointeur, celui ci s'incrémentera de la taille du type de l'élément auquel il fait référence.

Shell

cs_N3oPhyte · Answer

je commence à percuter merci deathcrash pour ta précision, je pense que donc pour le mémory dump, je peut déclarer le pointeur sur la mémoire en char et l'incrémenter de 1 ? (je ne pensais pas q'un pointeur pouvais être autre chose que long!!) ;)

Merci Bcp de t'être donné le mal de répondre,

cs_N3oPhyte · Answer

Merci DeathCrash c'est limpide maintenant, j'aurrais mis le temps mais c'est clair 1 - Quel que soit le pointeur il est codé sur 4 octets 2 - Il s'incrémente de la classe dont il est déclaré. Ca fait plaisir de comprendre un peut mieux ! Merci bcp pour le temps que tu as passé à répondre, j'ai cliquer sur accepter la réponse, Voilà le dump qui marche (grace à tes explications!): #include #include #include int peek=0; int a=0; int i=0; int n=0; int offset=0; int main(int argc, char *argv[]) { long *memoireAllouee = NULL; memoireAllouee = malloc(sizeof(char)*10000); // Allocation de la mémoire char *adresse=NULL; // Initialisation et mise a zero du pointeur adresse adresse=memoireAllouee; // Récupération de l'adresse de la plage mémoire allouée printf("plage mémoire allouee %lx val adresse %lx ",memoireAllouee,adresse); system("PAUSE"); for (n = 0 ; n<255 ; n++) // Boucle verticale du dump { printf("n %ld adresse %lu memoireAllouee %ld ",n,adresse,memoireAllouee); printf ("debut de la boucle n"); for (i = 0 ; i < 60; i++) // Boucle horizontale du dump { // peek=*(adresse+i); printf("%c",*adresse); // Affiche le contenue de l'adresse mémoire adresse=adresse+1; // Incrémentation de 1 du pointeur adresse } printf(" "); // Retour à la ligne en fin d'affichage } system("PAUSE"); return 0; }

Incrémentation qui passe de 4 en 4

11 réponses

Votre réponse

Discussions similaires