UC3M

¿Qué tamaño en bytes ocupa una variable de tipo struct informacion_celda en memoria?

Las siguientes dos líneas declaran dos variables. ¿Cuál de ellas ocupa más espacio en memoria?

struct informacion_celda a;
struct informacion_celda *b;

¿Qué tamaño tienen las siguientes variables?

struct informacion_celda *ptr1, *ptr2;
struct informacion_operador *i1, *i2;

Si una variable de tipo struct informacion_celda está almacenada en la posición de memoria 100, ¿qué dirección tienen cada uno de sus campos?

Si una variable de tipo struct informacion_celda * está almacenada en la posición de memoria 100, ¿qué dirección tiene cada uno de sus campos?

¿Qué cambios debes hacer en las definiciones de la parte izquierda para que sean equivalentes a las descripciones de la parte derecha?

struct informacion_celda c;
struct informacion_celda **c_ptr;

// variable de tipo estructura informacion_celda
// puntero a estructura informacion_celda;

¿Se pueden hacer las siguientes asignaciones? ¿Qué declara exactamente la linea 3?

1
2
3
4

struct informacion_celda c;
struct informacion_celda *c_ptr = &c;
struct informacion_celda d;
struct informacion_celda *d_ptr = c_ptr;

Considera la siguiente declaración y asignación:

1
2
3
4

struct informacion_celda c;
struct informacion_celda *c_ptr;

c_ptr = *c;

¿Es correcta? Y si lo es, ¿Qué contiene la variable c_ptr (no se pregunta por lo que apunta, sino su contenido)?

Si se declara una variable como “struct informacion_celda c;”, ¿qué tipo de datos es el que devuelve la expresión “&c.ptr_operador”?

Dado el siguiente código:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

struct pack3 
{ 
    int a;
};
struct pack2 
{
    int b;
    struct pack3 *next;
};
struct pack1 
{
    int c;
    struct pack2 *next;
};

struct pack1 data1, *data_ptr;
struct pack2 data2;
struct pack3 data3;

data1.c = 30;
data2.b = 20;
data3.a = 10;
dataPtr = &data1;
data1.next = &data2;
data2.next = &data3;

Decide si las siguientes expresiones son correctas y en caso de que lo sean escribe a que datos se acceden.

Supongamos que se escriben las siguientes declaraciones y asignaciones en un programa:

1
2
3
4

info_celda c;
info_celda_ptr c_ptr = &c;
info_operador op;
info_operador_ptr op_ptr = &op;

La estructura “c” contiene el campo “ptr_operador” precisamente para almacenar la información relativa al operador. ¿Qué expresión hay que usar en el código para guardar la información del operador “op” como parte de la estructura “c”? Teniendo en cuenta los valores que se asignan en las declaraciones, escribe cuatro versiones equivalentes de esta expresión (utiliza “c”, “c_ptr”, “op” y “op_ptr”).

Supón ahora que la aplicación en la que se usan estas estructuras necesita almacenar la información para un máximo de 10 celdas. ¿Qué estructura de datos definirías?

Escribe un bucle con la variable declarada en el ejercicio anterior que asigne al campo ptr_operador el valor vacío.

La información sobre las celdas que se almacena en la estructura del ejercicio anterior la debe utilizar la aplicación para recordar cuál de ellas es la más próxima. Esta información puede cambiar a lo largo del tiempo. ¿Qué tipo de datos sugieres para almacenar esta información? Ofrece dos alternativas.

Se dispone de una estructura de tipo “info_celda c” que a su vez, en el campo “ptr_operador” tiene un puntero a una estructura “info_operador cr”. ¿Qué tamaño tiene la estructura “c”? ¿Qué tamaño total ocupa la información incluyendo la información sobre el operador?

Escribe el cuerpo de la siguiente función:

void fill_in(info_celda_ptr dato, unsigned int id, float sq, info_operador_ptr op_ptr)

que asigna el valor de los parámetros “id”, “sq” y “op_ptr” a los campos “identificador”, “calidad_senal” y “ptr_operador” respectivamente de la estructura apuntada por el parámetro “dato”.

¿Cómo explicas que esta función asigne valores a unos campos y no devuelva resultado?

Considera las dos versiones del siguiente programa:

#include <stdio.h>
struct package 
{ 
    int q; 
};

void set_value(struct package data, int value) 
{
    data.q = value;
}

int main() 
{
    struct package p;
    p.q = 10;
    set_value(p, 20);
    printf("Value = %d\n", p.q);
    return 0;
}

#include <stdio.h>
struct package 
{ 
    int q; 
};

void set_value(struct package *d_ptr, int value) 
{
    d_ptr->q = value;
}

int main() 
{
    struct package p;
    p.q = 10;
    set_value(&p, 20);
    printf("Value = %d\n", p.q);
    return 0;
}

La versión 1 del programa imprime el valor 10 por pantalla, y la versión 2 imprime el valor 20. Explica por qué.

¿Qué cantidad de memoria ocupan estas dos estructuras? ¿Cuál es su diferencia?

info_celda t[SIZE];
cell_info *t[SIZE];

Una aplicación de gestión de fotografías en tu móvil tiene definido el catálogo de fotos de la siguiente forma:

#define SIZE_NAME
      
struct picture_info 
{
    char name[SIZE_NAME];
    int date_time;
} pictures[SIZE];

¿Qué tamaño tiene esta estructura de datos? La aplicación necesita crear una segunda tabla del mismo número de elementos, pero en lugar de tener los datos de las fotos quiere tener los punteros a los datos de las fotos. En otras palabras, es una tabla con idéntico número de elementos que la anterior, pero sus elementos no son estructuras sino punteros a las correspondientes estructuras de la tabla pictures. Escribe la declaración y el código para rellenar esa tabla.

Se dispone de la siguiente definición de datos:

#define SIZE 4
struct coordinates 
{
    int latitude;
    int longitude;
} places[SIZE];

places[0].latitude  = 200;
places[0].longitude = 300;
places[1].latitude  = 400;
places[1].longitude = 100;
places[2].latitude  = 100;
places[2].longitude = 400;
places[3].latitude  = 300;
places[3].longitude = 200;

La tabla almacena cuatro puntos obtenidos del GPS de tu móvil, cada uno de ellos con su latitud y longitud que son números enteros. Hay una aplicación que ha obtenido estos puntos en este orden, pero necesita acceder a los datos de tres formas distintas. La primera es en el orden en que han sido obtenidos, y por tanto, tal y como está la tabla. El segundo es ordenados crecientemente por latitud y el tercero ordenados crecientemente por longitud. El acceso a estos datos en base a estos tres órdenes es continuo. Una primera solución podría ser reordenar los elementos de la tabla cada vez que se cambia de orden (por ejemplo, llega una petición de datos ordenados por latitud, pero la anterior se ordenaron por longitud, y entonces se reordena la tabla). Pero es extremadamente ineficiente. ¿Por qué? ¿Crees que utilizando punteros puedes ofrecer una alternativa más eficiente que evite reordenar los datos continuamente?