Foro de elhacker.net

¿Cuál es el método utilizado en C para el ingreso de una estructura de datos? Me refiero a que si se deben leer las variables de la estructura por apartey luego asignarlas a los miembros de la esctructura... o bien, si se deben asignar directamente a cada miembro de la esctructura luego de un scanf().

no entiendo bien la pregunta pero bueno te pongo un ejemplo de uso de estrocturas en c que tenía por ahí tirado

#include <stdio.h>
 
 
struct Ficha {
 
	char Nombre[80];
	int  Num_unidades;
	int Precio_unidad;
	int Estado;   // 0 = moroso; 1 = atrasado; 2 = pagado
};
 
 
typedef struct Ficha Fichas;
 
 
int main(int argc, char** argv)
{
	Fichas Cliente[100];
	int i;
	char nombre[80];
 
	for (i = 0; i < 99; i++)
	{
		if (nombre == Cliente[i].Nombre)
		{
			printf ("%s", Cliente[i].Nombre);
			printf ("%i", Cliente[i].Num_unidades);
			printf ("%i", Cliente[i].Precio_unidad);
			switch  (Cliente[i].Estado) 
			{
				case 0 : printf ("Moroso");
						  break;
				case 1 : printf ("Atrasado");
						  break;					
				case 2 : printf ("Pagado");
						  break;
			};	
	    }	
	}
 
 
	return 0;
}
 
 
 
 
 

Saludos!!

Me refiero a las asignaciones:

//Suponemos la esctructura
struct Ficha {
 
	char Nombre[80];
	int  Num_unidades;
	int Precio_unidad;
	int Estado;   // 0 = moroso; 1 = atrasado; 2 = pagado
};
...
//Es esta la forma de asignacion?
int num, int pre;
Ficha F;
scanf("%d",&num);
scanf("%d",&pre);
F.Num_Unidades = num;
F.Precio_Unidad = pre;
...
/* O lo correcto seria que en el scanf haga una asignación directa?*/
 

seee.. lo podes hacer tanto así como directamente en el scanf

 
scanf ("%d" &f.numero);
 
 

o si nosotros pasamos por referencia el struct se haria

 
void ejemplo ( struct nom_del_struct *p )
 
scanf ("%d" &p->numero);
 
 

osea se utilaza  "->" en vez de de "."

saludos!!

Weno como no son clases... ni POO lo puedes hacer directamente... pero en la POO no es recomendable... Tu sabes para que no aya acceso directo con los miembros privados...

Saludos...

EDITO: aya xD!! va con 'h'... sorry

Exacto a eso último me refería.

OFFTOPIC : Para que no hallan creo que es lo correcto  :xD

Para acceder o asignar a una variable normal dentro de una estructura:

estructura.elemento;
 

Para acceder o asignar a un puntero, dentro de una estructura:

estructura->puntero;

También te recomiendo declarar las estructuras como typedef:

typedef struct Nodo
{
     elementos...
};
 

Gracias por la aclaración, pero no me refería a eso.

Miren el siguiente code:

#include <stdlib.h>
#include <string.h>
 
#define MAX_LIMIT 50
 
struct Persona{
  char *nom, *dom, *tel;
  int edad;  
};
 
typedef struct Persona stPersona;
 
void _ingreso(stPersona *);
void _imprimir(stPersona *);
 
int main()
{
  stPersona *User;
  //Aqui creo que deberia reservar el espacio para User
  _ingreso(User);
  _imprimir(User);
 
  return 0;
}
 
void _ingreso(stPersona *stP)
{
  char *nom;
  nom = (char *)(malloc((MAX_LIMIT)*sizeof(char)));
  stP = (stPersona *)(malloc(sizeof(stPersona)));
  stP->nom = (char *)(malloc((MAX_LIMIT)*sizeof(char)));
  fgets(nom,MAX_LIMIT,stdin);
  strcpy(stP->nom,nom);
}
 
void _imprimir(stPersona *stP)
{
  puts("------SALIDA------");
  puts(stP->nom);
}

¿Por qué se produce un error de segmentación en la salida?

EDITADO : Si reservo espacio para User, y luego utilizo printf("%s") la salida es (null).

Es que reservas memoria utilizando el puntero stP pero dicho puntero deja de existir cuando termina el contexto de la función. User no apunta al contenido adecuado cuando se lo pasas a _imprimir y ademas cuando sales de _ingresar pierdes la referencia para liberar la memoria que reservaste.

Saludos.

PD: Necesitas incluir stdio.h para stdin.

Disculpas por el stdio.h olvidé copiarlo

Ahora bien, no me queda otra opción que la siguiente?

int main()
{
  stPersona *User;  
  User = (stPersona *)(malloc(sizeof(stPersona)));
  User->nom = (char *)(malloc(sizeof(char) * MAX_LIMIT));
 
  _ingreso(User);
  printf("%s\n",User->nom);
 
  return 0;
}
 
void _ingreso(stPersona *P)
{
  puts("Ingrese nombre>");
  fgets(P->nom,MAX_LIMIT,stdin);
}

Lo que quedaría destacar es que para manipular estructuras(en realidad en todos los casos creo), hay que reservar la memoria antes de llamar a una función(procedimiento en este caso)?

Se me ocurrió lo siguiente para no estar reservando memoria a cada instante:

int main(){
  st_p *user;
 
  data_reserve(&user);
  data_input(user);
 
  printf("Nombre : %s", user->name);
}
 
void data_reserve(st_p **P){
  (*P) = (st_p *)(malloc(sizeof(st_p)));
  (*P)->name = (char *)(malloc(sizeof(char) * LIMIT));
  (*P)->dir = (char *)(malloc(sizeof(char) * LIMIT));
  (*P)->phone = (char *)(malloc(sizeof(char) * LIMIT));
}
 
void data_input(st_p *P){
  puts("Ingrese nombre");
  fgets(P->name, LIMIT, stdin);
}

No hay una regla estricta para lo que quieres hacer ya que depende de la organización del programa, de su objetivo y de los datos que vayas a manejar.

Es decir, si la pregunta viene por el lado de "Que me conviene hacer" te puedo responder, pero si lo que estas preguntando es "Que opciones tengo" la respuesta es que solo lo que tus conocimientos y tu imaginación te permitan.
Uno de los grandes atributos de la memoria dinámica y los punteros es la flexibilidad y la versatilidad por lo tanto ten por seguro que tendrás muchas opciones dependiendo como encares la situación.

Para que te des una idea, una función podría devolver la referencia de la estructura manipulada -stPersona * func(params)- y dicha referencia la puedes recibir con un puntero en main. Las posibilidades utilizando los elementos mencionados son interminables.

Saludos

Advertencia - mientras estabas escribiendo, una nueva respuesta fue publicada. Probablemente desees revisar tu mensaje.

No hagas doble post por favor, usa el botón modificar.

Edit:
No leí el código atentamente pero la idea se ve a simple vista. Efectivamente, suele ser una buena practica hacer una función que se encargue de la reserva de memoria de determinado tipo de estructura, en pos que los cambios sean mas fáciles de realizar en caso que los elementos de la estructura cambien en el futuro.

Gracias littlehorse. Sobre las recomendaciones, sólo necesito opiniones, porque aveces hay estándares los cuales permiten un mejor entendimiento del programa. Ahora bien, por ejemplo me gustaría ver algunos sources de grandes programas, para ver su organización y demás.

Conoces algún libro que trate sobre practicas sanas en C/C++? Aparte de las que estoy leyendo del libro de deitel&deitel?

EDIT: Existe alguna forma para saber si una puntero fue liberado correctamente con free()?
EDIT2: Creo que la forma sería que si utilizo el free(), entonces la información en mi puntero quedará en NULL.
EDIT3: En el caso que quiera manipular una gran cantidad de usuarios, en vez de un array de estructuras lo correcto sería utilizar una lista enlazada, verdad?

Lo ideal es inicializar los punteros, trabajar con ellos, y luego volver al valor inicial cuando no los necesites. Por supuesto esa es la forma mas fácil, pero también es la mas sencilla y mas efectiva en el común de los casos:

free(ptr);
ptr=NULL;
 

Entonces podrás comprobar fácilmente en cualquier contexto del programa si los punteros son validos o no.

dangling pointers C (http://www.google.com.ar/#hl=es&source=hp&q=dangling+pointers+C&aq=f&aqi=g10&aql=&oq=&gs_rfai=&fp=8a54748c72dc742d)
wild pointers C (http://www.google.com.ar/#hl=es&safe=off&q=wild+pointers+C&aq=&aqi=&aql=&oq=&gs_rfai=&fp=776e7a30c205b67)


Podría ser, depende como sea la estructura del programa. Lo importante es tener en cuenta que siempre que necesites insertar y/o borrar datos una lista va a tener mejor rendimiento que un arreglo -por mas que tengamos en contra las llamadas para reservar memoria-. Por el contrario el acceso es bastante mas rápido en un array.


La verdad en este momento no me acuerdo de ninguno. Ahora reviso a ver si encuentro algo en el HD externo.