Ecriture de nombres dans la mémoire

Résolu/Fermé
maniqk - 8 juil. 2013 à 14:51
 maniqk - 9 juil. 2013 à 09:57
Bonjour,

Je cherche à écrire dans des adresses spécifiques de la mémoire des nombres que je génère aléatoirement (le caractère aléatoire n'a pas vraiment d'importance pour le sujet).

Voici mon code :
int main(){
   float *adresse_depart = NULL;
   int i = 0, j = 0;
   int nombre_aleatoire = 0;

   srand(time(NULL));

   adresse_depart = (float *)0x80000000;

   for(j=0;j<400;j++){
      nombre_aleatoire = rand_a_b(0,20)-10; // Pour générer un nombre entre -10 et 10
      *adresse_depart = nombre_aleatoire;
      printf("dans adresse : %d",*adresse_depart);
      adresse_depart += 0x1;
   }

   return 0;
}


Je ne comprends pas pourquoi ce programme ne fonctionne pas, quand je demande de print le nombre aléatoire généré, je vois que c'est bien généré. Quand je veux affecter la valeur générer dans *adresse_depart, il me met des 0 de partout. Pourquoi donc ?

Une autre petite question sinon, pourquoi en faisant adresse_depart += 0x1, la prochaine adresse est 0x80000004 et non 0x80000001 ?

Merci d'avance,
maniqk

A voir également:

3 réponses

Utilisateur anonyme
8 juil. 2013 à 16:10
Bonjour

C'est très étonnant que tu n'aies pas un plantage pur et simple en essayant d'écrire à une adresse donnée en mémoire. En général, les OS empêchent ce genre de chose, et si l'OS ne t'empêche pas, as-tu une idée d'où tu vas écrire ? Tu vas écraser quelque chose quelque part, mais quoi ???
Note que c'est tout à fait possible quand même, à condition de bien maîtriser l'espace mémoire du processeur, ce qui peut être le cas par exemple si tu travailles avec un microcontrôleur, mais je n'ai pas l'impression que ce soit ton cas.

Sinon, ton programme a une grosse anomalie : tu déclares float *adresse_depart, mais dans ton printf, tu associes un %d à *adresse_depart, que tu traites donc alors comme un int * puisque %d analyse un int.

Enfin, il est normal que le contenu du pointeur n'avance pas que de 1 : l'incrémentation d'un pointeur ne lui ajoute pas 1, mais la taille de l'objet pointé (ce qui est infiniment plus pratique dans les boucles).
1
Utilisateur anonyme
9 juil. 2013 à 09:55
Si, c'est possible d'écrire à l'adresse 0x80000001 et tu l'as fait puisque en écrivant un int (ou un float, je ne sais plus vu ton erreur) tu écris plusieurs adresses à la fois, une donnée occupant plusieurs adresses. C'est même pour ça que l'incrémentation du pointeur 'saute' des adresses : pour ne pas ré-écrire partiellement sur ce que tu viens d'écrire.
1
Merci, c'est bien ce que je pensais ^^
0
En fait j'écris dans la mémoire d'une carte externe. C'est probablement pour ça que c'est possible ^^

Merci pour la solution, c'était en fait une erreur d'inattention !

Et du coup il n'est pas possible d'écrire à l'adresse 0x80000001 ? Ou bien il y a déjà des choses dedans vu que j'écris en 0x80000000 et selon ce que je mets dedans ?
0