Autor Tema: Estructuras anidadas en lenguaje C.  (Leído 903 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado Daniel1952

  • PIC10
  • *
  • Mensajes: 13
Estructuras anidadas en lenguaje C.
« en: 05 de Febrero de 2017, 16:44:57 »
Hola, ¿cómo están?
Ya pude compilar el código que propuso KILLERJC, http://www.todopic.com.ar/foros/index.php?topic=47333.0 como todavía no había practicado con estructuras anidadas tengo algunas intrigas, alguien me podría explicar la relación de las 2 estructuras, como que tengo un montón de dudas pero no sé expresarlas, espero me interpreten aunque más no sea para empezar a entender esto de las estructuras anidadas. -

Código: C
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. typedef struct {
  5.         char texto[30];
  6.         int tipo;
  7. } texto_t;
  8.      
  9. typedef struct{
  10.         texto_t nombre;
  11.         texto_t direccion;
  12. }alumno;
  13.  
  14. const char * TiposString[]={"el nombre","la direccion"};
  15.  
  16. void get_String( texto_t * NomDir );
  17.  
  18. int main( void ){
  19.         alumno *ptrAlumno = (alumno*) malloc(sizeof(alumno));
  20.        
  21.         get_String( &ptrAlumno->nombre );
  22.  
  23.         ptrAlumno->direccion.tipo = 1;
  24.         get_String( &ptrAlumno->direccion );
  25.  
  26.         free( ptrAlumno );
  27.         return 0;
  28. }
  29.  
  30. void get_String( texto_t * NomDir ){
  31.         printf("\n Ingresa %s del alumno ......:", TiposString[NomDir->tipo] );
  32. }

Saludos y desde ya muchas gracias.
Daniel
abraza las cosas y personas malas como si fueran tu mas preciada joya,Son tus mas grandes maestros de paciencia sabiduría y amor y cuando lo abrazas dejan de causar dolor.-

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 5246
Re:Estructuras anidadas en lenguaje C.
« Respuesta #1 en: 05 de Febrero de 2017, 19:04:39 »
Una estructura pensalo como un conjunto de variables/struct/union agrupadas en un nombre..

Esta es una definicion de estructura, no ocupa espacio, no define un nuevo tipo, simplemente dice que My_Struct posee 2 variables dentro.

Código: C
  1. struct My_Struct {
  2.         int Var1;
  3.         char Var2;
  4. }
  5.  
Para crear una estructura en memoria termino declarando una

Código: C
  1. struct My_Struct MiConjunto;

Ahora MiConjunto son esas 2 variables. Como un contenedor. ¿Pero si en ves de una variable tengo un struct? Es lo mismo, en ves de reservar el espacio para una sola variable, reserva el espacio de lo que ocuparia la estructura.

En el codigo que pase use typedef para no repetir la palabra struct ( Como en el ejemplo anterior )

Código: C
  1. typedef struct {
  2.         char texto[30];
  3.         int tipo;
  4. } texto_t;
  5.      
  6. typedef struct{
  7.         texto_t nombre;
  8.         texto_t direccion;
  9. }alumno;

Entonces este codigo me dice que... texto_t es una estructura con 2 variables, un array de 30 char y un int. Luego alumno son 2 estructuras de estas.
Si hicieramos un mapa completo de lo que seria al crear una estructura alumnos seria algo asi:

Código: C
  1. alumno MiEstructura;

MiEstructura contiene:

Una estructura tipo texto_t:  nombre, a su ves esta posee un array de 30 char y un int
Una estructura tipo texto_t:  direccion, a su ves esta posee un array de 30 char y un int

Si lo vieramos en memoria seria algo asi:

Código: [Seleccionar]
Array 30 char      ------- Esto se accede con "nombre"
int-------------------------|

Array 30 char------------------\
int------------------------------------ Esto se accede con "direccion"
(Todo eso corresponde a MiEstructura)

Entonces tenemos que MiEstructura es un struct, si quiero acceder a un elemento lo hago con el punto, los elementos son 2 struct, nombre y direccion, si quiero acceder a uno de esos elementos uso el punto de nuevo. Ejemplo

Código: C
  1. MiEstructura.nombre.tipo;

En el ejemplo se pasa los punteros a las estructuras nombre o direccion... estas poseen 2 campos como vimso con anterioridad, como se pasa el puntero se usa el -> y tenes los 2 variables de esa estructura que son texto y tipo

Desconectado Daniel1952

  • PIC10
  • *
  • Mensajes: 13
Re:Estructuras anidadas en lenguaje C.
« Respuesta #2 en: 07 de Febrero de 2017, 07:38:27 »
Hola, KILLERJC. -
Muy pero muy didáctico lo tuyo, espero que todo aquel que tenga dudas en cuanto a estructuras tenga la posibilidad de leer tu post, muy entendible. - ((:-)) ((:-)) ((:-))

Saludos.
Daniel
abraza las cosas y personas malas como si fueran tu mas preciada joya,Son tus mas grandes maestros de paciencia sabiduría y amor y cuando lo abrazas dejan de causar dolor.-

Desconectado Daniel1952

  • PIC10
  • *
  • Mensajes: 13
Re:Estructuras anidadas en lenguaje C.
« Respuesta #3 en: 09 de Febrero de 2017, 10:57:41 »
Hola, que tengan un muy buen día. -
Me quedaron algunas dudas sobre las estructuras, quisiera saber si lo que propongo a continuación es correcto o estoy equivocado. -

si solo voy a ingresar un dato y trabajar sin punteros:
Código: C
  1. alumno unAlumno;
  2. unAlumno.nombre.tipo;
si solo voy a ingresar un dato y trabajar con punteros:
Código: C
  1. alumno *unAlumno;
  2. unAlumno->nombre->tipo;
Si tengo de antemano establecido la cantidad de datos (más de uno):
Código: C
  1. alumno unAlumno[5];
  2. unAlumno[1].nombre.tipo;
Si dejo a elección del operario la cantidad de datos a ingresar (con un bucle):
Código: C
  1. alumno *ptrAlumno = (alumno*) malloc(sizeof(alumno));
  2. ptrAlumno->nombre->tipo;

Saludos.
Daniel
abraza las cosas y personas malas como si fueran tu mas preciada joya,Son tus mas grandes maestros de paciencia sabiduría y amor y cuando lo abrazas dejan de causar dolor.-

Desconectado colotron

  • PIC12
  • **
  • Mensajes: 55
    • Canal de YouTube
Re:Estructuras anidadas en lenguaje C.
« Respuesta #4 en: 09 de Febrero de 2017, 13:35:44 »
Está mal la parte de punteros:

...si solo voy a ingresar un dato y trabajar con punteros:
Código: C
  1. alumno *unAlumno;
  2. unAlumno->nombre->tipo;

Debería ser
Código: C
  1. alumno *unAlumno;
  2. unAlumno->nombre.tipo;

El operador flecha es un de-referenciador parecido al * aplicado a campos de estructura. La -> debería usarse una sola vez si el campo de la estructura NO es un puntero.
Quiero decir, que

unAlumno->nombre
es como poner:
(*unAlumno).nombre

Pero bueno, alguien decidió que era más fácil usar -> que poner (*puntero).nombreCampo
La sintaxis de C (y de C++ ni hablemos) puede ser un poco críptica.

Otra cosa sería si
Código: C
  1.     typedef struct{
  2.             texto_t *nombre; //Notar  que puse un asterisco acá
  3.             texto_t direccion;
  4.     }alumno;
  5.  

entonces ahí sí tiene sentido hacer

unAlumno->nombre->tipo

Si tengo de antemano establecido la cantidad de datos (más de uno):
Código: C
  1. alumno unAlumno[5];
  2. unAlumno[1].nombre.tipo;

sí... y también podrías poner :)
(unAlumno + 1)->nombre.tipo
o
(*(unAlumno+1)).nombre.tipo

y pongo paréntesis porque es "más claro" :P

Desconectado Daniel1952

  • PIC10
  • *
  • Mensajes: 13
Re:Estructuras anidadas en lenguaje C.
« Respuesta #5 en: 09 de Febrero de 2017, 15:55:53 »
Hola  colotron.
Un gustazo leerte, si me concentrara un poco más en lo que estoy haciendo ya no tendría que cometer ciertos errores tan obvios. -
Muchas gracias y hasta la próxima. -

Daniel.
abraza las cosas y personas malas como si fueran tu mas preciada joya,Son tus mas grandes maestros de paciencia sabiduría y amor y cuando lo abrazas dejan de causar dolor.-

Desconectado colotron

  • PIC12
  • **
  • Mensajes: 55
    • Canal de YouTube
Re:Estructuras anidadas en lenguaje C.
« Respuesta #6 en: 09 de Febrero de 2017, 22:00:15 »
Hola  colotron.
Un gustazo leerte, si me concentrara un poco más en lo que estoy haciendo ya no tendría que cometer ciertos errores tan obvios. -
Muchas gracias y hasta la próxima. -

Daniel.

Psssss... yo ni concentrándome, a veces me sigo sorprendiendo de la cantidad de errores que cometo por línea al 1er intento, pero bueno, no soy ningún super-experto en C tampoco.
Para eso están los foros :)


 

anything