en utilisant malloc pour le bloc de structures

Question

J'essaye d'allouer un bloc de mémoire, et stocke une liste de structures sans employer plusieurs mallocs pour chacun ... ceci est juste un exemple générique, je n'ai pas le code original I travaillait avec plus tôt, mais c'est l'idée générale, mais mon problème était que je recevais une corruption de tas quand d'autres parties de mon code s'exécutaient après l'appel de la fonction InitPoints(). Je ne sais pas quelle partie de mon code est illégale, mais je suppose que c'est dans la boucle for de la fonction InitPoints(). J'essaie d'utiliser cela comme une table, puis je peux créer des tables supplémentaires de taille définie si je manque de mémoire et les lier ensemble ... donc un peu comme un tableau dynamique en expansion si cela a du sens.

typedef struct Tb{ 
    POINT points; 
    POINT *next; 
} TABLE; 

typedef struct Pt{ 
    int x; 
    int y; 
}POINT; 

POINT *mypoints; 

int main() { 
    int size = 10; 
    int i = 0; 
    mypoints = InitPoints(size); 

    for(i=0; i < size; i++) 
    { 
     printf("mypoint [%d] = (%d,%d)\n",i, mypoints->x, mypoints->y); 
     mypoints = mypoints + sizeof(POINT); 
    } 
    // some other code... 
    // i.e. createThread(....) 

    return 0; 
} 

POINT* InitPoints(int size) 
{ 
    POINT *tmp; 
    POINT *orig; 
    int a = 10; 
    int b = 1000; 
    orig = (POINT*) malloc (sizeof(POINT) * size); 
    if(orig == NULL) 
     return NULL; 

    tmp = orig; 
    for (i = 0; i < size; i++) 
    { 
     tmp->x = a++; 
     tmp->y = b++; 
     tmp = tmp + sizeof(POINT); 
    } 
return orig; 
} 

Answer 1

Ceci est faux:

mypoints = mypoints + sizeof(POINT); 

Vous devriez examiner l'arithmétique des pointeurs en C. Il suffit d'utiliser:

mypoints += 1; /* or something similar */ 

(Il y a un problème similaire dans votre fonction InitPoints)

est ici un référence:

http://www.eskimo.com/~scs/cclass/notes/sx10b.html

Answer 2

Le problème est dans cette ligne:

tmp = tmp + sizeof(POINT); 

Il devrait être

++tmp; 

Ce dernier dit d'incrémenter le pointeur par un élément; puisqu'il pointe vers la structure, il s'incrémente de la taille de la structure. Le code original incrémente à la place de n éléments où n est le nombre d'octets dans la structure. Par exemple, si int est de 32 bits, il sera avancé de 8 éléments.

Answer 3

C'est pourquoi je le ferais

for (i = 0; i < size; i++) 
{ 
    orig[i].x = a++; 
    orig[i].y = b++; 
} 

Answer 4

En C, en ajoutant un entier à un pointeur POINT * avance le pointeur non par ce nombre d'octets, mais ce nombre de structures POINT.

Vous avez deux endroits dans votre code où vous ajoutez sizeof(POINT) à votre pointeur. Au lieu de cela, vous devriez juste ajouter 1.