Estructuras, unidad 8

INTRODUCCIÓN

Las estructuras (struct) son agrupaciones de una o más variables de tipos posiblemente diferentes, agrupadas bajo un solo nombre, que permite un manejo más cómodo de la agrupación de la información. Las struct son estructuras de datos similares a los registros (record) de Pascal. 

Una estructura es un tipo de dato compuesto que permite almacenar un conjunto de datos de diferente tipo. Los datos que contiene una estructura pueden ser de tipo simple (caracteres, números enteros o de coma flotante etc.) o a su vez de tipo compuesto (vectores, estructuras, listas, etc.). 

A cada uno de los datos o elementos almacenados dentro de una estructura se les denomina miembros de esa estructura y éstos pertenecerán a un tipo de dato determinado.

DEFINICIÓN DE ESTRUCTURAS

Se dispone de una forma de definir variables de esos grupos básicos, y los mecanismos de  acceso a las componentes: el discriminador del campo (un punto) para las estructuras; y los paréntesis cuadrados o corchetes para delimitar el índice de la componente del arreglo. Las operaciones que están definidas para estos grupos básicos son muy reducidas, el programador debe crear sus propias funciones o métodos para efectuar operaciones más complejas sobre estos grupos básicos. En el caso de strings existe una biblioteca estándar de funciones que los manipulan.

struct:  es una palabra reservada de C que indica que los elementos que vienen agrupados a continuación entre llaves componen una estructura.

nombre_estructura: identifica el tipo de dato que se describe y del cual se podrán declarar variables. Se especifica entre corchetes para indicar su opcionalidad.

miembro1, miembro2,...: Son los elementos que componen la estructura de datos, deben ser precedidos por el tipo_dato al cual pertenecen.

 

 Recordemos que una estructura define un tipo de dato, no una variable, lo que significa que no existe reserva de memoria cuando el compilador está analizando la estructura. Posteriormente habrá que declarar variables del tipo definido por la estructura para poder almacenar y manipular datos.
 
 La declaración de variables de un determinado tipo de estructura de datos se puede realizar de dos modos:
 Primera: Incluir en la propia definición de la estructura aquellas variables que se van a emplear en el programa. Esta declaración de variables  implica que el ámbito en el que éstas son reconocidas será el mismo que el de la declaración del tipo de dato estructura.

Ejemplo: estructura de una tarjeta bancaria, utilizando esta primera forma:
 

struct  {

long_int  num_tarjeta;

char tipo_cuenta;

char nombre [80];

float  saldo;

} cliente1, cliente2;

 
 

Segunda: Definir el tipo de dato estructura con un nombre determinado y declarar posteriormente las variables de ese tipo de dato. Para ello la estructura se identificará con un nombre de forma obligatoria. 

Ejemplo: estructura de una tarjeta bancaria, utilizando la segunda forma:
 

struct  {

long_int  num_tarjeta;

char tipo_cuenta;

char nombre [80];

float  saldo;

}

struct  tarjetas cli1, cli2;

INICIALIZACIÓN DE ESTRUCTURAS

Las estructuras, al igual que las matrices, almacenan sus miembros de forma contigua, razón por la cual, como veremos más adelante, se les pueden aplicar punteros y una cierta aritmética. Por la misma razón, se pueden crear matrices de estructuras e incluso estructuras de matrices (sus miembros son matrices). Conceptualmente, estas últimas no se diferencian gran cosa de las matrices de matrices (a no ser en la notación de acceso a sus miembros). También se puede calcular su tamaño en bytes con la expresión sizeof, aunque a este respecto debe tenerse en cuenta algunas posibles discrepancias respecto a los valores "teóricos", debidas a las alineaciones internas realizadas por el compilador

Se ha señalado que, al igual que las matrices, las estructuras pueden iniciarse, incluso en el mismo punto de su declaración, con una lista de iniciadores entre corchetes { } separados por comas [1], uno para cada miembro de la estructura. Por ejemplo, la sentencia:

struct Cliente {int i; char str[20]; double d;} s = {33, "Pepe Lopez", 3.14 };

declara una estructura Cliente compuesta por un entero; un array de 20 caracteres, y un doble.También inicia una estructura s como perteneciente al tipo Cliente con valores concretos en cada campo.

En estructuras o uniones con duración automática, el iniciador debe ser alguno de los siguientes:

·         Una lista de inicializadores constantes (también se permiten expresiones con sizeof) Ejemplo:

struct punto {int x; int y;} p1 = {1, 2};

·         Una sola expresión con una estructura de tipo compatible.  En este caso, el valor inicial del objeto es el de la expresión.  Ejemplo:

struct punto p2 = p1;

En este caso, (suponiendo los valores anteriores) sería: p2.x == 1 y p2.y == 2

Los miembros complejos de listas de iniciadores. Por ejemplo matrices, pueden inicializarse con expresiones adecuadas incluidas en bloques de corchetes anidados. Por ejemplo:

struct Pesadas {

   int tiket;

   int pesos[5];

} s = { 150, {10, 45, 0, 78, 20}};

Si la lista de inicializadores contenidos entre los corchetes { } es menor que los miembros de la estructura, el resto de los miembros es inicializado implícitamente siguiendo las mismas reglas que los objetos con duración estática.

UTILIZACIÓN DE ESTRUCTURAS CON FUNCIONES

Es posible pasar estructuras a las funciones como argumentos. En el siguiente ejemplo usaremos funciones, para ello escribiremos dos nuevas funciones, una de ellas leerá del teclado la información sobre un nuevo trabajador y la otra visualizará en pantalla la información de un trabajador.

#include<stedio.h>

#define LONGITUD 30

Struct trabajadores

{

    Char nombre [LONGITUD];

    Int num:

};

/****

La función nuevo_nombre lee la información de un nuevo trabajador y la función visualizar_datos visualiza la información de un trabajador

****/

Struct trabajadores nuevos_nombre(void) ;

Void visualizar_datos (struct trabajadores currela) ;

Void main(void main)

{

             Struct trabajadores tra_1;

             Struct trabajadores tra_2;

           Tra_1 = nuevo_nombre()

           Tra_2 = nuevo_nombre()

          Printf(“LISTA DE AGENTES SECRETOS :\n");”

          Visualizar_datos (tra_1);

          Visualizar_datos (tra_1);

}

/*

Como se puede apreciar esta función devuelve una estructura tipo trabajadores donde se almacena la información necesaria sobre cada trabajador, utilizando para ella la sentencia return.

*/

Struct trabajadores nuevo_nombre(void)

{

       Struct trabajadores currela;

       printf("\nDatos del agente.\introduce el nombre:");

       gets(currela.nombre) ;

      printf (“introduce el numero:");

     scantf (“%d”,& currela.num);

     fflush (stdin);

     return (currela);

}

Void visualizar_datos (struct trabajadores currela)

{

     Printf (“\n\n Agente secreto \n”);

     Printf (“\t nombre : %s \n” currela.nombre);

     Printf (“\t numero del agente %d\n”,currela.num);

}

CONCLUSIÓN

Cuando compilamos este programa el compilador puede dar un mensaje diciendo que la función visualizar_datos toma la estructura como valor y no como dirección, de seguro mucho de nosotros tenemos en mente la solución medante la utilización de punteros 

Prácticas Unidad 7

Cadenas, Unidad 7

INTRODUCCIÓN

En C, una cadena es un arreglo de caracteres, los cuales terminan con el carácter nulo ('\0'). Se accede a una cadena mediante un apuntador a su primer carácter. El valor de una cadena es la dirección del primer carácter. Así, en C, es apropiado decir que una cadena es un apuntador, de hecho, un apuntador al primer carácter de la cadena. En este sentido, las cadenas son como arreglos, debido a que un arreglo también es un apuntador al primer elemento.

Aunque C no incorpora en su definición operadores para el manejo de cadenas de caracteres, todo compilador de C proporciona una librera estándar (string.h) con funciones para facilitar su utilización.

Una cadena de caracteres se puede definir como una secuencia o un vector de caracteres, que están agrupados por un mismo nombre. Existen varias formas de manipular las cadenas de caracteres, por que vamos a definir primeramente el tipo de datos char, lo cual nos va a permitir comprender el resto de los tipos.

FUNDAMENTOS DE CADENAS Y CARACTERES

En el lenguaje C, una cadena de caracteres se representa con una matriz de caracteres. El valor de una cadena de caracteres se escribe entre comillas dobles, por ejemplo: “Hola”, que representa la siguiente cadena de caracteres: ‘H’ ‘o’ ‘l’ ‘a’ ‘\0’.

Por convención, todas las cadenas de caracteres en C finalizan con el carácter nulo (‘\0’). Este carácter indica el fin de una cadena de caracteres. Si la matriz no incluye este carácter al final no se considerará como una cadena de caracteres, sino como una simple matriz de caracteres.

La longitud de la cadena “Hola” es igual a 4 caracteres (no se incluye el carácter nulo), sin embargo la cadena ocupa en memoria el espacio de 5caracteres.

Los caracteres son bloques de construcción fundamentales para los programas fuente. Un programa puede contener constantes de carácter. Una constante de carácter es un valor int representado por un carácter entre comillas sencillas. El valor de una constante de carácter es el valor entero del carácter en el conjunto de caracteres de la máquina.

Por ejemplo, 'z' representa el valor entero de z, y '\n' representa el valor entero de una nueva línea.

Una cadena es un conjunto de caracteres tratados como una sola unidad. Una cadena puede incluir letras, dígitos y varios caracteres especiales como +, -, *, y $. En C, las literales de cadena, o constantes de cadena, se escriben dentro de comillas dobles de la siguiente manera:“Juan P. Pérez” (un nombre) “99999 de Eje Central” (la dirección de una calle).

Un arreglo de caracteres o una variable de tipo char * puede inicializarse con una cadena en la definición. Las definiciones

char color[] = “azul”;

const char *ptrColor = “azul”; inicializan una variable con la cadena “azul”. La primera definición crea un arreglo de 5 elementos, color, que contiene los caracteres 'a', 'z', 'u', 'l' y '\0'. La segunda variable crea una variable apuntador, ptrColor, que apunta a la cadena

“azul” en algún lugar de la memoria.

La definición del arreglo anterior también podría escribirse como char color[] = {'a', 'z', 'u', 'l', '\0'};

Cuando se define un arreglo para que contenga una cadena, éste debe ser lo suficiente grande para almacenar la cadena y su carácter de terminación nulo. La definición anterior determina automáticamente el tamaño del arreglo, basándose en el número de inicializaciones de la lista de inicialización ('a', 'z', 'u', 'l', '\0').

No almacenar suficiente espacio en un arreglo de caracteres para almacenar el carácter nulo que termina una cadena, es un error.

Si una cadena es más grande que el arreglo de caracteres en el cual se va a almacenar, los caracteres más allá del final del arreglo sobrescribirán los datos siguientes en la memoria del arreglo.

Una cadena puede almacenarse en un arreglo, por medio de scanf. Por ejemplo, la siguiente instrucción almacena el arreglo de caracteres palabra[20]: scanf( “%s”, palabra );

La cadena que introduce el usuario se almacena en palabra. Observe que palabra es un arreglo, el cual es, por supuesto, un apuntador, de modo que no necesitamos un & con el argumento palabra. La función scanf leerá caracteres hasta encontrar un espacio, un tabulador, un indicador de nueva línea o de fin de archivo. Observe que la cadena no debe ser mayor que 19 caracteres para dejar espacio suficiente para el carácter de terminación nulo. Para un arreglo de caracteres que se imprimirá como una cadena, el arreglo debe contener el carácter de terminación nulo.

La cadena de caracteres está definida como un arreglo de caracteres, debido a que el nombre de un arreglo es la dirección de memoria del primer elemento del arreglo, por lo que si se iguala el nombre del arreglo al nombre de un puntero, a este puntero se le puede aplicar aritmética de punteros (ver apunte Punteros) para poder desplazarse entre los datos del arreglo.

FUNCIONES DE MANEJO DE CADENAS Y CARACTERES

Todas las funciones para manejo de cadenas tienen su prototipo en:

#include <string.h>

Las funciones más comunes son descritas a continuación:

∞char *strcpy(const char *dest, const char *orig) -- Copia la cadena de caracteres apuntada por orig (incluyendo el carácter terminador '\0') al vector apuntado por dest. Las cadenas no deben solaparse, y la de destino, debe ser suficientemente grande como para alojar la copia.

∞int strcmp(const char *s1, const char *s2) -- Compara las dos cadenas de caracteres s1 ys2. Devuelve un entero menor, igual o mayor que cero si se encuentra que s1 es, respectivamente, menor que, igual a, o mayor que s2.

∞char *strerror(int errnum) -- Devuelve un mensaje de error que corresponde a un número de error.

∞int strlen(const char *s) -- Calcula la longitud de la cadena de caracteres.

∞char *strncat(char *s1, const char *s2, size_t n) -- Agrega n caracteres de s2 a s1.

∞int strncmp(const char *s1, char *s2, size_t n) -- Compara los primeros n caracteres de dos cadenas.

∞char *strncpy(const char *s1, const char *s2, size_t n) -- Copia los primeros n caracteres de s2 a s1.

∞strcasecmp(const char *s1, const char *s2) -- versión que ignora si son mayúsculas o minúsculas de strcmp().

∞strncasecmp(const char *s1, const char *s2, size_t n) -- versión insensible a mayúsculas o minúsculas de strncmp() que compara los primeros n caracteres de s1.

El uso de muchas funciones es directo, por ejemplo:

char *s1 = "Hola";

char *s2;

int longitud;

longitud = strlen("Hola");    /* long = 4 */

(void) strcpy(s2,s1);

Observar que tanto strcat() y strcopy() regresan una copia de su primer argumento, el cual es el arreglo destino. Observar también que orden de los argumentos es arreglo destino seguido por arreglo fuente lo cual a veces es una situación para hacerlo incorrectamente.

La función strcmp() compara lexicográficamente las dos cadenas y regresa:

∞Menor que cero -- si s1 es léxicamente menor que s2;

∞Cero -- si s1 y s2 son léxicamente iguales;

∞Mayor que cero -- si s1 es léxicamente mayor que s2;

Las funciones de copiado strncat(), strncmp() y strncpy() son versiones más restringidas que sus contrapartes más generales. Realizan una tarea similar, pero solamente para los primeros n caracteres. Observar que el caracter de terminación NULL podría ser violado cuando se usa estas funciones, por ejemplo:

char *s1 = "Hola";

char *s2 = 2;

int longitud = 2;

(void) strncpy(s2, s1, longitud); /* s2 = "Ho" */

donde s2 no tiene el terminador NULL.

CONCLUSIÓN

Las cadenas de caracteres son un tipo particular de vectores, son de hecho vectores de char, con la particularidad que tienen una marca de fin, además el lenguaje nos permite escribirlas como texto dentro de comillas dobles. 

Práctica 1 - Unidad 6