alors je préviens, j'avais plus touché à du code depuis une bonne année ><
A la lumière des exemple, je vois plus.
Quelle est la taille d'un char ? 1 octet ?
Quelle est la taille d'une adresse mémoire ? 8 octets ?
Quelle est ici la taille minimale d'une allocation ? 32 octets ?
Et on peut savoir la taille d'une variable allouée avec un malloc après coup pour éviter de déborder ?
_____________________ Quelques exemples que j'ai utilisé pour en venir à mes idées de réponse ^^
J'ai deux variables (char*) que j'affiche toujours dans le même ordre (première, puis seconde).
Avant l'allocation, c'est tout null.
Adresse0 : (nil) Contenu : (null)
Adresse1 : (nil) Contenu : (null)
Après l'alloc, on constate que les deux adresses pointées ont un espacement de 20 hexa (32)
Adresse0 : 0x159f010 Contenu :
Adresse1 : 0x159f030 Contenu :
Maintenant on va mettre des choses dedans. Ça marche tant qu'on dépasse pas 32 char
1234567891011121314151617181920
azertyuiopqsdfghjklmwxcvbn
Donc rien a signaler
Adresse0 : 0x159f010 Contenu : 1234567891011121314151617181920
Adresse1 : 0x159f030 Contenu : azertyuiopqsdfghjklmwxcvbn
mais si on modifie la première valable en mettant plus que 32 char dans la première variable (0x159f010)
0000000000000000000000000000000000000000000000000000 //52 fois 0
Adresse0 : 0x159f010 Contenu : 0000000000000000000000000000000000000000000000000000 //52 fois 0
Adresse1 : 0x159f030 Contenu : 00000000000000000000 //20 fois 0
Code utilisé ;
#include <stdlib.h>
#include <stdio.h>
void printAddrVal(char* var)
{
printf("Adresse : %p Contenu : %s\n",var,var);
}
int main(int argc, char *argv[])
{
char* str0=NULL;
char* str1=NULL;
//on constate que c'est bien null
printAddrVal(str0);
printAddrVal(str1);
str0=malloc(1);
str1=malloc(1);
//on y voit "l'écart" des deux adresses
printAddrVal(str0);
printAddrVal(str1);
scanf("%s",str0);
scanf("%s",str1);
printAddrVal(str0);
printAddrVal(str1);
//elles sont initialisées, mais si on écrit plus loin, on écrase ce qu'il y avait.
scanf("%s",str0);
printAddrVal(str0);
printAddrVal(str1);
free(str1);
free(str0);
}Comme vous le verrez dessous, un "malloc(1)" fait "32bits" (on le voit aux adresses, 20 de différence en hexa, c'est 32). Ok, c'est le minimum que peut allouer le système.
Et le débordement c''est après 32 char seulement posés.
J'ajoute que :
printf("char %ld",sizeof(char));Renvoie 1, et
printf("&char %ld",sizeof(&str0));Renvoie 8.
Et pire :
str0=malloc(366); printf("&char %ld",sizeof(str0));renvoie 8