Incrémentation qui passe de 4 en 4

[Résolu]
Signaler
Messages postés
6
Date d'inscription
jeudi 22 novembre 2007
Statut
Membre
Dernière intervention
24 novembre 2007
-
Messages postés
6
Date d'inscription
jeudi 22 novembre 2007
Statut
Membre
Dernière intervention
24 novembre 2007
-
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 <stdio.h>
#include <stdlib.h>
#include <string.h>


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 \n",memoireAllouee,adresse);
system("PAUSE");


for (n = 0 ; n<255 ; n++)                   // Boucle verticale du dump
{


printf("n %ld adresse %lu memoireAllouee %ld \n",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("%\n" );                             // Retour à la ligne en fin d'affichage
adresse=adresse+1;                          // Incrémentation de 1 du pointeur adresse
}


system("PAUSE");


return 0;
}

11 réponses

Messages postés
2671
Date d'inscription
vendredi 25 janvier 2002
Statut
Membre
Dernière intervention
6 février 2013
2
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
Messages postés
6
Date d'inscription
jeudi 22 novembre 2007
Statut
Membre
Dernière intervention
24 novembre 2007

Désolé j'avais modifié le source pour tracer, le voici à nouveau sans le if

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


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 \n",memoireAllouee,adresse);
system("PAUSE");


for (n = 0 ; n<255 ; n++)                   // Boucle verticale du dump
{


printf("n %ld adresse %lu memoireAllouee %ld \n",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("%\n" );                             // Retour à la ligne en fin d'affichage
adresse=adresse+1;                          // Incrémentation de 1 du pointeur adresse
}


system("PAUSE");


return 0;
}
Messages postés
336
Date d'inscription
samedi 9 août 2003
Statut
Membre
Dernière intervention
9 juillet 2011
2
for (i = 0 ; i < 60; i++)               // Boucle horizontale du dump
 {
    peek++;
}
Messages postés
3874
Date d'inscription
mardi 8 mars 2005
Statut
Modérateur
Dernière intervention
7 novembre 2014
15
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
Messages postés
6
Date d'inscription
jeudi 22 novembre 2007
Statut
Membre
Dernière intervention
24 novembre 2007

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
Messages postés
2671
Date d'inscription
vendredi 25 janvier 2002
Statut
Membre
Dernière intervention
6 février 2013
2
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
Messages postés
6
Date d'inscription
jeudi 22 novembre 2007
Statut
Membre
Dernière intervention
24 novembre 2007

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,
Messages postés
3874
Date d'inscription
mardi 8 mars 2005
Statut
Modérateur
Dernière intervention
7 novembre 2014
15
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.
Messages postés
2671
Date d'inscription
vendredi 25 janvier 2002
Statut
Membre
Dernière intervention
6 février 2013
2
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
Messages postés
6
Date d'inscription
jeudi 22 novembre 2007
Statut
Membre
Dernière intervention
24 novembre 2007

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,
Messages postés
6
Date d'inscription
jeudi 22 novembre 2007
Statut
Membre
Dernière intervention
24 novembre 2007

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 <stdio.h>
#include <stdlib.h>
#include <string.h>


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 \n",memoireAllouee,adresse);


system("PAUSE");


  for (n = 0 ; n<255 ; n++)                   // Boucle verticale du dump
  {
printf("n %ld adresse %lu memoireAllouee %ld \n",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("\n");                             // Retour à la ligne en fin d'affichage
 
  }




system("PAUSE");


return 0;
}