Centrate en los temas de punteros y argumentos de funciones. En tu caso lo que quieres es enviar un puntero a tu agenda como argumento a la funcion que rellenará los datos
Código C:
Ver originalagenda datos;//tu agenda
agenda *ptr_datos = 0;//puntero nulo
ptr_datos = &datos;//puntero a datos
Sabiendo esto ya pudes imaginar el prototipo de tu funcion:
Solo queda implementar la funcion y la llamada a la funcion:
Código C:
Ver originalvoid entra_datos(agenda *ptr_datos) {
ptr->orden = 123;
}
int main() {
//declaras la estructura
agenda datos;
//envias un puntero a la funcion
entra_datos(&datos);
//volcado
escribir_datos(datos);
return 0;
}
Ok? Seguramente te habrá faltado algo de informacion sobre porque esto de los punteros, en los manuales que puedas leer estará mejor explicado que lo que te voy a comentar: cuando envias la estructura tal cual (sin referencia, es decir sin puntero) la funcion recibe una copia exacta de la estructura, es decir recibe una segunda estructura que por mucho que la modifiques no alterará la original. Puedes hacer la prueba:
Código C:
Ver originalvoid modifica(agenda datos_copia) {
//datos_copia es una copia exacta de 'agenda datos' que tienes en el main
datos_copia.orden = 999;
}
int main() {
agenda datos;
datos.orden = 1;
modifica(datos);
printf("%d", datos.
orden);//muestra 1
return 0;
}
En la funcion 'modifica' se recibe una copia de 'datos' donde originalmente orden=1, pero por mucho que machaque 'datos_copia.orden' nunca alterará el valor 'orden' de la estructura original. Esto se debe a que la copia no está en la misma direccion de memoria que la original ya que tal como el nombre indica es una nueva copia que se genera en cada llamada a la funcion.
Esto suele tenerse en cuenta en aplicaciones que necesitan ejecutar muy deprisa (p.ej. videojuegos), si se requiere enviar estructuras (o variables que no sean estructuras) muy grandes suele ser preferible enviar su puntero que solo pesa 4 bytes que forzar a que la aplicacion reserve memoria para una nueva copia de esa variable, la rellene, la use en la funcion y le vuelva a liberar al finalizar la funcion.
Para trabajar sobre la estructura original se envia una direccion de memoria de esa variable (o lo que sea), dicho de otra forma una referencia o un puntero. Cualquier modificacion sobre ese puntero efecta la variable original. Una simple prueba:
Código C:
Ver originalvoid modifica(agenda *datos_ptr) {
datos_ptr->orden = 999;
}
int main() {
agenda datos;
datos.orden = 1;
modifica(&datos);
printf("%d", datos.
orden);//muestra 999
return 0;
}
Tambien te habrás fijado en los modificadores '->' y los '&', indican que estas trabajando sobre el puntero. Todo esto puede explicarse mejor, pero bueno supongo que ahora ya ves por donde van los tiros, con cualquier manual puedes profundizar en el tema de punteros.
Una ultima cosa, no incluyas las librerias que no uses: windows y stdlib no las estas usando para nada.
Y aun otra ultima cosa: por ahi encontraras mil referencias a porque evitar la llamada system("pause"), puedes sustituirla por la funcion 'getchar()'.
Saludos
vosk