Vérifier si un pointeur est alloué de la mémoire ou pas

Vous ne pouvez pas vérifier, à l'exception de certains de la mise en œuvre spécifique de hacks.

Les pointeurs ont aucune information, autre que celui où ils point. Le meilleur que vous pouvez faire est de dire "je sais comment cette version de compilateur alloue de la mémoire, donc je vais déréférencement de mémoire, déplacez le pointeur de retour de 4 octets, vérifier la taille, permet de s'assurer qu'il correspond à..." et ainsi de suite. Vous ne pouvez pas le faire de manière standard, puisque l'allocation de mémoire est définie par l'implémentation. Ne pas oublier qu'ils pourraient ne pas avoir alloué dynamiquement à tous.

Vous avez juste à assumer votre client sait comment programmer en C. La seule onu-solution je pense, serait d'allouer de la mémoire vous-même et de le retourner, mais ce n'est guère un petit changement. (C'est un grand changement de conception.)

Le code ci-dessous est ce que j'ai utilisé une fois pour vérifier si certains pointeur de la tente de l'accès illégal de la mémoire. Le mécanisme est d'induire un SIGSEGV. Le signal SEGV a été redirigé vers une fonction privée à l'heure, qui utilise longjmp pour revenir au programme. Il est une sorte de hack, mais il fonctionne.

Le code peut être amélioré (utilisation "sigaction" au lieu de "signal", etc), mais c'est juste pour donner une idée. Aussi, il est portable à d'autres versions d'Unix pour Windows je ne suis pas sûr. Notez que le signal SIGSEGV ne doit pas être utilisé de quelque part d'autre dans votre programme.

#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>
#include <signal.h>

jmp_buf jump;

void segv (int sig)
{
  longjmp (jump, 1); 
}

int memcheck (void *x) 
{
  volatile char c;
  int illegal = 0;

  signal (SIGSEGV, segv);

  if (!setjmp (jump))
    c = *(char *) (x);
  else
    illegal = 1;

  signal (SIGSEGV, SIG_DFL);

  return (illegal);
}

int main (int argc, char *argv[])
{
  int *i, *j; 

  i = malloc (1);

  if (memcheck (i))
    printf ("i points to illegal memory\n");
  if (memcheck (j))
    printf ("j points to illegal memory\n");

  free (i);

  return (0);
}

J'ai toujours initialiser les pointeurs à null valeur. Donc quand j'ai allouer de la mémoire, elle va changer. Lorsque je vérifie si la mémoire a été allouée je ne pointer != NULL. Quand je désalloue la mémoire j'ai également réglé le pointeur à null. Je ne pense pas de toute façon de savoir si il y avait assez de mémoire allouée.

Cela ne résout pas votre problème, mais tu as à faire confiance que si quelqu'un écrit des programmes en C, alors il est assez habile pour le faire droit.

Non, en général il n'y a aucun moyen de le faire.

En outre, si votre interface est tout simplement "passer un pointeur vers une mémoire tampon où je vais mettre des choses", alors le visiteur peut choisir pas pour allouer de la mémoire à tous, et au lieu d'utiliser une taille fixe de la mémoire tampon qui est allouée statiquement ou une variable automatique ou quelque chose. Ou c'est peut-être un pointeur sur une partie d'un plus grand objet sur le tas.

Si votre interface spécifiquement dit "passez un pointeur vers la mémoire allouée (parce que je vais le désallouer)", alors vous devriez vous attendre que l'appelant le faire. À défaut de le faire n'est pas quelque chose que vous pouvez détecter de manière fiable.

Vous ne pouvez pas vérifier avec tout ce qui est disponible dans la norme C. Même si votre compilateur spécifique ont été pour fournir une fonction pour le faire, il serait toujours une mauvaise idée. Voici un exemple de pourquoi:

int YourFunc(char * buf, int buf_size);

char str[COUNT];
result = YourFunc(str, COUNT);

Je ne sais pas un moyen de le faire à partir d'un appel de la bibliothèque, mais sur Linux, vous pouvez regarder /proc/<pid>/numa_maps. Il montrera toutes les sections de la mémoire et de la troisième colonne va dire "tas" ou "pile". Vous pouvez regarder le raw la valeur du pointeur de voir où il s'aligne.

Exemple:

00400000 prefer:0 file=/usr/bin/bash mapped=163 mapmax=9 N0=3 N1=160
006dc000 prefer:0 file=/usr/bin/bash anon=1 dirty=1 N0=1
006dd000 prefer:0 file=/usr/bin/bash anon=9 dirty=9 N0=3 N1=6
006e6000 prefer:0 anon=6 dirty=6 N0=2 N1=4
01167000 prefer:0 heap anon=122 dirty=122 N0=25 N1=97
7f39904d2000 prefer:0 anon=1 dirty=1 N0=1
7f39904d3000 prefer:0 file=/usr/lib64/ld-2.17.so anon=1 dirty=1 N0=1
7f39904d4000 prefer:0 file=/usr/lib64/ld-2.17.so anon=1 dirty=1 N1=1
7f39904d5000 prefer:0 anon=1 dirty=1 N0=1
7fffc2d6a000 prefer:0 stack anon=6 dirty=6 N0=3 N1=3
7fffc2dfe000 prefer:0

Donc des pointeurs qui sont au-dessus de 0x01167000 mais en dessous de 0x7f39904d2000 sont situés dans le tas.

en général lib les utilisateurs sont responsables de l'entrée de vérifier et de vérification. Vous pouvez voir AFFIRMER ou quelque chose dans le répertoire lib de code et qu'ils sont utilisés uniquement pour le débogage perpose. c'est une façon standard lors de l'écriture de C/C++. alors que beaucoup de codeurs comme pour faire ce genre de vérifier et verfying dans leur lib code très soigneusement. vraiment de "MAUVAISES" habitudes. Comme indiqué dans le IOP/IOD, lib interfaces devraient être les contrats et faire clairement ce que sera la lib faire et ce qui va pas, et ce qu'est une lib utilisateur doit faire et ce qui ne devrait pas être nécessaire.

Il y a une façon simple de le faire. Chaque fois que vous créez un pointeur, écrire un wrapper autour d'elle. Par exemple, si votre programmeur utilise votre bibliothèque pour créer une structure.

struct struct_type struct_var;

assurez-vous qu'il alloue de la mémoire à l'aide de votre fonction, telle que la

struct struct_type struct_var = init_struct_type()

si ce struct_var contient de la mémoire est allouée dynamiquement, par ex,

si la définition de struct_type était

typedef struct struct_type {
 char *string;
}struct_type;

puis dans votre init_struct_type() fonction de cela,

init_struct_type()
{ 
 struct struct_type *temp = (struct struct_type*)malloc(sizeof(struct_type));
 temp->string = NULL;
 return temp;
}

De cette façon,à moins qu'il alloue de la temp->chaîne de valeur, il ne reste NULLE. Vous pouvez vérifier dans les fonctions qui utilisent cette structure, si la chaîne est NULLE ou pas.

Une chose de plus, si le programmeur est tellement mauvais, qu'il ne parvient pas à utiliser vos fonctions, mais plutôt directement les accès non alloué de la mémoire, il ne mérite pas de l'utilisation de votre bibliothèque. Assurez-vous juste que votre documentation spécifie tout.

Un pointeur tracker, de pistes et de la vérification de la validité d'un pointeur

utilisation:

créer mémoire int * ptr = malloc(sizeof(int) * 10);

ajouter l'adresse de pointeur sur le tracker Ptr(&ptr);

vérifier pour ne pas avoir des pointeurs PtrCheck();

et gratuit tous les traqueurs à la fin de votre code

PtrFree();

 #include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
struct my_ptr_t { void ** ptr; size_t mem; struct my_ptr_t *next, *previous; };
static struct my_ptr_t * ptr = NULL;
void Ptr(void * p){ 
struct my_ptr_t * tmp = (struct my_ptr_t*) malloc(sizeof(struct my_ptr_t));
printf("\t\tcreating Ptr tracker:");    
if(ptr){ ptr->next = tmp; }
tmp->previous = ptr;
ptr = tmp;
ptr->ptr = p;
ptr->mem = **(size_t**) ptr->ptr;
ptr->next = NULL;
printf("%I64x\n", ptr); 
};
void PtrFree(void){
if(!ptr){ return; }
/* if ptr->previous == NULL */
if(!ptr->previous){ 
if(*ptr->ptr){
free(ptr->ptr);
ptr->ptr = NULL;
}
free(ptr);
ptr = NULL; 
return;                 
}
struct my_ptr_t * tmp = ptr;    
for(;tmp != NULL; tmp = tmp->previous ){
if(*tmp->ptr){
if(**(size_t**)tmp->ptr == tmp->mem){
free(*tmp->ptr);
*tmp->ptr = NULL;
}
}
free(tmp);
} 
return; 
};
void PtrCheck(void){
if(!ptr){ return; }
if(!ptr->previous){
if(*(size_t*)ptr->ptr){
if(*ptr->ptr){
if(**(size_t**) ptr->ptr != ptr->mem){
printf("\tpointer %I64x points not to a valid memory address", ptr->mem);
printf(" did you freed the memory and not NULL'ed the pointer or used arthmetric's on pointer %I64x?\n", *ptr->ptr);
return; 
}   
}
return;
}
return;
}
struct my_ptr_t * tmp = ptr;
for(;tmp->previous != NULL; tmp = tmp->previous){   
if(*(size_t*)tmp->ptr){         
if(*tmp->ptr){
if(**(size_t**) tmp->ptr != tmp->mem){
printf("\tpointer %I64x points not to a valid memory address", tmp->mem);
printf(" did you freed the memory and not NULL'ed the pointer or used arthmetric's on pointer %I64x?\n", *tmp->ptr);                            continue;
} 
}
continue;
}
} 
return;
};
int main(void){
printf("\n\n\t *************** Test ******************** \n\n");
size_t i = 0;
printf("\t *************** create tracker ********************\n");
int * ptr = malloc(sizeof(int) * 10);
Ptr(&ptr);
printf("\t *************** check tracker ********************\n");
PtrCheck();
printf("\t *************** free pointer ********************\n");
free(ptr);
printf("\t *************** check tracker ********************\n");
PtrCheck();
printf("\t *************** set pointer NULL *******************\n");
ptr = NULL;
printf("\t *************** check tracker ********************\n");
PtrCheck();
printf("\t *************** free tracker ********************\n");
PtrFree();
printf("\n\n\t *************** single check done *********** \n\n");
printf("\n\n\t *************** start multiple test *********** \n");
int * ptrs[10];
printf("\t *************** create trackers ********************\n");
for(; i < 10; i++){
ptrs[i] = malloc(sizeof(int) * 10 * i);
Ptr(&ptrs[i]);
}
printf("\t *************** check trackers ********************\n");
PtrCheck();
printf("\t *************** free pointers but set not NULL *****\n");
for(i--; i > 0; i-- ){ free(ptrs[i]); }
printf("\t *************** check trackers ********************\n");
PtrCheck(); 
printf("\t *************** set pointers NULL *****************\n");
for(i=0; i < 10; i++){ ptrs[i] = NULL; }
printf("\t *************** check trackers ********************\n");
PtrCheck(); 
printf("\t *************** free trackers ********************\n");
PtrFree();
printf("\tdone");
return 0;
}

Bien, je ne sais pas si quelqu'un ne l'avait pas mis ici déjà ou si il va être une possibilité dans votre programme. J'ai été aux prises avec les mêmes chose dans mon projet de l'université.

Je l'ai résolu tout simplement - Dans l'initialisation de la partie de main() , après j'ai déclaré LIST *ptr, j'ai juste mis ptr=NULL. Ce

int main(int argc, char **argv) {
LIST *ptr;
ptr=NULL;

Ainsi, lorsque l'allocation échoue ou le pointeur de la souris n'est pas attribué à tous, elle sera NULLE. AINSI, vous pouvez simplement le tester avec si.

if (ptr==NULL) {
"THE LIST DOESN'T EXIST" 
} else {
"THE LIST MUST EXIST --> SO IT HAS BEEN ALLOCATED"
}

Je ne sais pas comment votre programme est écrit, mais vous avez sûrement comprendre que suis-je en train d'essayer de mettre en évidence. Si il est possible de vérifier comme ça, ta répartition et de passer ensuite vos arguments à vous fonctionnez, vous pourriez avoir une solution simple.

Bien sûr, vous devez être prudent d'avoir vos fonctions avec l'allocation et de la création de la structure fait du bien, mais où en C, vous n'avez pas à être prudent.