variables locales non initialisées!

Question

Voici mon code:

int main(void) 
{ 
    int i; 
    Coords** latLng; 
    Quadrado* q1; 
    latLng[0] = AdicionaValores(latLng[0],-23.000490,-43.346687); 
    latLng[1] = AdicionaValores(latLng[1],-22.988243,-43.342224); 
    q1 = AdicionaValoresQuadrado(q1,-23.000490,-43.346687,-22.988243,-43.342224); 

    printf("# Connecting to database.\n"); 
    for(i=0;i<2;i++) 
    { 
    if(clientInside(q1, latLng[i])) 
     printf("Dentro"); 
    else 
     printf("Fora"); 
    } 
    system("PAUSE"); 
} 

Voici AdicionaValores et AdicionaValoresQuadrado:

Coords* AdicionaValores(Coords* v, double x, double y) 
{ 
    v = (Coords*) malloc(sizeof(Coords)); 
    v->x = x; 
    v->y = y; 
    return v; 
} 

Quadrado* AdicionaValoresQuadrado(Quadrado* q, double x1, double y1, double x2, double y2) 
{ 
    q = (Quadrado*) malloc(sizeof(Quadrado)); 
    q->x1 = x1; 
    q->x2 = x2; 
    q->y1 = y1; 
    q->y2 = y2; 
    return q; 
} 

il compile très bien avec 2 avertissements, me disant que latlng et q1 sont uninitialized! que devrais-je faire ?? malloc les sur le principal? Aidez-moi!

Answer 1

latLng et q1 sont en effet non initialisée.

Coords** latLng; 
latLng[0] = … 

Vous ne l'avez jamais affecté rien à latLng, et pourtant vous essayez de le traiter comme un pointeur vers un tableau où vous voulez mettre une valeur. Vous devez non seulement pour initialiser latLng à un pointeur valide, mais également allouer la mémoire pour le tableau. Comme il est un tableau avec une taille fixe (2) qui n'a pas besoin de durer au-delà de la durée de vie de la fonction, vous pouvez la renvoyer sur la pile.

Coords* latLng[2]; 
latLng[0] = … 

Après ce changement, vous aurez toujours des avertissements au sujet des variables non initialisées, mais cela est dû à un problème dans l'interface de AdicionaValores et AdicionaValoresQuadrado. Ces fonctions n'utilisent jamais réellement leur premier argument, mais elles en requièrent une, et vous passez une valeur complètement arbitraire.Supprimez simplement le premier argument et déclarez v en tant que variable locale.

Coords* AdicionaValores(double x, double y) 
{ 
    Coords *v = malloc(sizeof(Coords)); 
    v->x = x; 
    v->y = y; 
    return v; 
} 

(Notez que vous n'avez pas besoin de jeter la valeur de retour de malloc, et vous ne devez jamais utiliser un casting sauf si vous avez une raison de et vous comprenez pourquoi. Dans un programme de production, vous devriez vérifier si malloc manque de mémoire, mais c'est ok pour l'instant) Puis, en main:.

Coords* latLng[2]; 
Quadrado* q1; 
latLng[0] = AdicionaValores(-23.000490,-43.346687); 
latLng[1] = AdicionaValores(-22.988243,-43.342224); 
q1 = AdicionaValoresQuadrado(-23.000490,-43.346687,-22.988243,-43.342224); 

Answer 2

Coords** latLng; 
//... 
latLng[0] = AdicionaValores(latLng[0],-23.000490,-43.346687); 
latLng[1] = AdicionaValores(latLng[1],-22.988243,-43.342224); 

Ici vous déclarez un pointeur vers pointeur sur la structure Coords (s), mais vous continuez à déréférencer un pointeur non initialisé dans les deux lignes suivantes. À ce stade, latLng n'est pas un pointeur valide et peut avoir n'importe quelle valeur.

Vous invoquez un comportement non défini. Vous devez initialiser latLng avant de déréférencer basé sur le nombre d'éléments sous (pointeurs à Coord) qu'il pointera vers. Vous pouvez ensuite continuer à initialiser les sous-éléments, comme ceci:

Coords* latLng[2]; 
//... 
latLng[0] = // some assignment 
latLng[1] = // some assignment 

Un autre problème que vous ne pouvez pas avoir encore réalisé est que votre malloc ne touche pas la valeur du pointeur que vous avez passé dans la fonction AdicionaValores. Vous passez le pointeur par valeur. Si vous souhaitez attribuer une nouvelle valeur au pointeur d'origine, vous devrez passer un pointeur vers elle, à savoir,

private Coords* AdicionaValores(Coords** q, double x, double y) 
{ 
    *v = (Coords*) malloc(sizeof(Coords)); 
} 

Cela semble fonctionner parce que vous renvoie simplement le pointeur. Vous n'avez pas besoin de prendre le premier paramètre car il n'est jamais utilisé. Il suffit de l'omettre et de renvoyer un nouveau pointeur.

Answer 3

Vous pouvez déclarer:

Coords *latLng[2]; 

pour la question "latlng" pas en cours d'initialisation ou malloc dans main.

Pour les autres - il n'y a aucune raison pour que les fonctions prennent le pointeur comme premier argument, puisqu'il ne fait rien avec la valeur d'origine. Alors faites:

Coords* AdicionaValores(double x, double y) 
{ 
    Coords* v = (Coords*) malloc(sizeof(Coords)); 
    .... 
} 
Quadrado* AdicionaValoresQuadrado(double x1, double y1, double x2, double y2) 
{ 
    Quadrado* q = (Quadrado*) malloc(sizeof(Quadrado)); 
    .... 
} 

Et puis ne leur passez pas ce premier argument dans main.