[SOLUCIONADO] Problema con estructuras y punteros en C

[lmmontero]

Hola,

Tengo la siguiente estructura declarada en C:

Código C:

typedef struct              
{
    char *nombre;
    char *apellido;
    int edad;           
} persona;
 
persona empleado;
 

Tengo también una función que escribe en cada uno de los miembros de la estructura (de tipo char) el valor que se le pasa por parámetro:

Código C:

int setEmpleadoValue(char *nombre, string &cadena)
{
    nombre=(char*)malloc(cadena.size());
    strcpy(nombre,cadena.c_str()); 
    printf("%s\n",nombre);
    return 0;
}
 

Desde otra función, lo que hago es llamar a la funcion setEmpleadoValue para asignarle el valor correspondiente a cada uno de los miembros de la estructura empleado definida previamente:

Código C:

int rellenarEmpleado ()
{
   string text;
   obtenerTexto(text); //esta función asigna a texto el nombre del empleado en función de otros parametros
   setEmpleadoValue(persona[i].nombre,text);
   printf("%s\n", persona[i].nombre);
 

Al ejecutar el código printf(...) de la función setEmpleadoValue(), el nombre de la persona se imprime sin problemas. Pero al intentar ejecutar el código printf(...) de la función rellenarEmpleado(), me aparece un error en tiempo de ejecución.

Imagino que es algún problema con los punteros, pero no termino de ver cuál..

¿Podéis ayudarme? Espero haberme explicado correctamente.. Gracias de antemano

[eferion]

Si yo te pongo este ejemplo:

Código C:

#include <stdio.h>
 
void func( int dato )
{
  dato = 5;
}
 
int main( int, char**)
{
  int variable = 0;
  func( variable );
 
  printf( "%d", variable );
  return 0;
}
 

¿Qué se imprimirá por pantalla?

• Un número indeterminado
• 5
• 0

La respuesta correcta, espero que coincidas conmigo, es la tercera. El motivo es que "dato" es una copia local de "variable", por lo que cualquier cambio en "dato" no tendrá efecto en el valor de "variable".

Si trabajamos con punteros pasa algo parecido:

Código C:

#include <stdio.h>
 
void func( int* dato )
{
  dato = (int*)5; // Suponemos que '5' es una dirección de memoria válida
}
 
int main( int, char**)
{
  int* variable = 0;
  func( variable );
 
  printf( "%d", variable );
  return 0;
}
 

En este caso vemos que, efectivamente, el programa vuelve a devolver 0.

Espera, ¿no se supone que una de las gracias que tiene usar punteros es que podemos modificar los valores "a distancia"? Si, cierto, pero con un pequeño matiz:

"dato" es una variable local. Es un puntero, no lo niego, pero es una variable local. Al ser un puntero, si modificamos los valores almacenados en "dato" veremos que efectivamente también van a cambiar en "variable"... sin embargo, si cambiamos la dirección de memoria apuntada por "dato", estamos cambiando un valor local de "func", por lo que dicho cambio no se verá reflejado fuera de dicha función. No se si me explico.

Al final la cosa se soluciona añadiendo más punteros, tal y como se indica a continuación:

• Para modificar una variable normal desde una función, necesitamos un puntero
• Para modificar la posición de memoria a la que apunta un puntero desde una función, necesitamos un puntero doble
• Para modificar la posición de memoria a la que apunta un puntero doble desde una función, necesitamos un puntero triple
• ...

Es decir:

Código C:

#include <stdio.h>
 
void func( int** dato )
{
  *dato = (int*)5; // Suponemos que '5' es una dirección de memoria válida
}
 
int main( int, char**)
{
  int* variable = 0;
  func( &variable );
 
  printf( "%d", variable ); // Imprime 5, como pretendíamos
  return 0;
}
 

Un saludo

[lmmontero]

Hola eferion,

Perfecto, muy buena la explicación y todo aclarado. Me ha servido de gran auda.

Muchas gracias

[lmmontero]

Hola otra vez..

En el caso de utilizar estructuras anidadas y punteros, ¿cómo habría que pasar la variable por parámetro?

Siguiendo con el ejemplo de antes, suponemos que tenemos:

Código C:

typedef struct              
{
    char *dni;
    int edad;
} ninio;                    
 
typedef struct              
{
    char *nombre;
    char *apellido;
    int edad;           
    ninio *hijos;
} persona;  
 
persona empleado;
 

En este caso, a la hora de llamar a una función pasando como parametro el campo nombre de la estructura persona, lo haría tal y como me has explicado antes:

Código C:

void func(char **dato)
{
   ...
}
 
int main ()
{
   persona *empleado;
   func(&(empleado.nombre))
}
 

Pero en el caso de llamar a la función pasándole como parámetro el campo dni de la estructura ninio (que a su vez está definida dentro de la estructura persona), ¿cómo tendría que hacerlo? He probado a hacerlo así pero me aparece un error en tiempo de ejecución:

Código C:

int main ()
{
   persona *empleado;
   func(&(empleado.nombre.dni))
 
}
 

Gracias de nuevo!

[eferion]

Dado que "empleado" es un puntero, para acceder a sus miembros tienes utilizar el operador '->' en vez del operador '.':

Código C:

int main ()
{
   persona *empleado;
   func(&(empleado->nombre));
}
 

Otra posibilidad si la anterior, que es la más habitual y natural, no te gusta:

Código C:

int main ()
{
   persona *empleado;
   func(&(*empleado).nombre);
}
 

Para el otro caso:

Código C:

int main ()
    {
       persona *empleado;
       func(&(empleado.nombre.dni))
     
    }
 

Lamento decirte que "nombre" es de tipo "char*", es decir, no es una estructura y no tiene un miembro llamado "dni". Si revisas la definición de tu estructura, verás que "dni" se encuentra en la estructura "ninio", y el único campo de tipo "ninio" de la estructura "persona" se encuentra bajo el nombre "hijos", que además es un puntero.

Con todo esto la llamada quedaría así:

Código C:

int main ()
{
   persona *empleado;
   int x;
   func(&(empleado->hijos[x].dni));
}
 

Donde x debería tener un valor válido entre 0 y el número de elementos del arreglo "hijos"

[lmmontero]

Hola!!

Tienes toda la razón.. Al intentar simplificar mi código para poner el ejemplo, copié mal el mismo y puse persona.nombre en lugar de persona.hijos.

En cuanto a la solución al problema, de nuevo me ha sido de gran ayuda.

Muchas gracias!

[lmmontero]

Hola de nuevo,

He intentado probar la solución que me comentabas ayer, utilizando el operador '->' para acceder a los miembros del puntero, pero al utilizar la siguiente llamada:

Código C:

func(&(empleado->nombre));
 

me aparece este error:

error C2232: '->persona::nombre': el operando izquierdo tiene el tipo 'struct'; utilice '.'

Por tanto, imagino que estoy definiendo mal el puntero empleado.

Escribo la definición completa de empleado, por si hay algo mal aquí:

Código C:

typedef struct              
{
    char *dni;
    int edad;
} ninio;        
            
typedef struct              
{
    char *nombre;
    char *apellido;
    int edad;           
    ninio *hijos;
} persona;
 
int main ()
{
   persona *empleado;
   empleado=(persona*)malloc(num_empleados);   //num_empleados es un valor entero
 
   func(&(empleado->nombre));
}