Curso de programación en C y C++ · Documento: Curso de programación en C y C++ Fecha: 28/07/2010...

Documento: Curso de programación en C y C++Fecha: 28/07/2010

ÍNDICE

Introducción

El lenguaje de programación C

Matrices y punteros

Estructuras (Registros)

¿Continuará?

1Autor: Pablo Cristóbal Vergara Castro Edición: 1/2

Esta obra está bajo una licencia Attribution-ShareAlike 3.0 Unported de Creative Commons. Para ver una copia de esta licencia, visite http://creativecommons.org/licenses/by-sa/3.0/ o envie una carta a Creative Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.


IntroducciónPrograma: Conjunto de instrucciones dadas a un ordenador para que realice una

determinada tarea.

Lenguaje de programación: Programa especializado en la traducción de uno o varios ficheros que contienen variedad de líneas escritas en un lenguaje usado por el programador (C, C++, Pascal, Basic, etc), a la única forma en la que la máquina es capaz de comprender todas las sentencias que se le requieren realizar: El lenguaje máquina. La traducción de un lenguaje al lenguaje máquina se suele realizar en dos pasos básicos. Compilación que realiza la conversión de un ficheros de texto (con las sentencias escritas en el lenguaje usado) a un fichero objeto (con las sentencias en código máquina) y enlazado (o lincado) que es la unión de varios ficheros objeto para crear un fichero ejecutable.

Algoritmo: Forma de expresar un programa sin relacionarlo directamente con ningún lenguaje de programación. Cuando se escribe un algoritmo se pretende expresar la idea de lo que debe hacer un programa sin tener que llegar a detallar como se escribiría en un lenguaje específico.

Pseudocódigo: Forma de expresar un algoritmo sobre papel y poder convertirlo a un determinado lenguaje de programación de forma fácil, ya que, la gran mayoría de los lenguajes de programación siguen la misma estructura de un pseudocódigo.

Estructura básica de un programa (control de flujo): Existen tres formas elementales de estructurar un programa, de tal forma que todos los programas se realizan únicamente aplicando dichas formas (o anidando unas dentro de otras), éstas son:

• Secuencia : Las instrucciones de un programa que sigan tal esquema de funcionamiento van seguidas las unas a las otras (primero una instrucción, después otra, después otra, ...).

• Condición : Cuando un programa se encuentra una sentencia condicional la ejecución de la siguiente instrucción depende de que la condición que se tiene que cumplir sea falsa o cierta.Existen dos tipos de estructuras condicionales, la condición simple (si...sino) en la que el programa ha de tomar la determinación de seguir un rumbo entre dos caminos y la condición múltiple (en caso de a)...b)...c)...) en la que la ejecución del programa podrá seguir más de dos caminos.

1 Capítulo: IntroducciónAutor: Pablo Cristóbal Vergara Castro Edición: 1/2



• Bucle (o ciclo): Un conjunto de secuencias que se encuentren dentro de una estructura de tipo bucle se repetirán tantas veces como sean necesario.Existen dos tipos de bucles, los condicionales (repite...hasta y mientras...fin mientras) en los cuales las instrucciones que se encuentren dentro de ellos, se repetiran hasta que se cumpla una condición o mientras se cumpla una condición 1. El segundo tipo de bucles se pueden denominar no condicionales (desde n hasta m) en los cuales las sentencias incluidas dentro de éstos, se repetirán un número determinado de veces normalmente basándose en un valor determiando.

Ejemplos de control de flujo:

(SECUENCIA).........escribe en pantalla ("Introduzca una determinada cantidad")lee de teclado (cantidad)cantidad = cantidad + 100escribe ("La cantidad introducida mas cien unidades es: " + cantidad).........

(CONDICIÓN SIMPLE).........escribe ("Introduzca una determinada cantidad")lee (cantidad)si (cantidad>100)

escribe ("La cantidad supera las cien unidades.")sino

escribe ("La cantidad es igual o menor a cien unidades.")fin si.........

(CONDICIÓN MÚLTIPLE).........escribe ("Introduzca una determinada cantidad")lee (cantidad)case cantidad

<100escribe ("La cantidad es inferior a las cien unidades.")=100escribe ("La cantidad es exactamente igual a las cien unidades.")

1 Es importante remarcar que existe una diferencia existente entre las dos formas de bucles condicionales (hasta y mientras), ya que la forma de interpretar la condición será totalmente distinta (hasta i=5 -> mientras i<>5).




>100escribe ("La cantidad supera las cien unidades.")>200escribe ("La cantidad supera las doscientas unidades.")....

.........

(BUCLE CONDICIONAL -REPITE...HASTA-).........repite

escribe ("Introduzca una cantidad mayor a cien unidades")lee (cantidad)

hasta cantidad > 100.........(BUCLE CONDICIONAL -MIENTRAS....FIN MIENTRAS-).........cantidad = 0mientras cantidad <= 100

escribe ("Introduzca una cantidad mayor a cien unidades")lee (cantidad)

fin mientras.........

(BUCLE NO CONDICIONAL -DESDE...HASTA-).........desde i=1 hasta i<=10 haz

escribir("El valor de i es: "+i)fin desde.........

Variables: El concepto de variable se puede entender como zonas de memoria (con una capacidad mínima de un byte) en las que se almacenará una información determinada y necesaria para la realización de un programa. Como su propio nombre indica el valor de las variables puede cambiar (variar) en todo momento mientras se está ejecutando el programa.

De todas las características que tienen las variables, la mas importante es su tipo de dato que es la forma que tiene la máquina de interpretar el valor que se almacena en memoria relacionado con esa variable, por ejemplo, una variable de tipo caracter (o alfanumérica) no se puede sumar, pero una variable de tipo entero (numérica) se podrá sumar, restar, multiplicar, etc. Los tipos de datos mas básicos en distintos lenguajes de




programación son:

Carácter.Cadena de caracteres.Numero entero.Entero largo (long).Número decimal....

Otras características asociadas a las variables son:

Volátiles: Una vez que se termina el programa se pierde el valor que almacenaba la variable.

Nombre: Toda variable está definida por un nombre (en los ejemplos de control de flujo vistos anteriormente, "cantidad" era el nombre de una variable). Según el lenguaje de programación que se use se suelen aplicar una serie de normas para definir el nombre de las variables (por ejemplo, toda variable deberá empezar por un carácter y después puede seguir o por uno o mas caracteres o número, o si el nombre de la variable está formado por mas de una palabra, se deberán separar por guiones bajos cada una de las palabras o se deberá escribir la primera letra de cada palabra en mayúsculas -a excepción de la primera palabra-...).

Constantes: Al igual que pasa con las variables, las constantes también almacenan información en una determinada zona de memoria, también necesitan un nombre para ser definidas, y en algunos lenguajes también tienen tipos de datos, pero se diferencias de las variables, porque nunca podrán cambiar el valor que se les asigna inicialmente.




El lenguaje de programación CEl lenguaje C ha sido desde sus inicios y hasta hace algún tiempo uno de los

lenguajes de programación mas utilizado por los programadores. Para entender el alcance que ha tenido durante muchos años este lenguaje de programación, se pueden poner como ejemplo, la gran mayoría de los sistemas operativos actuales (que han sido escritos o en C o en algunas de sus variables orientadas a objetos), al igual que buena parte de los programas básicos escritos para cada una de las plataformas actuales.

La ventaja principal se siempre ha ofrecido el lenguaje C es su potencia, gracias a la cual dicho lenguaje se encuentra implementado en la gran mayoría (por no decir todas) de las plataformas actuales, esto quiere decir que desde los pequeños dispositivos (móviles, PDA's, etc), hasta los grandes ordenadores, cuentan con los elementos necesarios para programar en C.

El mayor de los inconvenientes de este lenguaje es que posee una sintaxis algo complicada de entender, de ahí que esta primera parte del curso de programación esté enfocada a tratar su sintaxis de forma esquemática.

Control de flujo en el lenguaje C:

La estructura secuencial de los programas en C quda determinada por un conjunto de instrucciones, una detrás de otra.

La estructura condicional simple tiene la siguiente sintaxis:

if(<condición o condiciones>){

<secuencia de instrucciones>}else{

<secuencia de instrucciones>}

La estructura condicional múltiple tiene la siguiente sintaxis:

switch (<variable>){

1 Capítulo: El lenguaje de programación CAutor: Pablo Cristóbal Vergara Castro Edición: 1/2



case (<valor 1>):{

<secuencia de instrucciones>}break;

case (<valor 2>):{


......case (<valor n>):{


default:{


};

El bucle no condicional tiene la siguiente sintaxis:

for(<inicio de la variable>;<condición mientras>;<inc. o dec.>){

<secuencia de instrucciones>}

El bucle condicional mientras (en "C" no existe el bucle condicional hasta) tiene la siguiente sintaxis:

Primera forma:

do{

<secuencia de instrucciones>}while(<condición>);

Segunda forma:

while(<condición>)




{<secuencia de instrucciones>

}

(NOTA): En algún caso, dentro de una sentencia en la que se incluye una condición ( if(<condicion>), while(<condicion>), etc.) nos interesará añadir mas de una condición (p.ej.: si ( cantidad>100 y cantidad<200 ) ), ésto lo haremos de la siguiente forma:

• Se usará && para expresar una condición Y (p.ej.: if ((cantidad>100) && (cantidad<200)) )

• Se usará || para expresar O (p.ej.: if ( (cantidad<=100) || (cantidad>=200) ) )

Creación de un programa en C: Para crear un programa básico en "C" es imprescindible guardarlo en un fichero (lo que se denominó previamente como código fuente) que tenga extensión .c (para "C") o .cpp (para C y C++) o .cc (para C y C++). Otra característica para poder crear un ejecutable en C es tener una función cuyo nombre sea necesariamente main (función principal) donde la máquina empezará a interpretar secuencias que se hayan ido escribiendo.

Ejemplo "Hola mundo" (holaMundo.c):

#include<stdio.h>

main(){

printf("Hola mundo");}

Pasamos a comentar cada una de las líneas:

#include<stdio.h>: Sentencia básica que fuerza a que el pre-compilador incluya el fichero de cabecera "stdio.h" que contiene la definición de las sentencias más usadas por los programadores en materia de entrada/salida de datos (stdio= STanDard Input Output).

main(): La función "main", como ya se comentó unas líneas mas arriba es imprescindible para dar comienzo un programa.

printf("Hola mundo");: Sentencia obtenida gracias al fichero de cabecera "stdio.h" que imprime en pantalla lo que tiene entre comillas. Esta función es mucho mas potente




de lo que parece a simple vista, pero eso se verá mas adelante.

(NOTA): El lenguaje "C" distingue de mayúsculas y minúsculas, lo que quiere decir que no reconocerá Main o pRintf o, si hemos declarado una variable en minúsculas, no la reconocerá si después la escribimos en mayúsculas.

Declaración de variables:

<tipo de dato> <nombre de variable>;

Tipos de datos en "C" (según Borland C versión 3.1:

TIPO DE DATO RANGO SIGNO MEMORIAunsigned char 0...255 No 1 Bytechar -128...127 Si 1 Byte.

unsigned int 0...65535 No 2 Bytesshort int -32768...32767 Si 2 Bytesint -32768...32767 Si 2 Bytesunsigned long 0...4.294.967.295 No 4 Byteslong -2.147.483.648...

2.147.483.647Si 4 Bytes

double 3.4*(10 -38)...3.4*(10 38)

No 4 Bytes.

float 1.7*(10 -380)...1.7*(10 380)

No 8 Bytes.

long double 3.4*(10 -4932)...3.4*(10 4932)

No 80 Bits.

¿Porqué tantos tipos de datos?: La respuesta a esta pregunta es muy sencilla,




los motivos principales por los que existen varios tipos de datos tienen que ver con tres características:

1. Cantidad de memoria utilizada para almacenar las variables de un tipo de dato determinado (un char o un unsigned char sólo ocupan un byte mientras que un long double ocupa 80 bits).

2. Rango numérico que pueden alcanzar los distintos tipo de datos

3. Posibilidad de tener signo o no tenerlo (unsigned).

En cada caso hemos de buscar el tipo de dato que más se ajuste a lo que queramos hacer con nuestra variable.

Imprimir en pantalla (printf): Como ya comentamos anteriormente el comando printf es muy potente y versátil. Dicho comando se compone de dos partes principales, la primera es la cadena de texto en la que se escriben los mensajes y la segunda son las variables que podríamos querer mostrar dentro de la cadena de texto, por ejemplo, si queremos mostrar la variable cantidad lo haríamos de la siguiente forma:

prinf("El valor de la variable cantidad es: %d",cantidad);

de ésta forma se imprimirá en la pantalla la variable cantidad con un formato numérico de entero (%d) la variable cantidad.

Vamos a ver el mismo ejemplo dentro de un programa:

(cantidad.c)

#include<stdio.h>

main(){

int cantidad;cantidad = 100;

prinf("El valor de la variable cantidad es: %d",cantidad);}

Formatos de impresión de variables para printf:




%c carácter.%s cadena de caracteres.%d enteros.%u enteros sin signo.%o entero en formato octal.%x o %X entero en formato hexadecimal.(estas tres filas imprimen la variable en formado de coma flotante pero con

alguna característica específica en cada caso, la recomendación es mirar la ayuda o hacer algún programa sobre ello)

%f valores con coma flotante (decimales).%g o %g valores con coma flotante (decimales).%e o %E valores con coma flotante (decimales) y exponente.%n puntero a entero (un puntero es una dirección de memoria, ya se hablará de

ellos mas adelante)%p puntero a cualquier variable.

Obtener una variable a través del teclado (scanf): Este comando también es bastante potente y tiene una sintaxis muy parecida a la de printf, también se divide en dos partes, la primera es una cadena de texto donde se indicarán los formatos de las variables que queremos que sean introducidas por teclado, la segunda parte son las variables donde queremos que queden almacenados los datos introducidos por teclado.

Ejemplo:

scanf("%d %d", &cantidad,&euros);

(NOTA): Por ahora todas las variables que queramos que almacenen los datos introducidos por teclado usando 'scanf', se han de escribir precedidas del carácter &.

Programa de ejemplo:

(canteuro.c)

#include<stdio.h>

main(){

int cantidad,euto;




printf("Escriba el valor de la cantidad y del euro: ");scanf("%d %d",&cantidad,&euro);

prinf("Los valores de cantidad y euro son: %d %d",cantidad,euro);}

Formatos para la obtención de variables a través del teclado usando scanf: Los formatos utilizados son prácticamente los mismo que los usados para printf, en este curso no los especificaremos ya que los que usaremos son, en la gran mayoría de las veces o %c (carácter) o %s (cadena de caracteres) o %d (entero) o %f (flotante). Si se utilizasen otros formatos ser irían especificando.




Matrices y punterosLlegamos a la parte del curso donde podremos comprobar la oscuridad de la

sintaxis del lenguaje de programación "C" y todos sus derivados (C+, C++, Objective C...)

Aunque en la gran mayoría de manuales (sino en todos) sobre programación, este tema aparezca separado en dos (por un lado matrices y por otro punteros), se ha determinado presentarlos en uno mismo puesto que en "C" las matrices y los punteros se pueden acabar entendiendo como la misma cosa. Lo primero que vamos a ver en este nuevo capítulo son las matrices, comprobaremos cual puede ser su utilidad y como se manejan, posteriormente introduciremos el concepto de punteros y también estudiaremos su utilidad al igual que la forma de trabajar con ellos.

Matrices

Antes de ver las matrices se ha propuesto un programa que nos intentará aclarar el sentido de las matrices:

Realizar un programa que permita introducir diez notas de un alumno de ingeniería informática y posteriormente se le da la oportunidad de sumar alguna de ellas (siempre y cuando el resultado de la suma no sea mayor que 10), la suma de las notas se realizará mientras el alumno no quiera salir del programa.

Para realizar el programa hemos de declarar diez variables en la que se encuentren los datos de las diez notas, posteriormente introduciremos los diez valores y posteriormente entraremos en un bucle (usando do...while), del cual no saldremos hasta que se cumpla la condición de salida. Con lo que se ha estudiado en actualidad podríamos hacer el siguiente código:

#include <stdio.h>

main(){

int no1,no2,no3,no4,no5,no6,no7,no8,no9,no10;

1 Capítulo: Matrices y punterosAutor: Pablo Cristóbal Vergara Castro Edición: 1/2



int nota,suma;

printf("Escrib el valor de la primera nota: ");scanf("%d",&no1);printf("Escrib el valor de la segunda nota: ");scanf("%d",&no2);printf("Escrib el valor de la tercera nota: ");scanf("%d",&no3);printf("Escrib el valor de la cuarta nota: ");scanf("%d",&no4);printf("Escrib el valor de la quinta nota: ");scanf("%d",&no5);printf("Escrib el valor de la sexta nota: ");scanf("%d",&no6);printf("Escrib el valor de la septima nota: ");scanf("%d",&no7);printf("Escrib el valor de la octava nota: ");scanf("%d",&no8);printf("Escrib el valor de la novena nota: ");scanf("%d",&no9);printf("Escrib el valor de la decima nota: ");scanf("%d",&no10);

do{

printf("¿Cuanto quiere sumar a una nota?");scanf("%d",&suma)

printf("¿Cual es el número de la asignatura que quiere sumar (escriba 11 para salir del programa)?");

scanf("%d",&nota)

switch(nota){

case(1):{

if(no1+suma<=10){

//no1+=suma es igual que no1=no1+suma




no1+=suma;printf("El nuevo valor de la nota es: %d",no1);

}else

printf("El valor dado para sumar la nota daría como resultado un número superior a 10.");

}break;case(2):{

if(no2+suma<=10){


}else


}break;case(3):{

if(no3+suma<=10){


}else


}break;case(4):{

if(no4+suma<=10){


}else





}break;case(5):{

if(no5+suma<=10){


}else


}break;case(6):{

if(no6+suma<=10){


}else


}break;case(7):{

if(no7+suma<=10){


}else


}break;case(8):{

if(no8+suma<=10){

no8+=suma;




printf("El nuevo valor de la nota es: %d",no8);}else


}break;case(9):{

if(no9+suma<=10){


}else


}break;case(10):{

if(no102+suma<=10){


}else


}break;}

}while(nota!=11)

}

El programa en si no es complicado pero ¿a quien no le sienta mal tener que repetir el trabajo tantas veces para elementos que son tan parecidos?.

En el código existen básicamente dos segmentos (los que se muestran en cursiva) que nos ayudarán a explicar la utilidad básica de las matrices. El primero de los




segmentos muestra la repetición de dos operaciones bien conocidas (printf y scanf) para pedir y almacenar el valor de diez variables muy parecidas entre si (las notas) y que tiene el mismo tipo de dato y las unas de las otras solo se diferencian por el número que aparece en su nombre.

El segundo de los segmentos realiza las mismas operaciones de comprobación y suma (en el caso de que la suma sea menor o igual a diez) sobre alguna de las diez variables para lo cual se hace uso de un número que indicará qué nota será la que se debe sumar (la variable nota). Dicho de otra forma la variable nota se usa como indice para acceder a una de las diez variables.

Una vez analizado el código ahora resaltaremos de forma mas esquemática los segmentos señalados:

• Uso de variables muy parecidas entre si ya que poseían el mismo tipo de dato (osea son homogéneas) y sólo se diferencian entre si por un número.

• Repetición de las mismas operaciones para las diez variables2.• Acceso al valor de una de las diez variables mediante el valor de la variable nota

(mediante el uso del índice).

Una vez escrito el código seguro que cualquiera desearía que existiese algún mecanismo para acceder de forma mas rápida a las distintas variables sobre las cuales había que realizar la misma operación, bueno pues ese método existe y justamente son las matrices. Pasaremos ahora a dar la definición formal del concepto de matriz, para explicar después estudiar la sintaxis de acceso y finalmente enseñar como sería el programa anterior usando matrices.

Matriz: Conjunto de elementos homogéneos (elementos del mismo tipo) que cumplen las siguientes características:

• Se almacenan de forma secuencial (un elemento detrás de otro).• Los elementos se encuentran en la misma zona de memoria, nunca se puede dar

el caso de tener alguno de los elementos en una zona de memoria y el resto en otra zona (para eso se deberían crear dos matrices, o listas enlazadas).

• Las matrices se caracterizan por tener una o varias dimensiones.• A cada elemento atómico de una matriz se le denomina celda.• En el lenguaje "C" si hacemos referencia al nombre de la matriz estaremos

2 Aquí surge además la pregunta de ¿y que pasaría si después el programa se hiciera para 11 asignaturas o para 5?




actuando sobre la dirección de memoria de su primera celda.

La sintaxis de una matriz puede llegar a ser compleja pero se intentará remarcar cada una de las partes para hacerla un poco mas comprensible:

Declaración de una matriz: (... de una dimensión)<tipo dato> <nombre matriz> [<1ª dimensión>];

(...de N dimensiones)<tipo dato> <nombre matriz> [<1ª dimensión>] [<2ª dimensión>] ... [<N-ésima

dimensión>] ;

Acceso a una celda: (...de una dimensión)<nombre matriz> [<número de celda13>]

(...de N dimensiones)<nombre matriz> [<número de celda1>] [<número de celda2>] ... [<número de

celdaN>]

Ejemplo: Como enunciado tomaremos el ejemplo anterior y lo llevaremos a cabo usando matrices:

#include<stdio.h>

main(){

int tablaNota[10];int i,suma;

for(i=0;i<10;i++){

printf("Introduzca el valor de la nota nº %d",i);scanf("%d",&tablaNota[i]);

}

do{


3 <número de celda> deberá estar comprendido entre 0 y (1ª dimensión)-1




printf("¿Cual es el número de la asignatura que quiere sumar (escriba 11 para salir del programa)?");

scanf("%d",&i)

if( (i>=0) && (i<=10)){

if(tablaNota[i]+suma<=10){

tablaNota[i]+=suma;printf("El nuevo valor de la nota es: %d",tablaNota[i]);

}else


}}while(i!=11);

}

Comparando los dos códigos podemos observar que el resultado es sensiblemente menor utilizando matrices (por no decir que es mas extensible).

El código, aunque parezca bien escrito, tiene un "pequeño" fallo de construcción y es que no se especifica la dimensión de la matriz como una constante y por lo tanto, después tampoco se usa dicha dimensión en ningún momento como valor relativo. Realizar esa práctica de programación es muy favorable ya que, si lo tenemos bien programado, cada vez que cambiemos la dimensión de la matriz no tendremos que cambiar el código. De haberlo hecho así el programa quedaría de la siguiente forma:

#include<stdio.h>#define dimension 10

main(){

int tablaNota[dimension];int i,suma;

for(i=0;i<dimension;i++){




printf("Introduzca el valor de la nota nº %d",i);scanf("%d",&tablaNota[i]);

}

do{


printf("¿Cual es el número de la asignatura que quiere sumar (escriba %d para salir del programa)?",dimension+1);

scanf("%d",&i)

if( (i>=0) && (i<=dimension)){

if(tablaNota[i]+suma<=10){

tablaNota[i]+=suma;printf("El nuevo valor de la nota es: %d",tablaNota[i]);

}else


}}while(i!=dimension+1);

}




Cadenas de caracteres: La persona que haya seguido el curso hasta este punto se habrá dado cuenta de que los ejemplos y ejercicios propuestos se han realizado usando tipos de datos numéricos o simples caracteres pero nunca se ha visto hasta ahora variables que puedan contener palabras o frases; ahora la pregunta que puede surgir es ¿qué pasa en C con las frases o la palabras?, pues bien la respuesta es bien sencilla, si hasta ahora no hemos usado variables para almacenar palabras era porque necesitábamos de las matrices para introducir el concepto de cadena de caracteres que será la herramienta que nos servirá para definir variables en las que podamos almacenar más de un carácter.

Definición de cadena de caracteres (o string): Se compone por un conjunto de elementos de tipo char agrupados en una matriz. Nos referiremos al concepto de cadena de caracteres siempre que hablemos de dos o más caracteres unidos.

Declaración de una cadena de caracteres: La operación de definición es bien sencilla y, una vez aclarado el concepto de matriz, se entenderá rápidamente:

char <nom _ cadcar> [<dimensión>];

Asignación de un literal a una cadena de caracteres: Para que una cadena de caracteres tenga el valor de un literal determinado sólo será necesario realizar la operación siguiente:

strcpy( <nom _ cadcar>, "<literal>");

Impresión por pantalla de una cadena de caracteres: Para poder imprimir por pantalla una cadena de caracteres se usará, en el printf, el %s dentro del literal.

Observaciones:

• Para que C pueda usar el comando "strcpy" y otros que veremos más adelante hemos de incluir (#include) un nuevo fichero de cabecera, éste es el string.h.

• Se deberá tener mucho cuidado con que el número de caracteres introducido en la cadena de caracteres sea menor o igual a la dimensión-1 con la que se declaró dicha cadena de caracteres. Esto es debido a que el lenguaje de programación usa un carácter especial (el '\x0') para saber donde queremos que termine el literal que se ha escrito, de tal forma que si hemos usado menos caracteres de los indicados en la dimensión de la cadena de caracteres no tengamos que preocupamos de que




se acceda incluso a los que no están escritos por nosotros.

• Hay que tener mucho cuidado cuando nos queramos hacer referencia a una única celda de una cadena de caracteres ya que, al tratarse de un único carácter, la sintaxis no será igual que cuando tratamos la cadena de caracteres entera. Para hacerse referencia a un único carácter usaremos las comillas simples (") y para hacernos referencia a un conjunto de caracteres (cadena de caracteres) usaremos las comillas dobles (""). Ejemplo:

#include <string.h> #include <stdio.h>

main(){

char cadcar[10]; strcpy( cadcar, "abcdefghi"); printf("La cadena de caracteres es %s\n",cadcar); printf ("El tercer carácter de la cadena de caracteres es: %t\n" ,cadcar[2]);

if (cadcar[2]==' c') printf ("HOLA \n");

}

La excepción del 'scanf': Como hemos visto hasta ahora cada vez que queremos recoger el valor de una variable (o una celda de una matriz) por teclado (osea cada vez que usamos scanf) hemos de anteponer el carácter & al nombre de la variable, bien pues cada vez que usemos una cadena de caracteres (cuidado una cadena de caracteres no es una celda de una cadena de caracteres) con la sentencia scanf no antepondremos el carácter & y usaremos el %s para notificar al scanf que el valor que queremos introducir por teclado es una cadena de caracteres. El porqué de la excepción que se acaba de explicar lo detallaremos después al ver los punteros con más detenimiento y también al estudiar las funciones.

Ejemplo:

char cadcar[ 10]; scanf("%s" ,cadcar); scanf("%c" ,&cadcar[2]);




De tal forma que un programa en el que queramos escribir una cadena de caracteres por teclado para, posteriormente, mostrar fa cadena de caracteres por pantalla tendría el siguiente aspecto:

#include<stdio. h>

main(){

char cadcar [10]; printf ("Escriba una palabra: "); scanf{" %s" , cadcar); printf("La palabra escrita es: %s",cadcar);

}

La excepción de las condiciones: Hasta la actualidad hemos estudiado que las condiciones con las variables se trataban con operadores del tipo == o != o <= o >= bien pues para comparar que una cadena es igual o distinta a otra no se hace de la misma forma sino usando una sentencia llamada strcmp (string compare). Las sintaxis de ésta sentencia es como sigue:

strcmp(<cadena1>,<cadena2>);

De tal forma que tanto <cadena1> como <cadena2> pueden ser o una cadena de caracteres o un literal cualquiera.

La sentencia strcmp retorna un valor igual a cero si <cadena1> y <cadena2> son exactamente4 iguales, un valor menor que cero si <cadena1> es menor que la <cadena2> y un valor mayor que cero si la <cadena1> es mayor que la <cadena2>. Usando esta sentencia un valor es menor a otro dependiendo de los valores ASCII de los caracteres ('A'=65 'a'=97 de tal forma que "a">" A") y viceversa5.

Para usar esta sentencia se ha de incluir (#include) el fichero de cabecera string. h

Ejemplo:

4 Cuidado con las mayúsculas y las minúsculas5 En muchos documentos se hacen referencia a este tipo de comparaciones como comparaciones

binarias.




#include <stdio.h> #include <string.h>

main(){

char cadcar1[10]; char cadcar2[10];

strcpy(cadcar1,"coche"); strcpy(cadcar2, "lerele");

if (strcmp(cadcar1,cadcar2)==0)) printf{"La primera cadena de caracteres es igual a la segunda");

strcpy(cadcar1,cadcar2);

if(strcmp(cadcarl,cadcar2)==0) printf("La primera cadena de caracteres es igual a la segunda");

}

Truco para entender las matrices y las cadenas de caracteres: Como muchos lectores pueden ver como algo muy complicado el tema de las matrices o las cadenas de caracteres (que al fin y al cabo son matrices pero de caracteres) vamos a proponer una forma más gráfica de ver una matriz, una cadena de caracteres y una matriz de cadena de caracteres:

Ejemplo de una matriz de una dimensión con 10 elementos y de tipo int:

(NOTA): Los valores encerrados en celdas de borde doble son los datos contenidos en la matriz, los otros valores (los que se encuentre fuera de la caja) son los índices; así, en el ejemplo que vamos a ver a continuación, la celda número seis de la matriz tiene el valor 84 (matriz[6] es 84)

1340 54 6834 5324 3 39 84 278 494 8673

0 1 2 3 4 5 6 7 8 9

Ejemplo de una matriz de dos dimensiones con 10 columna y 4 filas y de tipo




int::

0 1340 54 6834 5324 3 39 84 278 494 8673

1 534 765 75 9774 6787 9 543 75 39 25

2 64 845 20000 3553 789 7575 80 453 684 84

3 82 89 833 31000 304 793 987 678 456 456

0 1 2 3 4 5 6 7 8 9El valor de la celda que se encuentra en la segunda fila (cuidado esa es la fila

número uno) y la tercera columna (la columna número dos) es 75 (matriz[1][2] es 75)

Ejemplo de una matriz de una dimensión con 10 elementos y de tipo char (una cadena de caracteres):

M i c a s a \x0

0 1 2 3 4 5 6 7 8 9El valor de la celda número dos (la tercera celda) es ' ' (carácter espacio).

Ejemplo de una matriz de dos dimensiones con 10 columnas y 3 filas de tipo char (tres cadenas de caracteres):

0 E S T O S O N \x0

1 T R E S \x0

2 S T R I N G S \x0

0 1 2 3 4 5 6 7 8 9

Este es un ejemplo perfecto de cómo podemos crear un número determinado de cadenas de caracteres en una matriz. Para definir dicha matriz sólo hemos de escribir lo siguiente:

char <nombre cadcar> [<numero de cadcars>] [<dimension cadcars>];

Para acceder a una de la cadenas de caracteres sólo hemos de indicar la fila y si




queremos acceder a un único carácter hemos de indicar fila y columna.




Punteros

Pasamos ahora a la segunda sección del capítulo de "Punteros y matrices", ésta es, sin duda, una de las secciones mas complicadas ya que entender el concepto de puntero, y lo que es peor, la sintaxis y utilidad de los punteros es realmente difícil para alguien que no tenga los conceptos muy claros dentro de la programación. Esta sección se ha intentado escribir de la forma más didáctica posible pero, quien escribe el curso, es consciente de que no todo el mundo conseguirá entender con la suficiente claridad los conceptos que aquí se van a exponer, aun así se pondrá el suficiente empeño para que todos alcancen la meta de comprender el difícil mundo de los punteros.

Lo primero y más importante es aclarar algo sobre las variables que, hasta ahora, no se había explicado, esto es que existe una característica asociada a éstas muy relacionada con los punteros. Hasta ahora conocíamos las siguientes propiedades de una variable:

• Nombre de la variable• Tipo de dato

Pasemos a comentar una nueva característica de una variable: su dirección de memoria, pensemos en que una variable se aloja en un determinado lugar dentro de la memoria de nuestro ordenador, bien pues ¿cómo sabemos en que parte de la memoria se encuentra?, la respuesta a esta pregunta es: gracias a su dirección de memoria. Una vez conocida esta característica ¿qué pasaría si pudiéramos acceder al valor de una variable a través de su dirección de memoria?, bien, pues eso se puede hacer gracias a los punteros. Ahora surge una nueva duda ¿para que nos sirve acceder al valor de una variable usando punteros si ya lo conseguimos de una forma menos complicada?, esta respuesta será un poco más compleja de explicar y es necesario explicar previamente una serie de conceptos.

Definición de puntero: Una determinada dirección de memoria asociada, en una gran mayoría de casos, a una variable de un tipo determinado.

Para ver de forma más gráfica el significado de puntero pensemos en que la/s celda/s (byte/s) en la que se aloja una variable que hemos declarado tiene la siguiente forma:




54250 ? 54251 ? 54252 45 54253 ? 54254 ?

y que su dirección dentro de la memoria es la 54252 de tal forma que habrá alguna forma de acceder al valor (el 45) que se encuentra dentro de dicha variable usando su dirección de memoria.

Una vez mostradas la definición de puntero y la visión gráfica de los punteros vamos a estudiar como se declaran en lenguaje C como variables especiales que contienen el valor de la dirección de memoria de una determinada variable de un tipo de dato concreto.

Declaración de variables puntero:

<tipo de dato> * <nombre variable puntero>;

Podemos observar que la declaración de un puntero es muy similar a la de una variable cualquiera esto es así porque un puntero, puede ser declarado como variable con la característica especial de almacenar la dirección de memoria de otra variable. Un vez aclarado éste punto nos dedicaremos a estudiar el significado de la declaración de un puntero: <tipo de dato> será el tipo de dalo de la variable de la que queremos almacenar su dirección de memoria, osea, el tipo de dato de la variable a la que queremos "apuntar" con nuestro puntero; por ejemplo, si hemos definido una variable de tipo int, y queremos almacenar su dirección de memoria con un puntero, declararemos un puntero de tipo int.

Ejemplo:

...int variableInt; int *punteroInt;...

Ahora veremos como podemos asignar la dirección de memoria de una variable de un tipo determinado a un puntero de ese mismo tipo. Lo que se va a escribir ahora suele dar muchos problemas a los programadores noveles ya que la sintaxis de nuestro lenguaje C es, en el caso de los punteros, muy enrevesada,




Asignar una dirección de memoria a una variable puntero:

<variable _puntero>=&<variable>;

Quizás a alguien le suene familiar el símbolo & (ampersand) ya que lo hemos usado infinidad de veces en la sentencia scanf (excepto cuando usamos cadenas de caracteres), bueno pues podríamos adelantar en este curso, que existe una gran relación entre los punteros y el uso del & dentro del scanf, lo veremos más avanzado el curso, pero merece la pena tenerlo en cuenta.

(NOTA): Es muy importante que quede claro que el valor que albera una variable puntero es la dirección de memoria de otra variable, de tal forma que si nosotros queremos acceder al valor de una variable de tipo puntero estaremos accediendo a una dirección de memoria (si modificamos el valor de una variable puntero nos estaremos haciendo referencia a una dirección de memoria distinta y si leemos el valor de una variable puntero estaremos leyendo una dirección de memoria).

Una vez que sabemos como se declara una variable puntero y como se le asigna una dirección de memoria a dicha variable nos queda por ver como accederemos al valor de la variable a la que "apunta" nuestro puntero.

Acceso al valor de una variable mediante una variable puntero:

*<variable puntero>

(NOTA): Existe otra forma de acceder al valor relacionado con un puntero, forma veremos mas adelante cuando hablemos de la relación entre los punteros y las matrices.

Bueno pues una vez que se han explicado las tres operaciones básicas de los punteros vamos a ver un ejemplo en C y después veremos gráficamente el mismo los accesos realizados en dicho ejemplo:

#include <stdio.h>

main(){

int variableInt; int *punteroInt;




variableInt=5;

punteroInt = &variableInt;

printf("El valor de la variable es: %d",variableInt);printf("El valor de la variable (usando punteros) es: %d", *punteroInt);

*punteroInt = 6;

printf("El valor de la variable es: %d",variableInt);printf("El valor de la variable (usando punteros) es: %d", *punteroInt);

}

Ejemplo gráfico:

(NOTA): Los números que no se encuentran dentro de las celdas representan direcciones de memoria y los que se encuentran dentro de celdas representan los valores de las variables asociados a dichas direcciones de memoria.

Declaración de variableInt, a la que se le asignará por ejemplo la dirección de memoria 42422 y de punteroInt, a la que se le asignará por ejemplo la dirección de memoria 34636 (int variableInt, *punteroInt;).

42418-42419

? 42420-42421

? 42422-42423

? 42424-42425

? 42426-42427

?

34628-34631

? 34632-34635

? 34636-34639

? 34640-34643

? 34644-34647

?

(NOTA): Como la variable variableInt es de tipo entero y la variable punteroInt es de tipo puntero (independientemente del tipo de dato al que apunta) dichos tipos de dato ocupan 2 y 4 bytes respectivamente. Es por ese motivo que las direcciones 42422-42423 y 34636-34639 las podemos ver como casillas únicas en la que se almacenarán los valores de nuestras variables.

Asignación de un valor a variableInt (variableInt=5;):




42418-42419

? 42420-42421

? 42422-42423

5 42424-42425

? 42426-42427

?

34628-34631

? 34632-34635

? 34636-34639

? 34640-34643

? 34644-34647

?

Asignación de la dirección de memoria de variableInt a punteroInt (punteroInt = &variableInt;):

42418-42419

? 42420-42421

? 42422-42423

5 42424-42425

? 42426-42427

?

34628-34631

? 34632-34635

? 34636-34639

42422 34640-34643

? 34644-34647

?

Modificación del valor de variableInt usando punteroInt (*punteroInt=6;)

42418-42419

? 42420-42421

? 42422-42423

6 42424-42425

? 42426-42427

?

34628-34631

? 34632-34635

? 34636-34639

42422 34640-34643

? 34644-34647

?

Definición de un puntero a cualquier tipo de dato: Si hemos seguido atentamente la explicación de la sección dedicada a las variables de tipo puntero se habrá dado cuenta que se ha remarcado que, para que un puntero apunte a una determinada variable, es bastante conveniente que el tipo de la variable puntero sea igual al tipo de la variable a la que apunta. Si por algún motivo deseamos acceder mediante punteros a distintos tipos de datos o si no queremos definir el tipo de dato al que apuntaremos posteriormente, debemos declarar una variable puntero de al tipo de dato void (vacio); este tipo de variables puntero se declaran de la siguiente forma:

void * <nombre variable puntero>;

Punteros y matrices




Una vez que se ha aprendido el significado y la sintaxis de los punteros vamos a estudiar la relación entre las matrices y los punteros.

Como ya se había explicado anteriormente podemos ver las matrices y los punteros como la misma cosa ya que, cuando usamos en un programa el nombre de una matriz estamos especificando la dirección de memoria de su primera celda, esto quiere decir que si nosotros declaramos una variable puntero con un tipo de de dato idéntico al tipo de dato de una matriz podremos asignar la la dirección de la matriz a dicho puntero. Aunque esto suene algo complicado esto se puede hacer sin ningún problema, además podemos acceder al valor de una variable que es apuntada por otra variable de tipo puntero usando la misma sintaxis que se usaba para acceder a las celdas de una matriz.

La persona que escribe este curso es consciente que todos los conceptos que se acaban de introducir pueden ser realmente difíciles de entender en un principio, de tal forma que se va a intentar realizar ejemplos tanto en código C como de forma gráfica para hacer mas comprensibles todas las nociones.

Ejemplo: #include <stdio.h> #define dimension 10

main(){

int matriz[dimension], *punteroInt, i;

punteroInt=matriz;

*punteroInt=5;

for (i=1;i<dimension;i++) matriz[i]=i+10;

for (i=0;i<dimension;i++) printf("La celda n° %d de la matriz tiene el valor: %d\n",i,matriz[i]);

for (i=0;i<dimension;i++) printf ("La celda n° %d de la matriz tiene el valor: %d\n",i,punteroInt[i]);

}




(NOTA): Es muy importante observar que la última línea de código usamos la variable punteroInt con la misma sintaxis que usamos para acceder a una matriz, de tal forma que estamos accediendo a las celdas de la matriz con un puntero, eso se puede hacer, incluso cuando el puntero apunta a una variable normal (por ejemplo cuando un puntero a entero tiene almacenada la dirección de una variable de tipo entero, también podremos acceder al valor de dicha variable usando <nombre variable puntero>[0]).

Ejemplo gráfico:

Declaración de la matriz de diez elementos y de la variable puntero que almacenará la dirección de la primera celda (int matriz[dimension], *punteroInt, i;):

42418-42419

? 42420-42421

? 42422-42423

? 42424-42425

? 42426-42427

?

42428-42429

? 42430-42431

? 42432-42433

? 42434-42435

? 42436-42437

?

34628-34631

? 34632-34635

? 34636-34639

? 34640-34643

? 34644-34647

?

Asignación de la dirección de memoria de la primera celda de la matriz a la variable puntero (punteroInt=matriz;)

42418-42419

? 42420-42421

? 42422-42423

? 42424-42425

? 42426-42427

?

42428-42429

? 42430-42431

? 42432-42433

? 42434-42435

? 42436-42437

?

34628-34631

? 34632-34635

? 34636-34639

42418 34640-34643

? 34644-34647

?

Asignación del valor de la primera celda usando la variable puntero (*punteroInt=5; => aunque, como acabamos de ver, también se podría escribir punteroInt[0]=5;)




42418-42419

5 42420-42421

? 42422-42423

? 42424-42425

? 42426-42427

?

42428-42429

? 42430-42431

? 42432-42433

? 42434-42435

? 42436-42437

?

34628-34631

? 34632-34635

? 34636-34639

42418 34640-34643

? 34644-34647

?

Asignación del resto de valores usando la variable matriz

(for(i=1;i<dimension;i++)

matriz[i]=i+10; => punteroInt[i]=i+10;)

42418-42419

5 42420-42421

11 42422-42423

12 42424-42425

13 42426-42427

14

42428-42429

15 42430-42431

16 42432-42433

17 42434-42435

18 42436-42437

19

34628-34631

? 34632-34635

? 34636-34639

42418 34640-34643

? 34644-34647

?

Una vez que se hemos estudiado la relación más simple entre las matrices y los punteros, aprenderemos la forma en la que podemos crear una matriz sin declarada usando punteros, además esto, nos dará la opción de crear matrices dinámicas (esta es una de las utilidades de los punteros, pero no la más importante), de tal forma que si queremos que una misma matriz, primero tenga 10 celdas y después 20 celdas lo podremos hacer sin ningún problema, eso sí con mucho cuidado. Para realizar el proceso de creación de matrices dinámicas vamos a mostrar dos nuevas sentencias y a explicar su funcionamiento pidiendo al lector que preste en ello la máxima atención.

Comprobar el número de bytes que ocupa una variable (sizeof): Esta sentencia




nos sirve para saber cuantos bytes ocupa un determinado tipo de dato o una variable con un tipo de datos contreto. Aunque esta sentencia parezca algo inútil ya que, en una de las primeras páginas del curso, se comentó el número de bytes que ocupa cada tipo de dato (según la versión 3.1 del compilador desarrollado por la empresa Borland) es realmente importante porque existen muchas versiones del lenguaje C y muchas empresas que poseen versiones distintas, de tal forma que, dependiendo de la versión y de la empresa que sea, el tamaño de un tipo de dato puede ser distinto.

La sintaxis de la sentencia es la siguiente:

sizeof(<tipo de dato o variable>);

Ejemplo:

...printf("El tamaño de un entero usando su compilador es %d",sizeof(int));printf("El tamaño de un carácter usando su compilador es %d",sizeof(char));printf("El tamaño de un flotante usando su compilador es %d",sizeof(float));...

Reserva de una zona de memoria (malloc y calloc): A la hora de declarar una determinada variable o una matriz e incluso una variable de tipo puntero siempre hemos dejado que el lenguaje realice dicho trabajo por nosotros, pero existen formas alternativas para ello ya que, en algún momento determinado nos puede interesar a nosotros "hacer el trabajo sucio", esto lo realizaremos con la sentencia malloc o la sentencia calloc.

Antes de explicar la sintaxis y el funcionamiento de dichas sentencias es muy importante tener en cuenta que una zona de memoria ocupará un número de bytes determinados y nosotros hemos de saber perfectamente cuantos bytes queremos reservar (es por eso por lo que se ha explicado previamente la sentencia sizeof, de tal forma que si queremos reservar una zona de memoria para diez variables de tipo entero (osea una matriz de una dimensión con diez celdas) tendremos que tener en cuenta, además del número de celdas que queremos reservar, el tamaño de las celdas.

La sintaxis de las sentencias es la siguiente:

malloc(<numero total de bytes a reservar>);calloc(<numero celdas>,<bytes de cada celda>);




Ambas sentencias retornan la dirección de memoria en la que se encuentra el primer byte de la zona de memoria que hemos reservado.

Ejemplo (reservar una zona de memoria para diez enteros=>matriz de enteros):

punteroInt=malloc(sizeof(int)*10);

Ejemplo (reservar una zona de memoria para diez caracteres=>matriz de caracteres=>cadena de caracteres):

punteroChar=calloc(10,sizeof(char));

Liberar una zona de memoria (free): De la misma forma que, hasta ahora habíamos delegado la tarea de reservar unas determinadas zonas de memoria al compilador de nuestro lenguaje C, también hemos encomendado la misión de liberar las zonas de memoria que se han reservado al mismo lenguaje C. Esto quiere decir que si ahora nosotros nos podemos hacer cargo de reservar zonas de memoria, posteriormente nos tendremos que hacer cargo de liberar las zonas de memoria que hemos reservado, para conseguir que podamos realizar dicho trabajo hemos de usar la sentencia free.

Sintaxis:

free(<variable puntero>);

De tal forma que <variable puntero> será una variable de tipo puntero donde nosotros hemos almacenado la dirección de memoria que previamente nos retornó la sentencia malloc o la sentencia calloc y que ya vamos a dejar de usar.

Ejemplo (reserva de un zona de memoria para almacenar un entero usando calloc o malloc y posterior liberación):

...punteroInt=calloc(1,sizeof(int)); ...free(punteroInt); ...




o

...punteroInt=malloc(1*sizeof(int)); ...free(puntero _int); ...

Usando de forma correcta las sentencias malloc (o calloc) y free se pueden crear matrices dinámicas ya que la misma variable puntero, primero puede almacenar la dirección de una zona de memoria para, por ejemplo, 10 enteros y posteriormente puede almacenar la dirección de una zona de memoria para 20 enteros, eso sí, antes de que la variable puntero pueda acceder a la segunda zona se ha de liberar la primera.

Si todo lo que hemos estudiado hasta ahora de los punteros y de la relación de las matrices con dichos punteros parece complicado, hay una mala noticia, podemos complicar más las cosas declarando punteros a matrices, punteros de punteros, matrices a punteros y todo lo que nuestra imaginación quiera. Son este tipo de cosas las que confieren al lenguaje C de una gran potencia y a su vez de una sintaxis muy oscura.

Sintaxis de la declaración de un puntero que apunte a una matriz:

<tipo de dato matriz> (*<nombre variable puntero>) [<dimensión>];

Sintaxis de la declaración de una matriz que contiene punteros que apunten a variables con un determinado tipo de datos:

<tipo de dato punteros> *<nombre variable matriz>[<dimensión>];

Sintaxis de la declaración de un puntero que apunte a un puntero que a su vez apuntará a una variable de un tipo de datos determinado:

<tipo de dato puntero a puntero> ** <nombre puntero>;




Ejercicios propuestos

(PUNTEROS)

21° Declarar una variable de tipo entero y una variable puntero de tipo entero, asignar la dirección de la variable de tipo entero a la variable puntero, almacenar un valor determinado en la variable de tipo entero usando la variable puntero y posteriormente imprimir el valor usando la variable de tipo entero.

(PUNTEROS Y MATRICES)

22° Declarar una matriz de enteros de diez celdas y una variable puntero a entero, asignarle la dirección de la primera celda a la variable puntero y asignar los valores de cada una de las celdas usando la variable puntero.

23° Realizar el primer programa en el que se usó las matrices (cálculo de la media => ejercicio número 11), declarando, además de la variables y la matriz que se usaron, una variable puntero que almacene la dirección de memoria de la primera celda de la matriz. El programa usará la variable puntero (con la misma sintaxis de la matriz) en todos los sitios donde se usaba la matriz.

24º Declarar una matriz de caracteres (cadena de caracteres) y una variable puntero de tipo carácter, asignarle la dirección de la primera celda a la variable puntero. Usar la sentencia strcpy para copiar en la variable puntero la palabra "hola mundo" (CUIDADO SERÁ NECESARIA RESERVAR LA CADENA DE CARACTERES CON UN MÍNIMO DE 11 CELDAS) e imprimir el valor de la cadena de caracteres por pantalla.

(PUNTEROS Y MATRICES DINÁMICAS)

25º) Declarar una variable puntero de tipo entero y una variable de tipo entero en la cual se almacenará la dimensión de una matriz, de tal forma que dicho valor scrá introducido por teclado y a partir de este momento se creará una matriz dinámica y se introducirá en cada una de las celdas el valor por teclado y posteriormente se visualizarán dichos valores. Una vez se ha terminado de usar nuestra matriz dinámica se liberará la zona de memoria que fue reservada para ella y se concluirá el programa.




26º) Realizar el ejercicio número 12 (cálculo de la media de un determinado de variables estadísticas) usando una matriz dinámica, de tal forma que, dependiendo del número de variables estadísticas que se quieran crear se preparará la matriz dinámica con un número de celdas o con otro.




Estructuras (Registros)Antes de empezar con el capítulo más importante de la asignatura (las funciones)

estudiaremos como podemos reunir una colección de elementos heterogéneos (éstos pueden ser tipos de datos, punteros, matrices .... ) para que formen parte de una única entidad a la que llamaremos estructura o registro.

En un principio el lector quizás no entienda la utilidad que pueden tener las estructuras, de tal forma que, como es habitual en el curso, pasaremos a poner un ejemplo del uso de las estructuras para poder comprobar cuando pueden ser necesarias y cual es el sentido de su creación, posteriormente se mostrará la definición formal de las mismas.

Ejemplo: Una persona cualquiera quiere poder escribir una serie datos dentro del ordenador y posteriormente quiere visualizarlos, de tal forma que nosotros haremos un programa que realice dicha tarea.

Los datos que se almacenaremos de dicha persona serán los siguientes: Nombre, apellidos, número de teléfono y la edad.

(Ejemplo sin usar estructuras)

#include<stdio.h>

main() {

char nombre[20],apellidos[30],telefono[20]; int edad;

printf ("Escriba el nombre: "); scanf("%s" ,nombre); printf ("Escriba los apellidos: "); scanft."%s" ,apellidos); printf ("Escriba el teléfono: "); scanft."%s" ,telefono); printf ("Escriba la edad: "); scanft."%s" ,&edad);

printft."Su teléfono es: %s\n" ,telefono);

1 Capítulo: EstructurasAutor: Pablo Cristóbal Vergara Castro Edición: 1/2



printft."Su edad es: %d\n" ,edad); printf~"Su nombre es: %s\n",nombre); printft."Sus apellidos son: %s\n",apellidos);

}

(Ejemplo usando estructuras)

#include <stdio.h>

struct PERSONA{

char nombre[20],apellidos[30],telefono[20];int edad;

};

main(){

struct PERSONA sujeto;

printf ("Escriba el nombre: "); scanf("%s",sujeto.nombre);printf ("Escriba los apellidos: ");scanf("%s", sujeto.apellidos);printf ("Escriba el teléfono: ");scanf("%s", sujeto.telefono); printf ("Escriba la edad: ");scanf("%d",&sujeto.edad);

printf("Su nombre es: %s\n", sujeto.nombre);printf("Sus apellidos son: %s\n", sujeto.apellidos);printf("Su teléfono es: %s\n", sujeto.telefono);printf("Su edad es: %d\n", sujeto.edad);

}

Observando detenidamente el ejemplo en el que usamos la estructura PERSONA podríamos empezar a entender el sentido y la utilidad de las estructuras; nosotros hemos creado una entidad (la estructura persona) compuesta de un conjunto de elementos heterogéneos para agrupar los datos referentes a dicha entidad en un solo conjunto, posteriormente hemos declarado una variable estructura que será la que usemos en




nuestro programa para acceder a cada uno de los elementos definidos en la estructura PERSONA.

Definición de estructura (registro): Entidad formada por una colección de elementos heterogéneos

Definición de campo: Cada uno de los elementos que forman una estructura.

Sintaxis de creación de una estructura: La creación de una estructura se realiza en las líneas anteriores a la función principal (main) y se usa la siguiente sintaxis:

struct <nombre estructura> {

<tipo dato campo1> <nombre campo1>;<tipo dato campo2> <nombre campo12;...<tipo dato campoN> <nombre campoN>;

}

Sintaxis de declaración de una variable estructura: Para poder crear una variable estructura la tenemos que haber creado previamente.

struct <nombre estructura> <nombre variable estructura>;

Sintaxis de acceso a un campo: Lo más importante cuando accedemos a un campo es que debemos tener muy claro que, aunque se encuentre dentro de una estructura, lo usaremos de la misma forma que lo hemos hecho siempre (si tenemos que poner un & en el scanf lo pondremos si queremos sumarlo lo haremos ... ) pero con una sintaxis distinta:

<nombre variable estructura>.<nombre campo>

De tal forma que si queremos imprimir en pantalla el campo "nombre" de la variable estructura "sujeto" lo haremos de la misma forma que siempre pero usando la nueva sintaxis:

printf ("%s" ,sujeto.nombre);




Hemos de tener cuidado en el caso de haber definido una variable igual que el nombre de un campo, ya que la sintaxis para acceder a un campo de una variable estructura acabamos de ver que es distinta.

Ejemplo: Imagínese que hemos declarado una variable llamada "nombre" y un campo de la estructura "PERSONA" se llama igual, cuando declaremos una variable de la estructura "PERSONA" (p.ej: "sujeto") no accederemos igual al campo "nombre" que a la variable nombre.

(acceso al campo)

printf ("%s",sujeto.nombre);

(acceso a la varíable)

strcpy(nombre,"Raul");

Como casos interesantes de estudio veremos como podemos declarar una matriz de estructuras, como podemos acceder a los campos de dicha matriz y como crear una estructura con un campo, que es a su vez, otra estructura:

Declaración de una matriz de estructura:

struct <nombre estructura> <nombre variable matriz> [<dimensión>];

Si nos resulta más fácil podríamos entender una estructura como el tipo de datos de la matriz.

Ejemplo: struct PERSONA personas[20];

Acceso a un campo de una matriz de estructura: <nombre variable matriz>[<numero celda>].<nombre_campo>

Ejemplo:

printf("EI nombre de la primer persona es: %s",personas[0].nombre);

Creación de una estructura con un campo que es a su vez otra estructura:

struct <nombre estructura hijo>




{<tipo dato campoh1> <nombre campoh1>;<tipo dato campoh2> <nombre campoh2>;...<tipo dato campohN> <nombre campohN>;

}

struct <nombre estructura padre> {

<tipo dato campop1> <nombre campop1>; ...struct <nombre estructura hijo> <nombre campo estructura hijo>; ...<tipo dato campopN> <nombre campopN>;

}

(NOTA): En algunos lenguajes de programación es necesario crear primero la estructura hijo y después la padre.

Es en estos momentos en los que el lector se puede dar cuenta de lo enrevesado que puede ser nuestro lenguaje de programación, y por lo tanto lo mucho que necesita cuidar la sintaxis.

Ejercicios propuestos

(Estructuras simples) 27°) Realizar un programa en el que creemos una estructura CLIENTE que

contendrá los datos que creamos mas importantes de un usuario de un videoclub, posteriormente crearemos una variable de dicha estructura, para que el usuario introduzca los nombres de los campos y para poder visualizarlos posteriormente

28°) Realizar un programa en el que creemos una estructura denominada "LIBROS" formada por los siguientes campos:

nombre autor fechaEscrito edicion precIo disponible




posteriormente crearemos una variable de dicha estructura a la que llamaremos "quijote", introduciremos valores en todos sus campos y visualizaremos los campos.

29°) Una persona nos ha pedido que realicemos un programa en el que pueda introducir por teclado los datos más importantes de su película favorita y los datos más importantes del director de dicha película de tal forma que, una vez introducidos por teclado todos estos datos, la persona quiere escribir por teclado el nombre de cualquier director y si coincide con el que escribió previamente quiere que se imprima por pantalla los datos que se almacenaron de la película.

(Matrices de estructuras) 30º) Realizar un programa que permita introducir por teclado los datos de veinte

personas y posteriormente visualice dichos datos.

31°) Realizar un programa que permita introducir por teclado los datos de veinte libros (usaremos la misma estructura "LIBROS" creada en el ejercicio 28) y posteriormente visualice tales datos.

(EJERCICIO LATOSO) 32°) Realizar el ejercicio número veintinueve declarando una matriz de diez

estructuras "PELlCULAS" otra matriz de diez estructuras "DIRECTOR".

(Estructura con campo estructura) 33° Realizar un programa que cree una estructura "MOTOR" y otra estructura

"COCHE" de tal forma que la estructura "MOTOR" tendrá datos relevantes del motor de un coche y la estructura coche tendrá datos relevantes sobre un coche y sobre su motor. Una vez creadas las estructuras declarar una variable de la estructura "MOTOR", rellenar sus campos (los de la estructura "MOTOR" también) y visualizar dichos campos.



Curso de programación en C y C++ · Documento: Curso de programación en C y C++ Fecha: 28/07/2010...

Documents

Transcript of Curso de programación en C y C++ · Documento: Curso de programación en C y C++ Fecha: 28/07/2010...