Hola gente, estoy teniendo problemas para saber cuando utilizar la flecha y el punto cuando tengo que acceder a algun campo de una estructura.

Por ejemplo si yo tengo:

 

struct sData {

char Nombre[30];

char Apellido[30];

unsigned char Edad;

};



typedef struct Snode{

  struct sData *dato;

  struct Snode *ptr;

}SNODE;



int main(void)

{

   SNODE buff;

   SNODE *H;

  // ingresas , lo guardas , se lo pasas a la funcion y ella lo enlista

  

  H=NULL;

 [b] buff.dato = (struct sData*) malloc(sizeof(struct sData));[/b]

  

  printf("\n Ingrese nombre:");

  scanf("%s",buff.dato->Nombre);

  

  while(strcmp(buff.dato->Nombre,"FIN")!= 0)

  {

	  

  printf("\n Ingrese apellido:");

  scanf("%s",buff.dato->Apellido);

  printf("\nIngrese edad:");

  scanf("%c",&(buff.dato->Edad));

  

  ingreso_simple_alfinal(buff,&H);

  

   printf("\n Ingrese nombre:");

  scanf("%s",buff.dato->Nombre);

  }

 return 0;

}

La linea que esta en negrita : buff.dato = (struct sData*) malloc(sizeof(struct sData)); esa linea no entiendo porque se usa punto, osea porque buff.dato , si dato es un puntero entonces deberia ser buff->dato , pero no porque cuando compilo me tira error: invalid type argument of ‘->’ (have ‘SNODE’)
La verdad que me mareo , si no compilo no se si esta bien o mal.

Un saludo a todos!

Flecha es cuando tenés un puntero a estructura y punto cuando es una variable estructura.

---

Buff es una variable estructura, necesitás el punto para acceder al campo. Si tuvieras que acceder a un campo de dato sería buff.dato->campo

(23-01-2014 12:53)Dios escribió:  Flecha es cuando tenés un puntero a estructura y punto cuando es una variable estructura.

si es asi como decis vos, entonces porque funciona haciendo buff.dato ? , deberia ser buff->dato...

Ahora estoy desde el celular. Si no se entiende bien lo que escribo en un rato lo hago mejor desde una computadora.

(23-01-2014 12:56)nanohueso escribió:  

(23-01-2014 12:53)Dios escribió:  Flecha es cuando tenés un puntero a estructura y punto cuando es una variable estructura.

si es asi como decis vos, entonces porque funciona haciendo buff.dato ? , deberia ser buff->dato...

Proba si lo queres hacer así poniendo: SNODE *buff;

pero a ver si entiendo , la flechita no depende dato , sino de buff ?

La flechita depende de si el tipo de dato es puntero o variable
Eso es lo que me acuerdo yo

Como dicen arriba, cuando querés acceder a un campo de una variable estructura, usas el punto. Cuando en cambio, tenes un puntero a una estructura usas la flecha.

Fijate, en tu código, creas una variable llamada struct sData, osea una estructura. Después, lo siguiente que haces es declarar un tipo de dato SNODE, el cual es una estructura, y que tiene un puntero a un struct sData llamado dato como uno de sus campos.

Cuando vos haces:

buff.dato = (struct sData*) malloc(sizeof(struct sData));

Es correcto que uses el punto, ya que buff es un tipo de dato SNODE (osea, una estructura), y vos querés acceder a su campo dato, el cual es un puntero a una estructura...pero no te importa, te abstraes de eso...queres acceder a un campo de esa estructura?, usas el punto entonces.

(23-01-2014 13:28)nanohueso escribió:  pero a ver si entiendo , la flechita no depende dato , sino de buff ?

La sintaxis genérica es

 

punteroAEstructura->campo

Si campo también es un puntero a estructura, es así:

 

punteroAEstructura->campo->otroCampo

Ahora bien, si tenés una estructura igual, pero empezás con una variable y no un puntero es

 

estructura.campo

y para el otro

 

estructura.campo->otroCampo

Resumiendo, sí: el operador flecha (->) aplica a punteros y el operador punto (.) aplica a variables tipo estructura.

Si tenés un puntero a estructura y querés aplicar el operador punto deberías hacer algo así:

 

struct lala variable;

struct lala *puntero;



puntero = &variable;

(*puntero).campo;

porque el asterisco antes de un puntero hace que se comporte como la variable en sí...

No sé hasta qué punto les enseñan formalmente la sintaxis del lenguaje en electrónica, pero supongo que no la compliqué demasiado.

---

Para aplicarlo a tu código, fijate que tenés:

 

   SNODE buff;

entonces buff no es un puntero, por lo tanto tenés que usar el operador punto.

Lo entendi perfectamente , les agradezco Santi Aguito y Dios

(23-01-2014 13:04)Feer escribió:  

(23-01-2014 12:56)nanohueso escribió:  

(23-01-2014 12:53)Dios escribió:  Flecha es cuando tenés un puntero a estructura y punto cuando es una variable estructura.

si es asi como decis vos, entonces porque funciona haciendo buff.dato ? , deberia ser buff->dato...

Proba si lo queres hacer así poniendo: SNODE *buff;

Así como está su código, eso va a ser sintácticamente correcto pero semánticamente no. Además va a dar un error de segmentación porque buff va a tener "basura", debería inicializar buff con un malloc.

SNODE *buff = NULL;

para completar lo que dice Dios

 

//esto

a->b

//es exactamente igual que esto

(a*).b



//es pareccido a los arrays

a[1]

//es lo mismo que

(a+1)*

creo que eso esta explicado en el capitulo 7 del K & R