Mi objetivo es crear un sistema básico que en una función, teniendo un limite, esté añadiendo contactos a una tabla.

La cosa es que no entiendo porqué no me funciona lo siguiente:

#include<stdio.h>
#define LIMITE 3
 
 
 
struct contactos {
 
  char telefono[10];
 
  char descripcion[51];
 
};
 
//Prototipos:
int almacenaContacto(struct contactos *f);
void leerContacto(struct contactos *f);
 
int main(){ //INICIO PROGRAMA
 
int variable;
 
struct contactos gente[LIMITE];
 
 
 
variable=almacenaContacto(&gente);
 
 
 
 
return 0;
 
} //FIN PROGRAMA
 
int almacenaContacto(struct contactos *f){
 
 
int i=0;
 
  while(i<LIMITE){
 
  leerContacto(&(*f)[i]);
 
  i=i+1;
 
  }
}
 
//Nota: la funcion leerContacto funciona correctamente: recibe un parámetro struct y me permite ir añadiendo contacto a contacto
 

La parte que empieza a dar problemas en el programa es la de "leerContacto(&(*f)[ i]);", es decir, que podria concluir diciendo que:

Tengo un programa principal y en el tengo un struct en el que quiero que vayan un determinado numero de elementos. Llamo a una funcion para que haga el bucle y vaya uno a uno, y a su vez, esta función llama a otra que se encarga individualmente de meter los datos en cada una. Mi error se encuentra justo aquí al final, que no se porqué, no consigo hacer referencia a cada parte en el bucle.

Alguna idea?

Un saludo

Quieres tener la estructura declarada en el main, pasarla a un función que ingrese datos a ella, y luego pasarla a otra función que lea los parámetros que le fueron ingresados.
Podes pasar el puntero directamente de la función 1 a la función 2.

Es decir, en main tenes algo como esto:

int main{
//random code
struct contacto gente[3];
 
AlgunaFuncion( &gente[x]);

void AlgunaFuncion ( struct contacto *ptr)
{
//random code
 
ptr->algo =  otracosa;
 
FuncionNumeroDos(ptr); 
}
 

FuncionNumeroDos ( struct contacto *ptr)  
{
//random code
printf("%s", ptr->algo);
 
}

También podrías pasar el arreglo de estructuras directamente, pero no se si es eso lo que estas buscando.
No se si te entendí del todo, cualquier cosa me avisas.

Saludos!

Bueno por lo pronto algunas cosas:

while(i<3){
 escribir(f);
 i=i+1;
}

Esto no se porque lo haces siendo que f siempre contiene el mismo elemento. Es decir, ese bucle no tiene sentido, estas asignando contenido siempre al mismo elemento, el cual es el que le pasaste desde main. En todo caso en el main es donde tendrías que hacer el bucle (pasarías un elemento a la función probar en cada vuelta), o le tendrías que pasar el array completo a la función probar y ahí si seria correcto de la forma en que lo tienes.

Entrando en el main, el elemento que le pasas esta fuera de los limites del array. Recuerda que el primer elemento de un array comienza en la posición 0 y termina en arraymax-1.

 struct contacto gente[3];
 probar(&gente[3]);

gente[0] , gente[1], gente[2]. Esas son las 3 posiciones que tenes actualmente.

Saludos!

void probar(struct contacto f[]) // *f 
{
int i=0;
 
while(i<3){
 escribir(&f[i]);
 i=i+1;
}
 
}
 

//llamada
probar(gente);

Saludos

En vista de tu código, supongo que estás aprendiendo C y no tienes del todo afianzados los conocimientos técnicos del lenguaje. Por eso, permíteme hacerte algunos comentarios que te pueden favorecer el aprendizaje.

Primer Punto: No debería ser un WHILE sino un FOR, puesto que sabes exáctamente cuántos lugares recorrer.

Segundo: En estos casos, mientras uses C, te convendría ser más explícito en la aritmética de punteros, y quizá menos en la lógica. Yo prefiero ese estilo de codificación porque es más explícito en lo que se está haciendo a nivel memoria. Me refiero a que si tu código es más técnico, lo comprenderás mejor. Cuando conozcas lo suficiente, elegirás cuál es tu manera de codificar favorita.

No he probado porque estoy en el trabajo, pero esto es lo que haría yo:

1 - SIEMPRE pasar el puntero, así sabemos exáctamente con qué trabajamos:

int almacenaContacto(struct contactos *f)

2 - Usar la aritmética de punteros. Cada suma de una unidad para un puntero es un desplazamiento equivalente a su tamaño. Es totalmente claro hacer algo así:

int almacenaContacto(struct contactos *f){
    int i;
    struct contactos *punt = f;
    /* punt contiene la misma direccion, por
     * lo tanto es equivalente, pero como es
     * local a la funcion, podemos moverlo
     */
    for(i=0; i<LIMITE; i++) {
        /* en cada vuelta tienes una llamada simple
         */
        leerContacto(punt);
        /* se mueve una vez el tamanno de
         * la estructura
         */
        punt++;
    }
}

Respecto a la notación que LittleHorse te indicaba, lo reescribiría de esta forma:

void probar(struct contacto f[]) {
    int i;
    for(i=0; i<3; i++){
        escribir(&f[i]);
    }
}

Y por favor, no utilices:

i=i+1

Esto no es PASCAL, aquí existe el operador de incremento:

i++

Saludos