Quelle quantité de mémoire serait libérée si le pointeur était modifié en C?

Supposons qu’il y a 20 blocs de mémoire et qu’un pointeur p pointe vers le premier bloc. Maintenant, quand je fais:

 p++; free(p); 

Combien de blocs de mémoire seraient libérés et pourquoi?

Non déterministe. Je ne peux pas dire. Vous devez fournir le pointeur exact qui a été renvoyé par malloc() .

Passer un pointeur sur free() qui n’est pas renvoyé par malloc() [et sa famille] constitue un comportement indéfini .

Selon votre question, si le pointeur malloc() est stocké dans p , et que vous le faites p++ et appelez free(p); , alors p n’est plus un pointeur renvoyé par la fonction calloc , malloc ou realloc .

Conformément au chapitre 7.20.3.2, norme c99 , deuxième paragraphe

La fonction free provoque la désallocation de l’espace pointé par ptr, c’est-à-dire qu’elle est disponible pour une allocation ultérieure. Si ptr est un pointeur nul, aucune action ne se produit. Sinon, si l’argument ne correspond pas à un pointeur précédemment renvoyé par la fonction calloc, malloc ou realloc, ou si l’espace a été libéré par un appel à free ou realloc, le comportement est indéfini.

Une fois que la mémoire est allouée sur le tas à l’aide de malloc() calloc() ou realloc() , un enregistrement est conservé sur la quantité de mémoire allouée au cours de l’un de ces appels.

Donc, si quelques x octets sont alloués, ces informations sont gérées séparément par le système d’exploitation.

Comme

 ---------------------------- | Pointer | Memory allocated| ---------------------------- 

Maintenant, laissez votre pointeur qui a été utilisé lors de l’allocation dynamic de la mémoire pointé sur n’importe quel emplacement, c’est-à-dire un emplacement autre que celui de la mémoire sur lequel il était pointé lors de l’allocation initiale.

Mais lorsque vous appelez free, le pointeur ne lui importe pas, il se contente de regarder dans l’enregistrement où il obtient la quantité de mémoire allouée dynamicment sur le tas.

Donc free () utilise cet enregistrement et libère la mémoire allouée. Vous devez donc toujours passer le pointeur utilisé lors de malloc() , calloc() et realloc()

Ça dépend. Votre question ne fournit pas d’informations suffisantes.

Si p++ fait référence à un bloc qui a également été alloué par malloc() , alors ce bloc sera renvoyé au tas (quelle que soit la taille allouée). Si toutefois ce n’était pas un pointeur sur un bloc alloué dynamicment, vous corrompriez le tas, et le résultat serait non déterministe, mais jamais bon!

Donc par exemple si vous deviez faire:

 struct sBlock* p = malloc( 20 * sizeof(struct sBlock) ) ; p++ ; // point to second block free( p ) ; // Heap corruption or runtime error 

Le runtime C n’est pas nécessaire pour intercepter de telles erreurs, mais certaines implémentations ou environnements de débogage peuvent le faire. Le plus souvent, l’erreur passera inaperçue jusqu’à ce que vous essayiez d’allouer ou de libérer de la mémoire après avoir corrompu les structures utilisées par le segment de mémoire pour garder une trace de la mémoire. Le mode de défaillance réel sera imprévisible et se produit souvent à une certaine distance à la fois de la proximité du code et du temps écoulé depuis le débogage rendant le processus de débogage difficile.