Estructuras Y Punteros

Estructuras y punteros

Estructuras

Las estructuras son un conjunto de datos agrupados que forman una entidad lógica. También se dice que son una agrupación de variables bajo un mismo nombre (o que se referencia bajo un mismo nombre). El formato general es el siguiente:

struct tipo_estructura

{

tipo nombre_var;

...

tipo nombre_var;

}

variable_estructura;

Definiendo una estructura llamada fecha.

struct fecha

{

int dia; /* Elementos de la estructura */

int mes;

int a;

}

d; /* Nombre de la variable */

/* fecha es el nombre de la estructura */

Formato Descripción

struct fecha {...}; Se define el nombre de la estructura fecha y la descripción,

pero no se ha definido ninguna variable.

struct {....} j; No se le ha dado nombre a la estructura, pero si se ha definido

una variable j la cual tiene una descripción que está definida

entre { y }.

struct X s; Se declara una variable llamada s, cuya definición del

contenido es X. (El que fue o debe ser previamente definido).

struct X a,b,c; Se declaran 3 variables, todas con la estructura X.

Otras formas de definir una estructura.

Se pueden realizar operaciones con los miembros de las estructuras y no con la estructura en su conjunto. La única operación que se puede hacer es & (cálculo de dirección). Al aplicárselo a la estructura devuelve la dirección del primer byte (octeto) que ocupa la estructura. Para referenciar los elementos individuales de la estructura, se usa el operador punto (.).

variable_estructura.nombre_elemento

Accesando los elementos de una estructura.

#include <string.h>

void main()

{

struct direccion{

char calle[25];

int numero;

char nombre[30];

} d;

strcpy(d.calle,"Avd. Alemania");

d.numero=2010;

strcpy(d.nombre,"Fulano");

}

Se pueden realizar operaciones si los elementos son de tipo numérico.

void main()

{

struct complex { float x; float y;} x;

float modulo;

x.x=0.5;

x.y=10.0;

modulo=sqr(x.x*x.x+x.y*x.y);

}

En el caso de ser requerido pueden definirse matrices o arrays, es decir:

struct direccion dir[100];

Para acceder a ella se puede hacer de la siguiente forma:

dir[1].numero= 1002;

Punteros a estructuras

Si se desea acceder a un miembro concreto de la estructura debe utilizarse un puntero de dirección. El formato para acceder es el siguiente:

nombre_puntero->nombre_elemento

Declaración de un puntero a estructura.

struct direccion{

char calle[25];

int numero;

char nombre[30];

}

d;

void main()

{

struct direccion *p; /* puntero a estructura */

.....

}

/* En este caso no hay ninguna variable definida */

Forma de acceder a una estructura mediante un puntero.

#include<string.h>

struct direccion {

char calle[25];

int numero;

char nombre[30];

};

void main()

{

struct direccion d, *p; /* se declara d */

p=&d; /* p contiene la direccion del primer byte de d */

strcpy(p->calle,"Avd. Alemania");

p->numero=2010;

strcpy(p->nombre,"Fulano");

.....

}

Estructuras de bits

El lenguaje C permite manipular y definir campos de longitud inferior a un byte. O sea, permite acceder a un bits individual dentro de un byte.

Si el almacenamiento es limitado (RAM), se pueden definir y almacenar varias variables booleanas dentro de un byte. Algunos periféricos devuelven la información codificada dentro de un byte. La forma general de definir estos campos de bits es:

struct nombre_estructura {

tipo nombre1: longitud;

tipo nombre2: longitud;

tipo nombre3: longitud;

...

}

Los campos de bits, cuando son más de uno, tienen que declararse como int, signed o unsigned. Si los campos de bits son de longitud uno, debe declararse como unsigned.

Definición de una variable en la que se especifican los campos de bits.

#include<stdio.h>

void main()

{

struct uart_reg {

unsigned cardis:1;

unsigned overrun:1;

unsigned errorpar:1;

} uart_st;

if(uart_st.cardis)printf("Llegó dato..!");

}

El conjunto de estos bits se trata como palabra de microprocesador. Si es IBM PC es de 16 bits. La estructura anterior se extiende a 16 bits, rellenándose por la izquierda.

Las Uniones

En C una union es una posición de memoria que es utilizada por diferentes variables, la cuales pueden tener diferente tipo. La definición de una union en código es similar a una estructura.

union tipo_union{

int i;

char c;

} u;

Cuando se declara una unión el compilador crea automáticamente una variable suficientemente grande para guardar el tipo más grande de variable de la unión. Para acceder a las uniones se utiliza la misma sintaxis que se utiliza para las estructuras.

u.i=120;

Otro formato puede ser el siguiente:

union{ /* U: nombre de la union */

int i; /* Puede considerarse como un

...