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?

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);
}

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)?

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).

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

Exacto a eso último me refería.

OFFTOPIC : Para que no hallan creo que es lo correcto 

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?*/
 

¿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().

En realidad debería buscar sobre métodos de ordenación en general 

Tal cual aclaró littlehorse... hay una diferencia entre IDE y compilador.