Beruflich Dokumente
Kultur Dokumente
Juan XXIII
Laboratorio de Computadoras
Gustavo A. Yarce
1. Introducción 7
1.1. Problemas computacionales . . . . . . . . . . . . . . . . . . . . . . 7
1.2. Etapas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.1. Definición del problema . . . . . . . . . . . . . . . . . . . . 7
1.2.2. Análisis del problema . . . . . . . . . . . . . . . . . . . . . . 7
1.2.3. Programación . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2.4. Prueba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2.5. Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3. PROGRAMACIÓN MODULAR . . . . . . . . . . . . . . . . . . . 9
1.4. Documentación de Programas . . . . . . . . . . . . . . . . . . . . . 10
2. El Lenguaje C 11
2.1. Marco histórico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2. Características . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3. Creación del programa . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4. Compilación de C . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.1. Descripción . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5. Entorno de programación . . . . . . . . . . . . . . . . . . . . . . . . 13
2.6. Bibliotecas estándares . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.7. Componentes del lenguaje C . . . . . . . . . . . . . . . . . . . . . . 15
2.8. Estructura de un fichero fuente . . . . . . . . . . . . . . . . . . . . 16
2.9. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.10. CONSTANTES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.11. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.11.1. Variables locales y globales . . . . . . . . . . . . . . . . . . . 18
2.12. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.12.1. Calificadores de tipo . . . . . . . . . . . . . . . . . . . . . . 20
2.13. Secuencias de escape . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.14. Inclusión de ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.15. Operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.16. Operadores de asignación . . . . . . . . . . . . . . . . . . . . . . . . 23
3
4 Gustavo A. Yarce
4. Control de Programas 37
4.1. Instrucción FOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2. Instrucción WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.3. Instrucción DO...WHILE . . . . . . . . . . . . . . . . . . . . . . . . 39
5. Funciones 41
5.1. Paso de parámetros a una función . . . . . . . . . . . . . . . . . . . 47
6. Arrays 51
6.1. Vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.2. Operaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.3. Múltiples dimensiones . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.4. Paso de parámetros a una función . . . . . . . . . . . . . . . . . . . 53
7. Gráficos 55
7.1. Librería WinbGim . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
7.2. Instrucciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
7.2.1. initwindow . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
7.2.2. getmaxx . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
7.2.3. getmaxy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
7.2.4. moveto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.2.5. setcolor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.2.6. setbkcolor . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.2.7. cleardevice . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.3. funciones de dibujo . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.3.1. putpixel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.3.2. line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.3.3. lineto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
7.3.4. circle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
7.3.5. rectangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Laboratorio de Computadoras 5
8. Cadenas de texto 59
8.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
8.2. Comandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
9. Punteros 61
9.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.2. Punteros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
9.2.1. Declaración . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
9.2.2. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
9.3. Asignación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9.4. Aritmética de direcciones . . . . . . . . . . . . . . . . . . . . . . . . 64
Prologo
Este documento no pretende ser un libro completo sobre programación, es una
ayuda para el alumno, para su utilización como guía de aprendizaje.
Se tiene como objetivo presentar los conceptos básicos y las características gen-
erales del lenguaje C que posibiliten la realización de programas para la repre-
sentación de soluciones de problemas reales en una computadora.
Los temas tratados y el desarrollo que se realiza sobre ellos persiguen la enseñan-
za en entornos educativos técnicos de nivel medio que necesitan conocimientos de
informática como una herramienta para la resolución de problemas.
Se prioriza la enseñanza de una metodología de programación correcta tratando
de conservar la facilidad de uso como herramienta. Siempre se considera que lo
más importante es adquirir una base de conocimientos que permita una posterior
evolución hacia conocimientos relacionados con la Electrónica y la programación.
Capítulo 1
Introducción
1.2. Etapas
1.2.1. Definición del problema
Está dada por la formulación del problema en forma correcta y completa. Esta
enunciación de lo que se desea es primordial para el éxito de la resolución.
Condiciones: una o más relaciones que vinculan los dos conjuntos anteriores
y que permitirán plantear la solución del problema.
7
8 Gustavo A. Yarce
1.2.3. Programación
Esta etapa consiste en obtener la solución del problema dado. Se divide en dos
subetapas:
Programa
Un programa es una sucesión de instrucciones que pueden ser ejecutadas por
la PC. De modo general la PC comprende, sin traducción previa, los llamados
comando en lenguaje máquina, que son específicos del procesador.
Este tipo de lenguaje resulta ser bastante engorroso para realizar operaciones sim-
ples. Con el fin de vencer esta dificultad, se desarrollaron los lenguajes superiores de
programación. El programador no tiene que preocuparse por la estructura interna
de la PC, ya que puede trabajar en un lenguaje relativamente simple, transformar
un determinado algoritmo en un programa adecuado.
Un lenguaje de programación lo único que realiza es la traducción escrita en lengua-
je máquina de las diferentes instrucciones escrita en un lenguaje superior.
Aquí pueden acreditarse dos procedimientos:
1.2.4. Prueba
Esta etapa consiste en la ejecución del código del método elegido, es decir,
suministrar los datos al computador, y obtener los resultados. Luego se analizarán
los mismos determinando si son realmente los esperados. Caso contrario, deberán
analizarse las etapas previas, comenzando por la última hacia atrás, y realizar
las modificaciones necesarias, repitiendo esta proceso hasta obtener los resultados
esperados.
Laboratorio de Computadoras 9
1.2.5. Algoritmo
En relación al algoritmo, deseamos aún entrar con detalle en unos conceptos
que son independientes del procedimiento de notación y de la descripción formal.
En primer lugar tenemos:
los módulos deben ser pequeños para que sean claros y de poca complejidad.
un módulo debe tener una estructura de caja negra, es decir la salida debe
ser exclusivamente función de la entrada.
cada módulo deber tener una única entrada y una única salida.
10 Gustavo A. Yarce
El Lenguaje C
2.2. Características
El lenguaje C tiene muy pocas reglas sintácticas, sencillas de aprender. Su léx-
ico es muy reducido: tan solo 32 palabras. A menudo se le llama lenguaje de medio
nivel, más próximo al código máquina que muchos lenguajes de más alto nivel. Y
por eso mismo es un lenguaje muy eficiente. Permite el uso del lenguaje ensam-
blador en partes del código, trabaja a nivel de bit, y permite modificar los datos
con operadores que manipulan bit a bit la información. También se puede acceder
a las diferentes posiciones de memoria conociendo su dirección. El lenguaje C per-
11
12 Gustavo A. Yarce
2.4. Compilación de C
En el siguiente apartado se muestran las distintas etapas que cubre el compi-
lador para obtener el código ejecutable:
1. Código Fuente
2. Preprocesador
3. Compilador
4. Código Ensamblador
5. Ensamblador
6. Librerías
7. Código Objeto
8. Ligador
9. Código Ejecutable
Laboratorio de Computadoras 13
2.4.1. Descripción
El proceso puede ser el globalmente dividido en varios programas:
- Preprocesador: el proceso de archivo de origen antes de la compilación. Que,
por ejemplo, controlar y sustituir los archivos de macros e incluir en su fuente. -
Compilador: transformar su archivo de origen en el código de ensamble (procesador
de lenguaje humanamente legible) - Ensamblador: toma el código de ensamble
y generar código legible por máquina (código objeto binario) - Linker: reúne y
resuelve objeto códigos juntos para crear un único ejecutable.
Ejemplo de programa en C
#include <stdio.h>
main()
{
/* Escribe un mensaje */
printf (‘‘Hola, mundo\n’’);
}
literales
tipos enumerados
punteros y vectores
Construcciones algorítmicas
construcciones iterativas(while,for,do...while)
subrutinas (funciones)
comentarios
16 Gustavo A. Yarce
inclusión de ficheros
macros
compilación condicional
#include <biblioteca1.h>
#include <biblioteca2.h>
... declaraciones de funciones ...
main()
{
... cuerpo del main ...
}
2.9. Comentarios
En C, tienen la forma /* cualquier texto */
2.10. CONSTANTES
Se define a una constante, como un elemento cuyo valor que no puede alterarse
en el transcurso de la ejecución de un algoritmo. Por ejemplo: 123, ’López’, 3.14459.
2.11. Variables
En un programa existen otros elementos cuyo valor cambia durante la ejecución
del mismo, llamados variables.
Una variable es un elemento o lugar asociado a un valor el que puede variar con-
forme se ejecuta el algoritmo, se representa por un nombre que identifica a una
posición de memoria donde puede asignarse o almacenarse un único valor por vez.
Para proponer el nombre de una variable observaremos tres reglas simples:
1. Utilizar sólo letras y/o dígitos, comenzando siempre con una letra.
Una variable sólo puede pertenecer a un tipo de dato. Para poder utilizar una
variable, primero tiene que ser declarada:
Es posible inicializar y declarar más de una variable del mismo tipo en la misma
sentencia:
#include <stdio.h>
#include <conio2.h>
/* Declaración de variables */
#include <stdio.h>
#include <conio2.h>
int a;
main() /* Muestra dos valores */
{
int b=4;
printf("b es local y vale %d",b);
a=5;
printf("\na es global y vale %d",a);
getch)();
}
10mm
Laboratorio de Computadoras 21
#include <stdio.h>
#include <conio2.h>
Para indicar al compilador que vamos a incluir ficheros externos podemos hac-
erlo de dos maneras (siempre antes de las declaraciones).
22 Gustavo A. Yarce
#include "misfunc.h"
#include "c:\includes\misfunc.h"
#include <misfunc.h>
1. binarios:
+ Suma
-Resta
* Multiplicación
/ División
% Módulo (resto)
Su sintaxis es:
<variable1><operador><variable2>
2. unarios:
++ Incremento (suma 1)
- -Decremento (resta 1)
- Cambio de signo
Su sintaxis es:
#include <stdio.h>
#include <conio2.h>
= Asignación simple
+= Suma
-= Resta
*= Multiplicación
/= División
%= Módulo (resto)
Con estos operadores se pueden escribir, de forma más breve, expresiones del
tipo:
Ejemplo 2.5
#include <stdio.h>
#include <conio2.h>
( ) Mayor precedencia
++, - -
*, /, %
+, -Menor precendencia
Las operaciones con mayor precedencia se realizan antes que las de menor
precedencia.
Si en una operación encontramos signos del mismo nivel de precedencia, dicha op-
eración se realiza de izquierda a derecha. A continuación se muestra un ejemplo
sobre ello:
a*b+c/d-e
1. a*b resultado = x
2. c/d resultado = y
Laboratorio de Computadoras 25
3. x+y resultado = z
4. z-e
Fijarse que la multiplicación se resuelve antes que la división ya que está situada
más a la izquierda en la operación. Lo mismo ocurre con la suma y la resta.
Ejemplo 2.6
/* Jerarquía de los operadores */
#include <stdio.h>
#include <conio2.h>
printf(control,arg1,arg2...);
Ejemplo 2.7
/* Uso de la sentencia printf() 1. */
#include <stdio.h>
#include <conio2.h>
%c Un único caracter
%d Un entero con signo, en base decimal
%u Un entero sin signo, en base decimal
%o Un entero en base octal
%x Un entero en base hexadecimal
%e Un número real en coma flotante, con exponente
%f Un número real en coma flotante, sin exponente
%s Una cadena de caracteres
%p Un puntero o dirección de memoria
Ejemplo 2.8
#include <stdio.h>
#include <conio2.h>
main() /* Modificadores 1 */
{
Laboratorio de Computadoras 27
Longitud: especifica la longitud máxima del valor que aparece por pantalla.
Si la longitud es menor que el número de dígitos del valor, éste aparecerá
ajustado a la izquierda.
Ejemplo 2.9
/* Uso de la sentencia printf() 3. */
#include <stdio.h>
#include <conio2.h>
main() /* Modificadores 2 */
{
char cad[ ]="El valor de";
int a=25986;
long int b=1976524;
float c=9.57645;
printf("%s a es %9d\n",cad,a);
28 Gustavo A. Yarce
printf("%s b es %ld\n",cad,b);
printf("%s c es %.3f",cad,c);
getch();
}
scanf(control,arg1,arg2...);
Ejemplo 2.10
/* Uso de la sentencia scanf(). */
#include <stdio.h>
#include <conio2.h>
scanf("%d",&edad);
getch();
}
getch - Espera hasta que se pulse una tecla, pero no la muestra en pantalla.
BLACK
BLUE
GREEN
CYAN
RED
MAGENTA
BROWN
LIGHTGRAY
DARKGRAY
LIGHTBLUE
LIGHTGREEN
LIGHTCYAN
LIGHTRED
LIGHTMAGENTA
YELLOW
WHITE
Una última consideración: en MsDos sólo se pueden usar como colores de fondo
los 7 primeros: desde BLACK hasta LIGHTGRAY. Esto se puede evitar con las
pantallas VGA, a cambio de perder la posibilidad de que el texto parpadee, pero
no voy a entrar en esos detalles. El caso es que n̈ormalmentes̈i hacemos algo como
textbackground(LIGHTBLUE);
textbackground(BLUE);
main()
{
textbackground(BLUE); /* Fondo de la pantalla en azul */
clrscr(); /* Borro la pantalla */
for(i=0; i<=1; i++) /* Dos columnas */
for(j=0; j<=15; j++) /* Los 16 colores */
{
gotoxy(10+ 40*i , 3+j); /* Coloco el cursor */
textcolor(j); /* Elijo el color */
if (j == 0) /* Si el color es 0 (negro) */
textbackground(LIGHTGRAY); /* dejo fondo gris */
else /* Si es otro color */
textbackground(BLACK); /* dejo fondo negro */
cprintf(" Este es el color %d ",j); /* Escribo en color */
}
getch(); /* Final: espero a que se pulse una tecla, sin mostrarla */
}
32 Gustavo A. Yarce
Capítulo 3
Este tipo de sentencias permiten variar el flujo del programa en base a unas
determinadas condiciones. Existen varias estructuras diferentes:
>Mayor que
<Menor que
>= Mayor o igual que
<= Menor o igual que
== Igual que
!= Distinto que
33
34 Gustavo A. Yarce
if (condición)
sentencia1;
else
sentencia2;
#include <stdio.h>
if (condición) sentencia1;
else if (condición) sentencia2;
else if (condición) sentencia3;
else sentencia4;
Ejemplo 3.2
/* Uso de la sentencia condicional ELSE...IF. */
#include <stdio.h>
switch (variable){
case contenido_variable1: sentencias;
case contenido_variable1: sentencias;
default:
switch (variable){
case contenido_variable1:
sentencias;
break;
case contenido_variable2:
sentencias;
break;
default:
sentencias;
}
36 Gustavo A. Yarce
Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves,
ya que se ejecutan todas hasta que se encuentra la sentencia BREAK. La variable
evaluada sólo puede ser de tipo entero o caracter. default ejecutará las sentencias
que incluya, en caso de que la opción escogida no exista.
Ejemplo 3.3
/* Uso de la sentencia condicional SWITCH. */
#include <stdio.h>
Control de Programas
La mayor parte de los programas incluyen repeticiones o ciclos. Los bucles son
estructuras que permiten ejecutar partes del código de forma repetida mientras se
cumpla una condición.
Esta condición puede ser simple o compuesta de otras condiciones unidas por
operadores lógicos. Según cómo queramos que se controle ese bucle, tenemos tres
for: La orden se repite desde que una variable tiene un valor inicial hasta
que alcanza otro valor final.
while: Repite una sentencia mientras que sea cierta la condición que in-
dicamos. La condición se comprueba antes de realizar la sentencia.
Las diferencias son: for normalmente se usa para algo que se repite un número
fijo de veces, mientras que "while"se basa en comprobar si una condición es cierta,
se repetirá un número mienstras se cumpla la condición.
for (inicialización;condición;incremento)
{
37
38 Gustavo A. Yarce
sentencia1;
sentencia2;
}
Ejemplo 4.1
/* Uso de la sentencia FOR. */
#include <stdio.h>
#include <conio2.h>
for(Inicialización1,inicialización2;condición1,condición2;incremento1,incremento2)
El programa sigue avanzando,no se sale del bucle for, hasta que se cumplen las
dos condiciones.
Ejemplo 4.2
/* Uso de la sentencia WHILE. */
#include <stdio.h>
#include <conio2.h>
do{
sentencia1;
sentencia2;
}while (condición);
Ejemplo 4.3
/* Uso de la sentencia DO...WHILE. */
40 Gustavo A. Yarce
#include <stdio.h>
#include <conio2.h>
}while(seleccion!=’4’);
}
Capítulo 5
Funciones
41
42 Gustavo A. Yarce
Saluda;
Por el contrario una función podría ser la raíz cuadrada: realizar una determina-
da cantidad de instrucciones, destinados a calcular cual es el valor, pero finalmente
tiene que respondernos diciendo qué valor ha obtenido.
En C sólo existen funciones, pero éstas pueden devolver unos valores de tipo
“nulo”, con lo cual equivale a un procedimiento.
Su sintaxis es:
tipo función: puede ser de cualquier tipo de los que conocemos. El valor
devuelto por la función será de este tipo. Por defecto, es decir, si no indicamos
el tipo, la función devolverá un valor de tipo entero (int). Si no queremos
que retorne ningún valor deberemos indicar el tipo vacío (void).
tipo y nombre de argumentos: son los parámetros que recibe la función. Los
argumentos de una función no son más que variables locales que reciben un
valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden
existir funciones que no reciban argumentos.
Las funciones pueden ser llamadas desde la función main o desde otras fun-
ciones. Nunca se debe llamar a la función main desde otro lugar del programa.
Por último recalcar que los argumentos de la función y sus variables locales se
destruirán al finalizar la ejecución de la misma.
Laboratorio de Computadoras 43
Ejemplo 5.1
#include <stdio.h>
#include <conio.h>
main()
{
int num1, num2;
base y exponente son dos valores que se “le pasan” a la función: son sus
“parámetros”, unos datos que la función necesita. En nuestro caso, queremos
elevar un número a otro, luego deberemos indicarle cual es el número que
queremos elevar (la base) y a qué número lo queremos elevar (el exponente).
Ejemplo 5.2
#include <stdio.h>
#include <conio.h>
main()
{
saludo("Eva");
printf("\n");
getch();
}
Esta función es de tipo “void” (nulo), con lo que indicamos que no queremos
que devuelva ningún valor.
Tenemos que “main” es una función, de tipo entero (se considera así si no se
indica el tipo, que es lo que estábamos haciendo hasta ahora), por lo que, podemos
escribir de otra forma el ejemplo de la potencia, sería:
Ejemplo 5.3
#include <stdio.h>
Laboratorio de Computadoras 45
#include <conio.h>
int main()
{
int num1, num2;
Ejemplo 5.4
#include <stdio.h>
#include <conio.h>
/*Cuerpo de la función*/
void funcion(void)
{
printf("%d este valor corresponde a una variable global \n",num);
}
Las funciones también pueden ser escritas en otro archivo. En este caso se lo
indicaremos al compilador mediante la directiva “#include”.
Ejemplo 5.5
#include <stdio.h>
#include <conio.h>
#include <c:\potencia.cpp>
main()
{
int num1, num2;
En una misma función podemos tener más de una instrucción return. La forma
de retornar un valor es la siguiente:
Ejemplo 5.6
#include <stdio.h>
#include <conio.h>
Paso de parámetros.
48 Gustavo A. Yarce
Ejemplo 5.7
#include <stdio.h>
#include <conio.h>
Para enviar un valor por referencia se utiliza el símbolo & ( ampersand ) delante
de la variable enviada. Esto le indica al compilador que la función que se ejecutará
tendra que obtener la dirección de memoria en que se encuentra la variable.
Laboratorio de Computadoras 49
Ejemplo 5.8
#include <stdio.h>
#include <conio.h>
Recursividad
La idea es simplemente que una función recursiva es aquella que se llama a sí
misma. El ejemplo clásico es el factorial de un número:
50 Gustavo A. Yarce
Luego podemos escribir cada factorial en función del factorial del siguiente
número:
n! = n (n-1)!
Pues esta es la definición recursiva del factorial, ni más ni menos. Esto, pro-
gramando, se haría:
Ejemplo 5.9
#include <stdio.h>
#include <conio.h>
long fact(int n)
{
if (n==1) /* Aseguramos que termine */
return 1;
return n * fact (n-1); /* Si no es 1, sigue la recursión */
}
main()
{
int num;
printf("Introduzca un número entero: ");
scanf("%d", &num);
printf("Su factorial es: %ld\n", fact(num));
getch();
}
Capítulo 6
Arrays
6.1. Vectores
Vectores
Un vector es un array unidimensional, es decir, sólo utiliza un índice para
referenciar a cada uno de los elementos. Su declaración será:
Ejemplos:
int vector[]={1,2,3,4,5,6,7,8};
char vector[]="programador";
char vector[]={’p’,’r’,’o’,’g’,’r’,’a’,’m’,’a’,’d’,’o’,’r’};
51
52 Gustavo A. Yarce
Ejemplo 6.1
/* Declaración de un array. */
#include <stdio.h>
#include <conio2.h>
6.2. Operaciones
Las principales operaciones que se pueden realizar son:
Tipo nombre_array[tamaño]={lista_valores};
int lista[6]={2,4,6,8,1,5};
Ejemplo 6.2
#include <stdio.h>
#include <conio.h>
main() /* Rellenamos una matriz */
{
int x,i,numeros[3][4];
/* rellenamos la matriz */
for (x=0;x<3;x++)
for (i=0;i<4;i++)
scanf("%d",&numeros[x][i]);
/* visualizamos la matriz */
for (x=0;x<3;x++)
for (i=0;i<4;i++)
printf("%d",numeros[x][i]);
}
int temp[20]
54 Gustavo A. Yarce
funcionvector(temp,20);
Para modificar el valor de un arreglo con una función y que el valor modificado
pueda ser utilizado posteriormente fuera de la función se debe realizar lo siguiente:
int temp[20]
funcionvector(&temp[0],20);
Gráficos
Una vez realizada la instalación es necesario reiniciar la PC para que las mod-
ificaciones sean actualizadas. Se debe realizar al igual que la librería Conio la
siguiente modificación en el compilador, en “Herramientas” - “Opciones del compi-
lador” - “Añadir estos comandos...”:
55
56 Gustavo A. Yarce
7.2. Instrucciones
7.2.1. initwindow
Esta función inicializa el modo gráfico, creando una ventana del tamaño especi-
ficado. Los parámetros obligatorios de esta función son los dos primeros, ancho y
alto, ambos valores son enteros. Esta instrucción se complementa con la instrucción
“closegraph()”, la cual cierra el modo gráfico.
Ejemplo 7.1
#include <winbgim.h>
#include <conio.h>
main()
{
getch();
closegraph(); // Cierra la ventana gráfica
}
7.2.2. getmaxx
Retorna la coordenada máxima horizontal.
int xmax;
xmax=getmaxx();
7.2.3. getmaxy
Retorna la coordenada máxima vertical.
int ymax;
ymax=getmaxy();
Laboratorio de Computadoras 57
7.2.4. moveto
Se mueve a las coordenadas indicadas
moveto(50,40);
7.2.5. setcolor
Selecciona el color de dibujo y texto indicado. Ej: setcolor(1);
7.2.6. setbkcolor
Selecciona el color de fondo indicado. Ej: setbkcolor(4);
7.2.7. cleardevice
Borra la pantalla. Ej: cleardevice( );
7.3.2. line
line(int x1 , int y1 , int x2 , int y2);
7.3.3. lineto
lineto(int x1 , int y1);
moveto(0,0)
lineto(400 , 400); //traza una diagonal en la pantalla
7.3.4. circle
circle(int x , int y , int radio);
Dibuja un círculo del radio indicado y con centro en x,y. Ej: circle(320,200,20);
7.3.5. rectangle
rectangle(int x1 , int y1 , int x2 , int y2);
7.4.2. settextstyle
settextstyle(int fuente , int dirección , int tamaño);
Selecciona el estilo del texto. Las fuentes más comunes son las que van de 0 a
4. La dirección puede ser: 0 = horizontal y 1 = vertical. El tamaño puede tomar
un valor de 1 a 10. Ej: settextstyle(2,0,5);
Capítulo 8
Cadenas de texto
8.1. Introducción
Una cadena de texto en C no es más que un array de caracteres. Como a todo
array, se le puede reservar espacio. Esto es de la siguiente forma:
char texto[80];
char telefono[8];
dado que hay que almacenar esas 7 y después un “\0”. Si sabemos lo que
hacemos, podemos reservar sólo esas 7, pero tendremos que usar nuestras propias
funciones, porque las que nos ofrece el lenguaje C se apoyan todas en que al final
debe existir ese carácter nulo.
8.2. Comandos
Para copiar el valor de una cadena de texto en otra, no podemos hacer
texto1 = texto2;
porque estaríamos igualando dos punteros. A partir de este momento, las dos
cadenas se encontrarían en la misma posición de memoria, y los cambios que
hiciéramos en una se reflejarían también en la otra.
Se debe usar una función de biblioteca, “strcpy” (string copy), que se encuen-
tra, como todas las que veremos, en “string.h”:
59
60 Gustavo A. Yarce
Para comparar dos cadenas alfabéticamente (para ver si son iguales o para
poder ordenarlas, por ejemplo), usamos
strcmp (cad1, cad2);
Esta función devuelve un número entero, que será:
“0” si ambas cadenas son iguales
negativo, si cad1 < cad2
positivo, si cad1 > cad2
gets (cad);
La llamada “getch()” puede ser utilizada para leer un carácter tecleado. Este
carácter no se visualiza en pantalla
gets (cad);
Punteros
9.1. Introducción
Hasta ahora teníamos una serie de variables que declaramos al principio del
programa o de cada función. Estas variables, que reciben el nombre de ESTÁTI-
CAS, tienen un tamaño asignado desde el momento en que se crea el programa.
Este tipo de variables son sencillas de usar y rápidas, si sólo vamos a manejar
estructuras de datos que no cambien, pero resultan poco eficientes si tenemos
estructuras cuyo tamaño no sea siempre el mismo.
Es el caso de un vector: tenemos una serie de valores, e iremos añadiendo más.
Si reservamos espacio para 10, no podremos llegar a añadir la número 11, estamos
limitando el máximo. Una solución sería la de trabajar siempre en el disco: no
tenemos límite en cuanto a número de valores, pero es muchísimo más lento.
Lo ideal sería aprovechar mejor la memoria que tenemos en el ordenador, para
guardar en ella todas las fichas o al menos todas aquellas que quepan en memoria.
Una solución “típica” (pero mala) es sobredimensionar: preparar un vector con-
tando con 1000 valores, aunque supongamos que no vamos a pasar de 200. Esto
tiene varios inconvenientes: se desperdicia memoria, obliga a conocer bien los datos
con los que vamos a trabajar, sigue pudiendo verse sobrepasado, etc.
Las pilas. Justo como una pila de libros: vamos apilando cosas en la cima, o
quitando de la cima.
Las colas. Como las del cine, por ejemplo (en teoría): la gente llega por un
sitio (la cola) y sale por el opuesto (la cabeza).
61
62 Gustavo A. Yarce
9.2. Punteros
Los punteros, son aquellos que como su nombre lo dice almacenan un espacio en
la memoria virtual dinamicamente, o sea mientras no sea creada la variable dentro
del programa, el espacio en la memoria volatil esta libre.Esta variable contiene la
dirección de memoria de otra variable. Se utilizan para pasar información entre
una función y sus puntos de llamada.
9.2.1. Declaración
Su sintaxis es la siguiente:
tipo *nombre;
9.2.2. Operadores
Existen dos operadores especiales para trabajar con punteros: & y *.
El primero devuelve la dirección de memoria de su operando. Por ejemplo, si
queremos guardar en el puntero x la dirección de memoria de la variable num,
deberemos hacer lo siguiente:
x= #
Laboratorio de Computadoras 63
a=*x;
Por tanto, con el símbolo * indicamos que se trata de un puntero, y & nos
devuelve la dirección de memoria en la que se encuentra una variable.
Lo de “pos=1000” es peligroso, porque no sabemos qué hay en esa dirección,
de modo que si escribimos allí podemos provocar una catástrofe. Por ejemplo, si
ponemos un valor al azar que coincide con la instrucción en código máquina de
formatear el disco duro, no nos hará nada de gracia cuando nuestro programa
llegue hasta esa instrucción. Normalmente las consecuencias no son tan graves,
pero hay que llevar cuidado. La forma de trabajar será pedir al compilador que
nos reserve un poco de memoria donde él crea adecuado
Para eso usamos la orden “malloc” (necesitaremos incluir en la cabecera <
stdlib.h >). Una vez que hemos terminado de usar esa memoria, suele ser conve-
niente liberarla, y para eso empleamos “free”.
“free(pos)” quiere decir “libera la memoria que ocupaba pos”. El de “malloc” es
más rebuscado:
malloc (tamaño)
Como queremos reservar espacio para un entero, ese “tamaño” será lo que ocupe
un entero, y eso nos lo dice “sizeof(int)”.
¿Y eso de (int*)? Es porque “malloc” nos devuelve un puntero sin tipo (un
puntero a void (void*). Cómo queremos guardar un dato entero, primero debemos
hacer una conversión de tipos (typecast), de “puntero sin tipo” a “puntero a entero”
(int *).
64 Gustavo A. Yarce
9.3. Asignación
Los punteros se asignan igual que el resto de las variables. El programa ejem-
plo mostrará las direcciones contenidas en p1 y p2, que será la misma en ambos
punteros.
Ejemplo 9.2
#include <stdio.h>
#include <stdlib.h>