Como Programar en C y No Morir en El Intento
description
Transcript of Como Programar en C y No Morir en El Intento
Como programar en C y no morir en el intento. Autor: Cesar Cárdenas
Fecha: Mayo del 2007
Introducción: En vista y considerando la dificultad de alguna gente para comprender el lenguaje de
programación C he decidido hacer este texto para explicar de forma precisa y sencilla lo
básico de la programación en C, con ejemplos claros y útiles, de manera que se entienda de
buena forma la programación en C.
Este texto no pretende ser una guía completa de C, ya que para eso hay libros dedicados al
tema, con muchos tecnicismos y cosas por el estilo, sino que más bien pretende ser una
ayuda para entender la forma de hacer programas en c de la manera mas optima y sencilla.
Como nos decía un profesor en el colegio: “Aprender es encontrar relaciones entre lo que
uno conoce y lo que quiere conocer”.
Termino citando a un compañero, que dice lo siguiente “El Calculo es tu herramienta”.
Yo le digo “La programación es tu herramienta, y si es bien usada puede ser muy útil”.
Como programar en c y no morir en el intento 2
Índice: Como programar en C y no morir en el intento. ..................................................................... 1
Introducción: ........................................................................................................................... 1
1.- Primeros pasos en C .......................................................................................................... 3
1.1.-Definiciones. ............................................................................................................... 3
1.2.- Estructura general de un programa. ........................................................................... 3
1.3.- Tipos de datos. ........................................................................................................... 4
1.4.- Funciones. .................................................................................................................. 5
1.4.1.- Estructura básica ................................................................................................. 5
1.4.2.- Declaración de variables. .................................................................................... 6
1.4.3- La Función main(). ............................................................................................... 7
1.4.4- Otras funciones básicas. ....................................................................................... 7
2.- Comenzando a programar. ................................................................................................ 9
2.1.- Nuestro primer programa. .......................................................................................... 9
2.2.- Operadores. .............................................................................................................. 11
2.2.1.- Operadores aritméticos. ..................................................................................... 11
2.2.2.- Operadores de asignación ................................................................................. 13
2.2.3-. Operadores incrementales. ................................................................................ 13
2.2.4.- Operadores relacionales .................................................................................... 14
2.2.5.- Operadores Lógicos .......................................................................................... 14
2.2.6.- Otros operadores. .............................................................................................. 15
2.3.- Bucles ....................................................................................................................... 16
2.3.1.- Estructuras de control ........................................................................................ 16
2.3.2.- Bucles iterativos ................................................................................................ 20
3.- Otros temas de C ............................................................................................................. 22
3.1-. Vectores y matrices. ................................................................................................. 22
3.1.1.- Los Vectores ...................................................................................................... 22
3.1.2.- Las matrices....................................................................................................... 23
3.2.- Punteros. ................................................................................................................... 24
3.3.-Estructuras. ................................................................................................................ 26
3.4.- Declaracion de tipos ................................................................................................. 28
3.5.- Funciones recursivas ................................................................................................ 29
3.6.- Asignación dinámica de memoria ............................................................................ 30
3.6.1.- Petición de memoria .......................................................................................... 30
3.6.2.- Liberacion de memoria...................................................................................... 33
4.- Temas mas avanzados del C ........................................................................................... 34
4.1.- Listas enlazadas simples .......................................................................................... 34
4.2.- Manejo de ficheros ................................................................................................... 38
4.2.1.-Lectura de ficheros ............................................................................................. 38
Como programar en c y no morir en el intento 3
1.- Primeros pasos en C
1.1.-Definiciones.
Programa: Conjunto de ordenes que se ejecutan en un computador
Cabecera o header: Archivo externo que contiene funciones.
Funciones: Conjunto de acciones al que entra un dato y devuelve un resultado
String: Cadena de texto alfanumérico
Variable: Objeto de c que puede tomar distintos valores
1.2.- Estructura general de un programa.
El lenguaje de programación C, en adelante C, tiene una estructura definida para hacer
programas.
En c la estructura básica esta dada por lo siguiente
Ahora explicare una a una las partes de un programa en c.
Primera parte (1): Declaración de cabeceras:
Aquí se declaran las librerías a usar en nuestro programa, estas son las que nos permiten
usar algunas funciones básicas, como printf(), scanf() y otras que iremos viendo mas
adelante. En C existen muchas librerías las que mas vamos a usar aquí serán:
stdio.h Encargada de las funciones de entrada y salida, como imprimir en pantalla obtener
datos desde el teclado, etc. (Standard input output library)
stdlib.h Encargada de funciones Standard como la pausa, generar números aleatorios, pedir
memoria dinámica, etc.
string.h Encargada de trabajar con cadenas de texto. Tiene funciones para unir cadenas,
cortar cadenas, contar caracteres en una cadena y en general todo lo relacionado con
cadenas.
math.h Encargada de las funciones matemáticas, por ejemplo, seno coseno, valor absoluto,
raíz cuadrada, etc.
Segunda parte (2): Declaración de funciones locales.
Las funciones locales son aquellas que solo se peden usar en nuestro programa y sirven
para ahorrar tiempo de programación, líneas de código, y mucho trabajo.
En esta parte existen dos caminos:
1.- Solo declarar la función (ya veremos esto mas adelante, también se le llama prototipo)
1.1.-Estructura básica de un programa en c
Declaración de cabeceras o headers……………… (1)
Declaración de funciones locales…………………. (2)
Función main() …………………………………….(3)
Completacion de Funciones locales……………….. (4)
Comentarios ………………………………………...(5)
Como programar en c y no morir en el intento 4
1.2.- Tipos de comentarios
/* esto es un comentario
de mas de una línea */
// esto es un comentario de una línea
2.- Declarar y completar la función es decir además de declararla agregar lo que va a hacer
(o se puede agregar lo que va a hacer mas adelante en la parte 4)
Cualquiera de los dos caminos es valido, y todo depende del programador, en lo personal
prefiero utilizar el segundo método.
Tercera parte (3): Función main( ).
La función main es la función principal de un programa en c, en ella debe ir lo que hará
nuestro programa, ósea lo que imprimirá por pantalla y lo que recibirá por teclado, etc.
Entenderán mejor esta función cuando lleguemos a la parte de funciones.
Cuarta parte (4): Completacion de Funciones locales.
Como dije en la parte 3 se puede poner aquí lo que va a hacer cada función, esto sirve para
poder tener mas despejada la parte superior del programa y ver el main mas fácilmente.
Quinta parte (5): Comentarios.
Los comentarios son utilizados por el programador para poder dejar ideas o funcionalidades
que se le puedan olvidar o poder explicar partes que puedan ser difíciles de entender para
otros programadores.
Los comentarios pueden ir en cualquier parte del programa y para utilizarlos hay dos
formas, que son las siguientes:
Como podrán ver esta el la parte aburrida de la programación en C, pero esperen que ya
viene lo entretenido… jajaja.
1.3.- Tipos de datos.
Los tipos de datos en C se refieren a los tipos de valores que puede tomar una variable, los
Que mas usaremos son
int Se refiere a una variable del tipo entero con signo. Se representa por %i
char Se refiere a una variable del tipo carácter (una letra). Se representa por %c
long Se refiere a un entero grande. Se representa por %li
unsigned long Se refiere a un entero sin signo grande. Se representa por %ul
float Se refiere a un número decimal. Se representa por %f
double Se refiere a un número real grande. Se representa por %d
void Se refiere a un dato nulo.
string se usa para representar cadenas de caracteres. Se representa por %s (no es tipo)
Para mas tipos de datos y tecnicismos sobre tamaño y cosas así lean el libro “ANSI C como
si estuviera en primero” o cualquier otro que puedan descargar de Internet
Como programar en c y no morir en el intento 5
1.4.- Funciones.
1.4.1.- Estructura básica
Como vimos anteriormente uno de los conceptos básicos de C son las funciones, ya que las
funciones son muy útiles a la hora de hacer programas que realizan una acción más de una
vez, porque ahorran tiempo y facilitan el entendimiento y desarrollo de un programa.
Pero ¿Qué es una función? Se preguntaran ustedes.
Como en las matemáticas las funciones son modificadores según algo ingresado, por
ejemplo la función seno y la función coseno, operan sobre un valor y devuelven otro valor.
En C una función recibe un parámetro y devuelve el mismo parámetro modificado u otro
según conveniencia del programa.
El esquema general de una función es:
1 2 3 4
lo_que_devuelve Nombre(lo_que_recibe){lo_que_hace}
1.- Lo que devuelve: Aquí va el tipo de dato que devuelve la función, puede ser un
entero(int), un carácter(char), un flotante(float), etc.
2.- Nombre: Este es el nombre por el cual se identifica una función, este debe ser único
para cada función y distinto de nombre de variables para evitar confusiones y errores en el
programa.
3.- Lo que recibe: Una función puede recibir mas de un dato y de distinto tipo, cada dato
que va entrar a la función debe estar definido como: tipo_de_dato nombre_del_dato
donde tipo puede ser cualquier tipo de dato como int, float, etc. Y el nombre es un nombre
que se usara dentro de la función.
4.- Lo que hace: Son las acciones que realizara la función sobre los datos ingresados para
devolver algo, aunque a veces la función no devuelve nada
Hasta ahora solo conocemos la estructura general de una función pero podemos hacer una
función que nos sirva de ejemplo para entender mejor su funcionamiento.
Creare la función suma que recibirá dos enteros y devolverá otro entero que será el
resultado de la suma.
1.3.-Función Suma
int suma(int a, int b){
int resultado; /*declaración de variables*/
resultado = a+b; /*suma a con b y lo guarda en resultado*/
return resultado; /*devuelve resultado */
}
Como programar en c y no morir en el intento 6
1.4.- Declaración general de variables
Tipo_de_variable nombre_variable;
1.5.- Declaración de más de una variable
Tipo_de_variable nombre_variable1, nombre_variable2, … ,nombre_variablen;
1.6.- Ejemplo declaración general de variables
int entero_1, entero_2, entero_3;
char caracter;
Este ejemplo sirve para mostrar varias cosas importantes en C.
Primero: Para terminar una línea o orden se usa un ; que es lo que le dice al programa que
ahí termina la línea, de no usar ; el programa no funcionaria por que no podría diferenciar
cuando terminar de ejecutar una orden.
Entonces ¿Por qué no hay ; después de los paréntesis de corchetes }?
Por que los paréntesis de corchete {} sirven para delimitar un bloque de código, así que en
vez del ; son ellos los que le dicen al programa donde terminar, es por esto que no necesitan
un elemento adicional para poder decirle al programa que ahí termia el código.
Segundo: Es importante hacer notar que C distingue mayúsculas de minúsculas, es decir,
no es lo mismo poner Suma() que suma() ni que SUMA(), todas estas serian tratadas como
funciones distintas.
1.4.2.- Declaración de variables.
Las variables son elementos muy útiles al momento de realizar un programa ya que pueden
ser usadas para guardar datos ingresados por teclado o constantes o algo que se nos ocurra.
La declaración de variables puede hacerse solo al inicio de las funciones, antes del resto del
código y siempre antes de que la variable sea utilizada ya que de no estar declarada nuestro
programa no funcionara.
Para declarar una variable debemos seguir la siguiente estructura:
Donde tipo de variable puede ser cualquiera de los soportados por C, como int, float,
double, char, unsigned long, etc.
Para declarar más de una variable del mismo tipo se hace de la siguiente manera:
Por ejemplo si queremos declarar 3 variables del tipo entero y una variable del tipo carácter
lo hacemos de la siguiente forma:
Como programar en c y no morir en el intento 7
1.7.- Declaración general de la función main
int main(void){
nuestro código aquí;
}
1.8.- Declaración general de la función printf()
printf(“Lo que se va imprimir (variables)”,variable1,variaable2…,variablen);
1.9.- Declaración general de la función scanf()
scanf(“%tipo_de_variable”,&nombre_variable);
Ahora que ya sabemos que es una función y como se usa podemos avanzar un poco mas y
tratar la función principal de c, la que nunca puede faltar en nuestros programas, la función
main().
1.4.3- La Función main().
Dedico una apartado especia a esta función por que es la función principal de C.
Esta función como cualquier otra debe atenerse alas mismas reglas, con la excepción que
no debemos declararla ya que ya esta declarada.
Su estructura como la de todas las funciones es:
1 2 3 4
lo_que_devuelve main(lo_que_recibe){lo_que_hace}
en nuestro caso haremos que la función main retorne un entro y que no reciba nada por lo
que quedara de la siguiente manera:
1.4.4- Otras funciones básicas.
1.4.4.1.- La función printf().
La función printf() es una de las mas utilizadas, aunque no la única, para imprimir datos por
pantalla, ósea mostrar datos y mensajes en la pantalla del computador.
Su utilización general es
Esta función esta definida en la librería stdio.h y se usa dentro de otras funciones, puede ser
main() o alguna declarada por nosotros.
Lo de las variables lo veremos en el siguiente capitulo.
1.4.4.2.- La función scanf().
Esta función tiene por misión obtener datos ingresados desde el telado y guardarlos en una
variable.
Su estructure general es:
%tipo_de_variable se refiere al tipo de variable que el usuario va ingresar, es decir, entero,
flotante, carácter, etc, en si representación % (%i, %s, %c, %f…).
&nombre_variable es el nombre de la variable donde guardaremos lo ingresado por el
usuario.
Como programar en c y no morir en el intento 8
1.10.- Uso de la función system(“pause”)
system(“pause”);
1.11.- Uso de la función system(“cls”)
system(“cls”);
1.4.4.2.- La función system(“pause”).
La función system(“pause”) se usa para crear una pausa en el sistema hasta que el usuario
presione una tecla su uso es:
1.4.4.3.- La función system(“cls”).
La función system(“cls”) se usa para “limpiar” la pantalla, es decir borrar todo lo que
aparece dejando el cursor en el principio de la primera línea su uso es:
Como programar en c y no morir en el intento 9
2.1.- Nuestro primer programa
#include <stdio.h> //declaración de librería stdio
#include <stdlib.h> //declaración de librería stdlib
/*declaramos al función suma */
int suma(int a, int b){
int resultado; /*declaración de variables*/
resultado = a+b; /*suma a con b y lo guarda en resultado*/
return resultado; /*devuelve resultado */
}
/*comienza el programa con la función main */
int main(void){
int num_1, num_2; /*declaramos 2 variables enteras */
printf(“Ingrese un numero :”); /*mostramos mensaje en pantalla */
scanf(“%i”,&num_1); /* capturamos dato desde el teclado */
printf(“\nIngrese un numero :”); /*mostramos mensaje en pantalla */
scanf(“%i”,&num_2); /* capturamos dato desde el teclado */
printf(“\n%i + %i = %i\n”,num_1,num_2,suma(num_1,num_2)); /* Imprime resultado */
system(“pause”); /*Para que la pantalla se mantenga */
return 0; /*devolvemos un 0 */
}
2.- Comenzando a programar.
Hasta ahora solo hemos visto teoría sobre la programación en C, pero ahora vamos a ir a la
parte mas practica de la programación.
Para no empezar con el típico ejemplo de mostrar en la pantalla hola mundo vamos a
empezar con algo mas entretenido y usando lo que ya conocemos del capítulo anterior
2.1.- Nuestro primer programa.
Como conocemos la estructura básica de un programa y además sabemos como declarar
funciones vamos a mezclar esto para comenzar a programar.
Lo primero que haremos será un programa que sume dos números ingresado por el teclado,
para esto utilizaremos la función suma que definimos al comienzo.
Este pequeño programa suma dos números ingresados por el usuario y muestra cuanto vale
la suma
Otra forma análoga de hacer esto mismo pero guardando el resultado en una variable seria
algo así:
Como programar en c y no morir en el intento 10
2.2.- Variación del ejemplo 1
#include <stdio.h> //declaración de librería stdio
#include <stdlib.h> //declaración de librería stdlib
/*declaramos al función suma */
int suma(int a, int b){
int resultado; /*declaración de variables*/
resultado = a+b; /*suma a con b y lo guarda en resultado*/
return resultado; /*devuelve resultado */
}
/*comienza el programa con la función main */
int main(void){
int num_1, num_2, resultado; /*declaramos 3 variables enteras */
printf(“Ingrese un numero :”); /*mostramos mensaje en pantalla */
scanf(“%i”,&num_1); /* capturamos dato desde el teclado */
printf(“\nIngrese un numero :”); /*mostramos mensaje en pantalla */
scanf(“%i”,&num_2); /* capturamos dato desde el teclado */
resultado = suma(num_1,num_2); /*Guardamos el retorno de la función en resultado*/
printf(“\n%i + %i = %i\n”,num_1,num_2,resultado); /*mostramos los datos en pantalla */
system(“pause”); /*Para que la pantalla se mantenga */
return 0; /*devolvemos un 0 */
}
2.3.- Otra variación del ejemplo 1
#include <stdio.h> //declaración de librería stdio
#include <stdlib.h> //declaración de librería stdlib
int suma(int a, int b); /*declaramos al función suma */
/*comienza el programa con la función main */
int main(void){
int num_1, num_2; /*declaramos 2 variables enteras */
printf(“Ingrese un numero :”); /*mostramos mensaje en pantalla */
scanf(“%i”,&num_1); /* capturamos dato desde el teclado */
printf(“\nIngrese un numero :”); /*mostramos mensaje en pantalla */
scanf(“%i”,&num_2); /* capturamos dato desde el teclado */
printf(“\n%i + %i = %i\n”,num_1,num_2,suma(num_1,num_2)); /* Imprime resultado */
system(“pause”); /*Para que la pantalla se mantenga */
return 0; /*devolvemos un 0 */
} /* termina la función main() */
int suma(int a, int b){ /* completamos la función suma*/
int resultado; /*declaración de variables*/
resultado = a+b; /*suma a con b y lo guarda en resultado*/
return resultado; /*devuelve resultado */
}
Incluso podemos hacer otra modificación mas para dejar de otra manera el programa, en el
siguiente caso solo declararemos la función sobre main y la completaremos después del
main y el programa seguirá haciendo lo mismo (sumar dos números ingresados por
teclado).
Como programar en c y no morir en el intento 11
Algo que puede llamar la atención es el \n que aparece en algunos printf(), bueno no es mas
que un retorno de línea, ósea cundo printf() imprime en pantalla imprime todo de corrido,
pero al poner \n imprime lo que viene después en una nueva línea, aparte de \n existen otros
“caracteres especiales” como el \r que es el retorno de carro (vuelve al principio de la línea
nueva) o \t que es una tabulacion o espacio de sangría, si quieres conocer mas de estos
caracteres busquen una lista de ellos o revisen el libro “ANSI C como si estuviera en
primero”.
Como podemos ver este programa no tiene un uso practico muy importante, pero si un uso
educacional tremendo ya que de el se pueden sacar mas ejemplos y seguir haciendo
modificaciones.
2.2.- Operadores.
Una parte muy importante de C son los operadores, estos, como su nombre lo indica,
operan sobre alguna variable. Pueden ser un carácter o mas de uno y pueden actuar sobre
una, dos o tres variables. Existen varios tipos de operadores entre ellos los operadores
lógicos, operadores aritméticos, operadores de asignación, operadores incrementales,
operadores relaciónales, los cuales comenzaremos por describir y enseñar su
funcionamiento.
2.2.1.- Operadores aritméticos.
Estos operadores son uno de los mas fáciles de entender ya que son muy conocidos y
usados en al vida cotidiana.
Los operadores aritméticos son:
Suma +
Resta -
Multiplicación *
División /
Modulo %
El único de ellos que merece explicación es el modulo (%) ya que tiene dos usos el
primero es saber el resto de la división entre 2 números, por ejemplo 5%2=1 y 2%2=0.
Otra cosa que cabe notar es que el operador división calcula la división exacta de dos
números si se guarda en un flotante y si se guarda en un entero aproxima al menor numero
mas cercano, con los números anteriores esto seria 5/2=4 y 2/2=1.
Ahora veamos esto en un ejemplo:
Cree un programa que reciba 3 números ingresados por teclado, los sume y
muestre el resultado en pantalla, luego debe recibir otros 3 números,
sumarlos y mostrar el resultado en pantalla. Como restricción la suma se
debe hacer mediante una función.
Como programar en c y no morir en el intento 12
2.4.- Ejemplo de operadores
#include <stdio.h> //declaración de librería stdio
#include <stdlib.h> //declaración de librería stdlib
/*comienza el programa con la función main */
int main(void){
int num_1, num_2, resultado; /*declaramos 3 variables enteras */
printf(“Ingrese un numero :”); /*mostramos mensaje en pantalla */
scanf(“%i”,&num_1); /* capturamos dato desde el teclado */
printf(“\nIngrese un numero :”); /*mostramos mensaje en pantalla */
scanf(“%i”,&num_2); /* capturamos dato desde el teclado */
resultado = num_1+num_2; /*sumamos los dos números y los guardamos*/
printf(“\n%i + %i = %i\n”,num_1,num_2,resultado); /*mostramos los datos en pantalla */
resultado = num_1-num_2; /*restamos los dos números y los guardamos*/
printf(“\n%i - %i = %i\n”,num_1,num_2,resultado); /*mostramos los datos en pantalla */
resultado = num_1*num_2; /*multiplicamos los dos números y los guardamos*/
printf(“\n%i * %i = %i\n”,num_1,num_2,resultado); /*mostramos los datos en pantalla */
resultado = num_1/num_2; /*dividimos los dos números y los guardamos*/
printf(“\n%i / %i = %i\n”,num_1,num_2,resultado); /*mostramos los datos en pantalla */
resultado = num_1%num_2; /*sacamos modulo los dos números y los guardamos*/
printf(“\n%i m %i = %i\n”,num_1,num_2,resultado); /*mostramos los datos en pantalla */
system(“pause”); /*Para que la pantalla se mantenga */
return 0; /*devolvemos un 0 */
}
En este ejemplo podemos notar que las variables se pueden reutilizar y así ahorrar memoria
en el sistema donde se ejecute nuestro programa.
También podemos mezclar operadores para producir operaciones mas complejas y además
podemos asociar expresiones por medio de paréntesis (). Por ejemplo la expresión
2*2+3*10/5=10 y si usamos paréntesis (2*2+3*10)/5=6. esto se puede explicar y predecir
los resultados ya que C tiene un orden de evaluación de los operadores aritméticos que esta
dado por su precedencia, es decir, la importancia que se le asigna a cada operador al
momento de evaluar. La precedencia de los operadores aritméticos es la siguiente por orden
de evaluación * / % + -
Aquí esta el programa para que vean el resultado ustedes mismos
2.5.- Precedencia de operadores
#include <stdio.h> //declaración de librería stdio
#include <stdlib.h> //declaración de librería stdlib
/*comienza el programa con la función main */
int main()
{
int result; /*declaramos 1 variable entera */
result = 2*2+3*10/5; /* guardamos el resultado en result */
printf("%i\n",result); /*mostramos los datos en pantalla */
system(“pause”); /*Para que la pantalla se mantenga */
return 0; /*devolvemos un 0 */
}
Como programar en c y no morir en el intento 13
2.2.2.- Operadores de asignación
Como su nombre lo indica estos operadores tienen la misión de asignar un valor
determinado a una variable. El mas conocido y que ya hemos usado en los ejemplos
anteriores es l operador asignación ( = ), y lo que hace es asignarle el resultado de una
expresión a una variable, también puede asignarle el valor de una variable a otra variable.
Una consideración a tener al usar este operador es que la variable a al cual se le va asignar
el valor debe ir a la izquierda del operador, es decir seria incorrecto hacer a+b=c; ya que a
la izquierda hay una expresión en vez de una variable.
Otros operadores de asignación son:
+= Su uso es a +=expresion; equivale: a = a+expresión;
-= Su uso es a -= expresión; equivale: a = a-expresión;
*= Su uso es a *=expresion; equivale: a = a*expresión;
/= Su uso es a /=expresion; equivale: a = a/expresión;
2.2.3-. Operadores incrementales.
Estos operadores son solo 2, ellos son ++ y --. Como su nombre lo indica se encargan de
incrementar y decrementar una variable.
Se pueden usar de 2 formas para preincrementar y predecrementar o para postincrementar y
postdecrementar, lo que quiere decir que incrementa o decrementa la variable antes de
usarla y incrementa o decrementa la variable después de usarla.
Su uso es el siguiente:
++a aumenta en 1 la variable a y después la usa
a++ usa la variable a y después la aumenta en 1
--a disminuye en 1 la variable a y después la usa
a-- usa la variable a y después la disminuye en 1
Como podrán ver los resultados son los siguientes:
2.6.- Decremento e incremento
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a=10,b;
b = a++; /* postincremento de a y guardado en b */
printf("a vale %i y b vale %i\n",a,b);
b= ++a; /* preincremento de a y guardado en b */
printf("a vale %i y b vale %i\n",a,b);
b = a--; /* postdecremento de a y guardado en b */
printf("a vale %i y b vale %i\n",a,b);
b= --a; /* predecremento de a y guardado en b */
printf("a vale %i y b vale %i\n",a,b);
system("pause");
return 0;
}
Como programar en c y no morir en el intento 14
2.2.4.- Operadores relacionales
Como su nombre lo indica estos operadores se encargan de procesar relaciones entre
expresiones y variables.
Los operadores relacionales son:
igual que == Verdad si las dos expresiones son iguales
menor que (exp_1)<(exp_2) Verdad si (exp_1) es menor que (exp_2)
mayor que (exp_1)>(exp_2) Verdad si (exp_1) es mayor que (exp_2)
menor o igual que (exp_1)<=(exp_2) Verdad si (exp_1) es menor o igual que (exp_2)
mayor o igual que (exp_1)>=(exp_2) Verdad si (exp_1) es mayor o igual que (exp_2)
distinto de (exp_1)!=(exp_2) Verdad si (exp_1) es distinta que (exp_2)
Estos operadores producen un resultado que puede ser verdadero o falso, para el falso el
resultado es un 0 y para verdadero el resultado es cualquier número distinto de 0. Por
ejemplo:
(10==2) /* resultado =0 porque 10 no es igual a 2 */
(5<10) /*resultado =1 porque 5 es menor que 10 */
(3>=10) /* resultado =0 porque 3 no es mayor que 10 */
(100!=(10*10)) /*resultado =0 porque 100 es igual a 10*10=100 */
2.2.5.- Operadores Lógicos
Los operadores lógicos sirven para unir varias evaluaciones en una sola.
Estos son:
(exp_1)||(exp_2) Es verdadero cuando exp_1 o exp_2 es verdadera
(exp_1)&&(exp_2) Es verdadero cuando exp_1 y exp_2 son verdaderas
El operador o lógico (||) da como resultado verdadero si al menos uno de las 2 expresiones
son verdaderas, si ambas lo son también resultado es verdadero, es falso cundo ambas
expresiones son falsas.
El operador y lógico (&&) da como resultado un verdadero si los 2 son verdaderos, si
alguno es falso el resultado es falso, si ambos son falsos el resultado es falso.
Ejemplo:
(7>3)&&(10!=5) //resultado = 1 porque ambas expresiones son verdaderas
(500==100)&&(100>3) //resultado = 0 porque la primera expresión es falsa
(1==1)||(10>11) //resultado = 1 porque la primera expresión es verdadera
(24==12)||(1>20) //resultado = 0 porque ambas expresiones son falsas
2.7.-Resultados decremento e incremento
a vale 11 y b vale 10
a vale 12 b vale 12
a vale 11 y b vale 12
a vale 10 y b vale 10
Como programar en c y no morir en el intento 15
2.2.6.- Otros operadores.
Para no alargar tanto este texto solo daré el nombre un breve descripción de lo que hace y
su uso para una definición mas completa ya saben que hacer…(leer el libro “ANSI C como
si estuviera en primero”).
2.2.6.1.- Operador menos (-)
Vuelve negativa a una variable su uso es –variable
2.2.6.2.- operador mas (+)
Vuelve positiva a una variable su uso es +variable (si se le pone algo antes, como otra
variable, se transforma en el operador suma)
2.2.6.3 Operador negación lógica (!)
Niega el valor lógico de una expresión o variable, lo que quiere decir que si el resultado de
una expresión o variable es 0 el operador lo hace 1 y si es distinto de 0 el operador lo
vuelve 0. su uso es !(expresión o variable).
2.2.6.4 Operador sizeof().
Aunque parezca una función en realidad es un operador y lo único que hace es devolver el
tamaño de una variable, su uso es sizeof(variable). También sirve con los tipos de variables
por ejemplo podemos hacer sizeof(int) lo que nos devolverá el numero de bytes que ocupa
un entero en memoria.
2.2.6.5.- Operador coma (,).
Sirve para separar expresiones su uso es expresion1= expresion2, espresion3 , expresion4…
2.2.6.6.- Operador dirección (&) e indireccion (*).
El operador dirección obtiene la dirección de una variable, su uso es &variable.
El operador indireccion obtiene lo que guarda una dirección, se usa con punteros, que será
un tema tratado mas adelante en este documento su uso es *(dirección) donde dirección es
la dirección de lo que queremos obtener el valor.
Que mejor manera de explicar esto que con un ejemplo que abarque todo lo que ya
conocemos. No comento el ejemplo por que es muy básico y entendible.
2.8 uso de de operadores
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a=10;
printf("a vale %i y ocupa %i bytes en memoria\n",a,sizeof(a));
printf("ademas esta en la pocicion %i de memoria\n",&a);
printf("y por si fuera poco la negacion de a es %i\n",!a);
printf("y si no te convences a >1 es %i\n",(a>1));
system("pause");
return 0;
}
Como programar en c y no morir en el intento 16
2.3.- Bucles
Todo lo hasta aquí visto tiene por objetivo enseñar a programar, pero los programas que
hasta ahora hemos hecho no tienen mayor utilidad, además de lo académico.
Sin embargo ahora abordaremos un tema muy importante en C como son los bucles, ya que
estos nos permiten hacer programas más dinámicos, que puedan variar su funcionamiento
según pasen ciertas cosas.
2.3.1.- Estructuras de control
Los bucles de control sirven para controlar ciertas acciones en nuestro programa, según
pase o se cumpla cierta condición, el más conocido de ellos es el if... aunque no viene solo
el viene con el else, bueno mejor lo explico.
2.3.1.1.- IF y ELSE
Como dije anteriormente este es probablemente el bucle mas conocido, ya que tiene una
gran utilidad al momento de programar, permitiéndonos tomar decisiones según ciertas
acciones de manera de lograr cierta interacción con el usuario.
Para los que no saben ingles (deberían ponerse a estudiar desde ya ingles XD), if significa
si, como yes también significa si, pero el en C if se refiere a si se cumple cierta condición.
Su forma general es:
En español esto seria si se cumple la condición entre paréntesis, se ejecuta el código entre
llaves.
La condición puede ser como las que vimos anteriormente, o alguna variable que queremos
ver si el valor es distinto de cero o igual a cero.
Si la condición llega a ser falsa no se ejecuta el código entre llaves, pero podemos forzar a
que se ejecute otro código cundo la condición sea falsa, para ello usamos el else, que s
utiliza como sigue:
Denuevo, para los que no sepan ingles o les de flojera buscar en el diccionario o en un
traductor, else significa si no, con lo que el bucle if else quedaría algo como, si pasa esto,
hago algo, si no pasa hago otra cosa.
Luego se continúa con la ejecución del programa normalmente.
2.9.-Declaración del bucle if
if(condicion){
pasa esto;
}
2.10.-Declaración del bucle if, else
if(condicion){
pasa esto;
}
else {
pasa esto otro;
}
Como programar en c y no morir en el intento 17
También es valido usar un bucle if dentro de otro, lo cual nos permite comprobar mas
condiciones, o poner un if después de un else. ¿Parece enredado? Veámoslo con un
ejemplo:
En el ejemplo anterior podemos ver un ejemplo muy claro de bucles anidados, solo hay que
seguir los paréntesis de corchete y tener cuidado de no perderse, lo único que hace este
programa es pedir dos números por teclado y revisar si son iguales o ver cual es mayor que
cual.
Omití los comentarios por que a esta altura ya debería estar claro que hace cada parte, si
todavía no entinten revisen denuevo el principio del texto.
2.11.-Ejemplo del bucle if, else
#include <stdio.h>
#include <stdlib.h>
int main(void){
int num_1, num_2, resultado;
printf(“Ingrese un numero :”);
scanf(“%i”,&num_1);
printf(“\nIngrese un numero :”);
scanf(“%i”,&num_2);
if(num_1==num_2){ //compara igualdad
printf(“%i es igual que %i\n”,num_1,num_2); // esto pasa si son iguales
}
else { //esto pasa si son distintos
if(num_1<num_2){ //compara si n1 es menor que n2
printf(“%i es menor que %i\n”,num_1,num_2); //pasa si n1menor que n2
}
else { // si no es menor tiene que ser mayor
printf(“%i es mayor que %i\n”,num_1,num_2);
}
}
system(“pause”);
return 0;
}
Como programar en c y no morir en el intento 18
2.3.1.2.- SWITCH y CASE
La estructura switch sirve para actuar de una manera determinada según tome algún valor
una variable, en otras palabras sirve para hacer distintas cosas dependiendo del valor que
tome una variable o expresión, a diferencia del if que solo puede hacer a lo mas dos cosas.
El case se usa dentro del switch para numerar los posibles casos según los cuales se
tomaran distintas decisiones.
La estructura general de la sentencia switch es:
Como vemos va a hacer distintas cosas según sea el valor de variable.
Además si se dieron cuenta, aparece la sentencia break después de cada caso y antes del
siguiente, esto es para que si encuentra una coincidencia deje de ejecutar el switch,
ahorrando así tiempo de procesamiento y además posibles errores que podría generar que la
variable coincidiera con dos casos.
Además aparece default que es el caso por defecto, es decir, si no se cumple ningún caso se
ejecuta esta condición, el default puede omitirse si es que no se necesita.
Para poner un caso con número se pone solo el número, por ejemplo case 3: hace algo…
Para poner un caso con letras se usa la comilla simple, por ejemplo case „c‟: hace algo…
Esto se ve mejor con un ejemplo, el ejemplo del menú, que es el siguiente:
2.12.-Estructura del switch case
switch(variable){
case valor1:
hace esto;
break;
case valor2:
hace esto otro;
break;
…..
….
case valorn:
hace esto;
break;
default:
hace esto;
break
}
Como programar en c y no morir en el intento 19
Para cerrar esta parte vamos a poner un ejercicio para que practiquen todo lo que se supone
han aprendido.
Cree un programa que reciba dos números y muestre un menú o lita de
opciones para que el usuario elija que hacer con los números, las opciones
deben ser sumar, restar, multiplicar, dividir, con la restricción de que los
números ingresados deben ser menores que 500.
2.13.-Ejemplo switch case
#include <stdio.h>
#include <stdlib.h>
int main(void){
int opcion;
printf(“1.-Mostrar Hola mundo\n”);
printf(“2.-Mostrar Como estan\n”);
printf(“3.-Mostrar Estoy programando\n”);
printf(“Ingrese su opcion :”);
scanf(“%i”,&opcion);
switch(opcion){
case 1:
printf(“\n\tHola mundo, hoy es un buen dia para programar\n”);
break;
case 2:
printf(“\n\t¿Como estan? Yo estoy bien\n”);break;
case 3:
printf(“\n\tAunque no lo crean ya estoy programando…\n”);
break;
default:
printf(“\n\tTe pedi que eligieras entre 3 opciones, no di mas posibilidades\n”);
break;
}
system(“pause”);
return 0;
}
Como programar en c y no morir en el intento 20
2.3.2.- Bucles iterativos
Bucles iterativos es lo mismo que repetitivos, es decir ejecutan una condición varias veces
o un número determinado de veces.
2.3.2.1.- Bucle FOR
Para entender este bucle debemos primero conocer su forma general, la cual es:
Donde variable es una variable ya declarada, hasta cuando es una condición, generalmente
se usa hasta que variable sea mayor igual o menor que algo, y lo que hace después es lo que
hace cundo termina el bucle, generalmente se incrementa o decrementa variable, aunque se
pueden hacer cosas mas interesantes.
El siguiente ejemplo muestra el uso del bucle for, lo que hace es mostrar una lista de los
numero del 1 al numero ingresado por teclado saltándose un espacio depuse de cada uno.
Como cosa excepcional pondré la respuesta inmediatamente para que puedan entender
mejor el uso de switch con letras y del bucle for.
Cree un programa que le pregunte al usuario si ha estudiado programación,
si el usuario responde que si (representado por s), debe ser felicitado, si
responde que no (representado por n) debe mostrarse 20 veces (saltándose
una línea entre mensaje) el mensaje, estudia programación, si responde otra
cosa, que le avise que su respuesta es incorrecta
2.14.-Forma general del bucle for
for(variable; hasta_cuando ; que hace despues){
lo que se va a repetir;
}
2.15.-Ejemplo bucle for
#include <stdio.h>
#include <stdlib.h>
int main(void){
int limite, i;
printf(“Ingrese el numero limite :”);
scanf(“%i”,&limite);
for(i=0; i<=limite; i++){
printf(“%i\n”, i);
}
system(“pause”);
return 0;
}
Como programar en c y no morir en el intento 21
#include <stdio.h>
#include <stdlib.h>
int main(void){
int i;
char opcion;
printf("responda con s o n\n");
printf("¿Estudiaste programacion? : ");
scanf("%s",&opcion);
switch(opcion){
case 's':
printf("\n\tTe felicito , vas por buen camino\n");
break;
case 'n':
for(i=0; i<=20; i++){
printf("Eso esta muy mal, deberias estar estudiando\n");
}
break;
default:
printf("\n\tTe pedi un si o un no\n");
break;
}
system("pause");
return 0;
}
2.3.2.2.- Bucle DO y WHILE
Si entendieron el bucle for este se les hará muy fácil ya que es casi lo mismo, y digo casi
por que si fuera lo mismo no habría que explicarlo.
El bucle do while es un bucle compuesto que consiste en lo siguiente:
El do lo agregamos para que haga eso una vez, si no queremos usarlo lo podemos omitir y
dejar solo el while que se ejecutara mientras la expresión sea verdadera, si es falsa se
interrumpe la ejecución del bucle. Otra manera de interrumpir el bucle es con la sentencia
break; que es la misma que se uso en switch.
Además podemos pasar a la siguiente ejecución mediante la expresión continue; la que
fuerza a terminar el bucle y comenzarlo desde la siguiente vuelta.
2.13.-Respuesta al problema anterior
2.14.-Bucle do while
do {
hace esto una vez;
}
while(expresion){
hace esto otro mientras expresion sea verdadera;
}
Como programar en c y no morir en el intento 22
3.- Otros temas de C
3.1-. Vectores y matrices.
3.1.1.- Los Vectores
Los vectores son una parte muy importante del C, ya que nos permiten trabajar con mas de
un dato, hasta ahora vimos variables en las cuales solo podíamos guardar un dato, ahora
veremos como guardar mas de un dato del mismo tipo en u vector.
Un vector es una colección de elementos de un mismo tipo, es decir como una variable
múltiple.
Su estructura general es:
Donde tipo de vector puede ser cualquiera aceptado por C (int, char, float…), nombre debe
ser el nombre por el cual se identificara al vector y el numero de elementos es el numero de
elementos que vamos a guardar en el vector.
Por ejemplo declaremos un vector de caracteres de 10 elementos, un vector de enteros de 5
elementos y un vector de flotantes de 3 elementos y luego asignémosle valores, esto
quedaría como así:
Los vectores de caracteres también son llamados Ristras, además se pueden declarar como
los vectores de caracteres o entre comillas dobles.
3.1.-Declaración de un vector
tipo_de_vector nombre[numero_de_elementos];
3.2.-Uso de vectores
#include <stdio.h>
#include <stdlib.h>
int main(void){
int i, enteros[5]={10,20,30,40,50};
char caracteres[11]="hola mundo";
float flotante[3]={3.5,6.3,25.8};
for(i=0;i<=10;i++){
printf("caracteres[%i] tiene %c\n",i,caracteres[i]);
}
for(i=0;i<=2;i++){
printf("flotante[%i] tiene %f\n",i,flotante[i]);
}
for(i=0;i<=4;i++){
printf("enteros[%i] tiene %i\n",i,enteros[i]);
}
system("pause");
return 0;
}
Como programar en c y no morir en el intento 23
Si son buenos observadores el largo del vector caracteres es 11, pero hola mundo tiene 10
caracteres contando el espacio, entonces ¿Por que tiene once espacios para guardar
caracteres? Esto se debe a que al final de la ristra se agrega automáticamente un \0 para
indicar que ahí termina la ristra, esto sucede al guardarlo de esta forma ya que si lo
hubiéramos guardado de la otra manera (con los paréntesis de llave
caracteres[10]={„h‟,‟o‟,‟l‟,‟a‟,‟ ‟,‟m‟,‟u‟,‟n‟,‟d‟,‟o‟} ) podríamos haber hecho un vector de
10 elementos
También podríamos haber impreso la ristra completa con %s, sin tener que usar el for para
recorrer la matriz, esto seria agregando lo siguiente:
Para acceder aun elemento especifico del vector se hace mediante un índice que es el
numero donde esta ubicado el electo al cual queremos acceder, estos índices empiezan
desde el 0 y va hasta el largo del vector menos 1, es decir si el vector es de 10 elementos,
los índices para acceder a cada uno de ellos ira desde el 0 al 9.
En el ejemplo anterior enteros[3] valdría 40, porque se empieza a contar desde el índice 0.
Para terminar falta decir que a los vectores y matrices también se les conoce como arrays.
3.1.2.- Las matrices
Las matrices son una ampliación de los vectores, o tal vez los vectores son un caso puntual
de las matrices, no se eso lo dejo al criterio del lector.
Las matrices son colecciones de elementos del mismo tipo pero con varias dimensiones,
podemos tener matrices de 2 dimensiones o de más, según sea nuestra necesidad,
La declaración general de una matriz de dimensión 2 es:
En donde tipo_de_matriz es cualquiera de los tipos aceptados en C, nombre_matriz es el
nombre con el cual identificaremos nuestra matriz, numero_filas es el número de filas de
nuestra matriz y numero_columnas es el número de columnas aunque esto es relativo ya
que se pueden cambiar las filas por columnas.
En el siguiente ejemplo se muestra como rellenar una matriz de 4*4 con números
consecutivos, lo que se hace es ir llenado cada fila y cundo termina pasa al la siguiente y así
hasta que llena las 4, esto se hace con dos for con índices independientes, cosa de poder
recorrer toda la matriz.
3.3.-Impresión de ristras
printf(“La ristra contiene %s”,caracteres);
3.4.-Declaración de matrices
tipo_de_matriz nombre_matriz[mumero_filas][numero_columnas];
Como programar en c y no morir en el intento 24
3.2.- Punteros.
Los punteros son uno de los temas mas difíciles de entender ya que las explicaciones que se
dan son demasiado técnicas, por eso tratare de hacer esto lo mas fácil posible, ya que
entendiendo este concepto se hace mucho mas fácil, rápido y cómodo programar.
En algunos textos también se les llama apuntadores, lo que es un nombre que resulta más
fácil de asociar con el concepto.
Un puntero tiene un tipo de dato específico, que es el tipo de dato al que apunta, es decir
podemos tener punteros a entero, a caracteres, a flotantes e incluso a otros punteros.
La declaración general de un puntero se hace mediante el operador * (operador indireccion)
y es de la siguiente manera:
Donde tipo_de_dato_ al_que_ apunta es cualquiera de los aceptados por C y nombre_
del_puntero es el nombre con el cual se identificara al puntero.
El puntero debe apuntar a el tipo de dato que le designemos, es decir es como un acceso
directo a cierto dato, esto nos sirve para ahorrar memoria, por ejemplo al momento de pasar
variables a una función, ya que al pasar la variable a la función el valor se copia renuevo en
memoria, en cambio al usar un puntero ala variable, solo le pasamos al dirección de la
variable ahorrándonos la copia.
3.5.-Ejemplo Matrices
#include <stdio.h>
#include <stdlib.h>
int main(void){
int m[4][4], con=0;
int i,j, ;
for(i=0;i<4;i++) {
printf("\n"); //para que salte una linea cuando termine la fila
for(j=0;j<4;j++)
{
m[i][j]=con; //llena la el espacio j de la fila i con con
printf(" %i ",m[i][j]); //imprime el contenido de la
con++; //aumenta con
}
}
printf("\n");
system("PAUSE");
return 0;
}
3.6.-Declaración de un puntero
tipo_de_dato_al_que_apunta *nombre_del_puntero;
Como programar en c y no morir en el intento 25
El contenido de un puntero es una dirección de memoria que es al dirección de lo que esta
apuntando.
La asignación de un puntero se hace de la siguiente manera, claro esta que es después de
haber declarado el puntero.
Se usa el operador & para obtener la dirección de la variable (puede ser también una
estructura, puntero o variable) a la cual queremos apuntar y se le asigna este valor al
puntero.
Para conocer el valor de lo apuntado por un puntero podemos usar el operador indireccion
(*) de la forma *nombre_del_puntero.
Veamos un ejemplo para clarificar el uso de punteros.
Como podrán ver al ejecutar el código puntero guarda una dirección de memoria, esta
dirección de memoria es la dirección donde se encuentra lo que apunta el puntero, lo que
apunta se obtiene por el operador * (indireccion) y la asignación ya que se trata de una
dirección se hace a una dirección, la que se obtiene usando el operador & (dirección) en lo
que queremos apuntar.
En el ejemplo se crean dos punteros uno a entero y el otro a carácter, el primero apunta al
número que ingresamos y el segundo apunta a la primera letra de la palabra que
ingresamos.
Podemos usar punteros a todos los tipos de variables que están definidas en C e incluso
podemos usar punteros a estructuras solo declarando el tipo de estructura a la cual
queremos apuntar, eso lo veremos mas adelante en la aparte de estructuras.
3.7.-Asignación de un puntero
nombre_del_puntero = &variable_apuntada;
3.8.-Ejemplo de punteros
#include <stdio.h>
#include <stdlib.h>
int main(void){
int numero;
int *puntero1 ;
char letra, palabra[15];
char *puntero2, *puntero3;
puntero1=№
puntero2=palabra;
printf("ingrese un numero: ");
scanf("%i",puntero1);
printf("\ningrese una palabra: ");
scanf("%s",puntero2);
printf("puntero1 tiene guardado %i y apunta a %i\n",puntero1,*puntero1);
printf("puntero2 tiene guardado %i y apunta a %c\n",puntero2,*puntero2);
system("pause");
}
Como programar en c y no morir en el intento 26
3.3.-Estructuras.
Como ya aprendimos lo que es un vector, nos va a ser muy fácil entender las estructuras,
las estructuras son colecciones de elementos, al igual que los vectores, pero con la
diferencia de que los elementos pueden ser de distinto tipo, no como en los vectores que
cada vector contenía elementos de un mismo tipo.
La declaración de estructuras puede hacerse de dos maneras, vamos con la primera:
Aquí solo declaramos una estructura del tipo nombre_del_tipo, este es solo el tipo de
estructura y suele confundirse con el nombre, ademas podemos definir cuantas variables
queramos dentro de la estructura, siendo estas de cualquera de lso tipos aceptados por C.
Para crear una estructura del tipo nombre_del_tipo podemos hacerlo de dos formas, la
primera es poniendo el nombre de la estructura después del último paréntesis de corchete,
lo que crea una estructura del tipo nombre_del_tipo y con el nombre que nosotros le
especifiquemos, la otra es declarar la estructura como sigue:
Aquí además de declarar la estructura se crearon dos estructuras más del tipo
nombre_del_tipo, mas abajo también se creo otra estructura del tipo nombre_del_tipo.
Esta declaración se puede hacer dentro del main o fuera del main dependiendo si queremos
que nuestra estructura sea local o global, si es global puede ser modificada y retornada por
cualquier función, si es local se pierde al momento de salir de la función.
Vemos un ejemplo de estructuras.
3.9.-Declaración de estructuras
struct nombre_del_tipo {
tipo_variable1 nombre_variable1;
tipo_variable2 nombre_variable2;
...
};
3.10.-Declaración y uso de estructuras
struct nombre_del_tipo {
tipo_variable1 nombre_variable1;
tipo_variable2 nombre_variable2;
...
}nombre_estructura1, nombre_estructura2...;
(aquí mas codigo..);
struct nombre_del_tipo nombre_estructura_3;
Como programar en c y no morir en el intento 27
En el ejemplo anterior declaramos dos estructuras del tipo agenda y de nombre amigo1 y
amigo2, luego las vamos llenando de acuerdo a los datos ingresados.
Para acceder a un elemento de una estructura se usa el operador . el uso del cual es el
mismo del los índices en las matrices ([i]), solo que en vez de un numero aquí se usa un
nombre para acceder a cada elemento.
También se puede declara un puntero a la estructura y acceder por el operador -> esto se
vera mas adelante.
3.11.-Ejemplo estructuras
#include <stdio.h>
#include <stdlib.h>
int main(void){
int i;
struct agenda { //se define el tipo de estructura agenda
char nombre[20], apellido[20];
int rut, telefono;
};
struct agenda amigo1, amigo2; //se crean dos structuras del tipo agenda
printf("Ingrese el nombre de su amigo: ");
scanf("%s",&(amigo1.nombre));
printf("Ingrese el apellido de su amigo: ");
scanf("%s",&(amigo1.apellido));
printf("Ingrese el telefono de su amigo: ");
scanf("%i",&(amigo1.telefono));
printf("Ingrese el rut de su amigo: ");
scanf("%i",&(amigo1.rut));
printf("\n Se a agregado satisfactoriamente %s %s", amigo1.nombre, amigo1.apellido);
printf("\n Su telefono es %i ", amigo1.telefono); //se accesa a los datos
printf("\n y su rut es %i \n", amigo1.rut);
system("pause");
system("cls");
printf("Ingrese el nombre de otro amigo: ");
scanf("%s",&(amigo2.nombre));
printf("Ingrese el apellido de su amigo: ");
scanf("%s",&(amigo2.apellido));
printf("Ingrese el telefono de su amigo: ");
scanf("%i",&(amigo2.telefono));
printf("Ingrese el rut de su amigo: ");
scanf("%i",&(amigo2.rut));
printf("\n Se a agregado satisfactoriamente %s %s", amigo2.nombre, amigo2.apellido);
printf("\n Su telefono es %i ", amigo2.telefono);
printf("\n y su rut es %i \n", amigo2.rut);
system("pause");
return 0;
}
Como programar en c y no morir en el intento 28
Otra forma de definir estructuras es mediante typedef, que define un nuevo tipo de dato su
definición es la siguiente:
Esto es lo mismo que lo anterior lo que cambia es la forma de crear una nueva estructura, lo
que se hace de la siguiente manera una vez creada la estructura:
Esto nos ahorra escribir el struct antes del tipo para crear una nueva estructura.
3.4.- Declaracion de tipos
La declaración de tipos nos permite crear nuestros propios tipos de datos para usarlos en
nuestros programas, esto es útil a la hora de usar variables con tipos largos, como por
ejemplo, una variable del tipo long long int, con typedef podría pasar a llamarse entero lo
que nos ahorra escribir tanto al programar.
La definición general de typedef es la siguiente
Esto crea un tipo de variable nuevo_nombre que podemos usar y seria aceptada por el
compilador.
Por ejmeplo para crear el tipo de dato entero, debemos hacer lo siguinete:
Esto crea el tipo de dato entero el cual podmeos usar al momento de declarar variables,
tambien podemos hacer que entero sea un entero grande ahorandonos así tener que escribir
tanto al programar esto seria de la siguiente forma:
Así cuando queramso declara una variable del tipo unsigned long ling int bastara con que
declaremos una variable del tipo entero.
3.12.-Declaración de estructuras
typedef struct {
tipo_variable1 nombre_variable1;
tipo_variable2 nombre_variable2;
...
} nombre_del_tipo ;
3.13.-Declaración de estructuras
Nombre_del_tipo nombre_de_la_estructura1;
3.14.-Declaración de typedef
typedef tipo_1 tipo_2 tipo_n nuevo_nombre;
3.15.-Uso de typedef
typedef int entro;
3.16.-Declaración de typedef
typedef unsigned long long int entero;
Como programar en c y no morir en el intento 29
3.5.- Funciones recursivas
Una función recursiva es una función que se llama a si misma, esto para evitarnos tener que
usar bucles, el ejemplo mas famoso, aunque no el unico de funciones recursivas es el
calculo del factorial, como es tan famsoso no lo voy a poner si no que pondre una función
para calcular el binario de un numero en forma recursiva, esto es como sigue:
Esta es una función recursiva muy simple, se puede modificar un poco para que guarde los
resultados en un vector sobre el cual podamos operar después pero eso lo dejo como
desafió para el lector.
Toda función recursiva debe tener una condición de termino para indicarle cundo debe
dejar de llamarse a si misma, de lo contrario la función no sabría cundo debe terminar y
continuaría hasta el infinito y mas allá… jajaja eso fue el momento humorístico, pero
volviendo a la seriedad esta función verifica si el numero es igual a 0 de ser así da por
terminada la función retornando un 1, si no es igual a 0 se llama a si misma aplicándose
sobre el numero dividido en 2, hasta que llega a la condición de termino y imprime el
modulo del numero con 2.
3.17.- Función recursiva
#include <stdio.h>
#include <stdlib.h>
int binario(int num); // declaracion del prototipo
int n; // crea variable global n
int main(void)
{
printf("Dame un numero:");
scanf("%d",&n);
binario(n); //llama a la función recursiva
printf("\n\r");
system("pause");
return 0;
}
int binario(int num) //completa la funcion recursiva
{
if (num == 0) //condicion de termino
return 1;
else
{
binario(num/2); //llama a la function binario (ella misma)
}
printf("%d",num%2);
}
Como programar en c y no morir en el intento 30
3.6.- Asignación dinámica de memoria
La asignación dinámica de memoria nos es muy útil al momento de programar para, por
ejemplo guardar datos de los cuales no sabemos el largo exacto, esto nos ayuda a no pedir
ni memoria de menos ni memoria de mas, en el caso de pedir memoria de mas nos tanto un
problema si no que es un desperdicio de memoria, el caso de quedarnos cortos si es grave
ya que significaría que algunos datos no se pudieran guardar.
3.6.1.- Petición de memoria
En esta parte debemos saber cuanta memoria vamos a pedir, de lo contrario como la vamos
a pedir?????
Para pedir memoria existen dos funciones ya declaradas en C, estas son malloc() y calloc()
aquí solo trataremos malloc(), si quieren saber sobre calloc() busquen en google…
La función malloc recibe como argumento el número de bytes que queremos pedir y
devuelve un puntero del tipo void al primer espacio de esta dirección de memoria, como
devuelve un puntero del tipo void debemos hacer n casting o cambio de tipo al tipo de
variable que queramos almacenar en el espacio reservado con malloc.
Primero veamos la estructura general de malloc
Si la función malloc llegara a fallar por que no hay memoria o por cualquier otra razón
devuelve un puntero a NULL que es un dato vacío, lo que indica que la petición de
memoria fallo, es bueno hacer un if para comprobar si la memoria se pide de forma correcta
comprobando el puntero al cual le asignamos el retorno de malloc con NULL, si es que
fueran iguales es que la memoria no se pidió correctamente, ahí cada uno debe elegir la
acción a seguir, si terminar le programa o ejecutar alguna otra acción.
Para hacer un casting debemos poner el tipo de variable al que queremos transformar entre
paréntesis, por ejemplo si queremos hacer un casting a entero ponemos delante de la
variable (int), de la misma manera si queremos hacer un casting a flotante ponemos (float)
Para hacer un castina puntero a entero debemos hacerlo de la forma (int *) y así con todos
los demás, para clarificar esto y las estructuras y además mezclarlo con funciones vamos a
crear una especie de catalogo de libros pero con un solo elemento, esto nos servirá de base
para después estudiar lo que son las listas, este “catalogo” debe tener un menú en un bucle
infinito para poder agregar el producto, modificar el producto y ver el producto, además de
la opción de salir, además se deben declarar 3 funciones una para mostrar elementos, otra
para agregarlos y una mas para modificarlo, además la asignación de memoria para el
elemento debe hacerse de forma dinámica, sin mas preámbulos vamos a la programación
3.18.- Estructura general de malloc
void malloc(bytes_a_pedir);
Como programar en c y no morir en el intento 31
#include <stdio.h>
#include <stdlib.h>
typedef struct catalogo { /declaración de la estructura mediante typedef
char nombre[20];
int codigo;
} articulo;
articulo *puntero; //creación de un puntero a estructura (del tipo articulo)
void mostrar(void); //declaracion de funciones
void editar(void);
void llenar(void);
int main(void){
int opcion;
puntero= (articulo *)malloc(sizeof(articulo)); //peticion de memoria
while(1){ //bucle para mostrar el menu infinitas veces
system("cls"); // limpia pantalla
printf("1.- Agregar articulo\n");
printf("2.- Editar articulo\n");
printf("3.- Ver articulo\n");
printf("4.- salir\n");
printf("Ingrese su opcion: ");
scanf("%i",&opcion);
switch(opcion){
case 1:
llenar();
break;
case 2:
editar();
break;
case 3:
mostrar();
break;
default:
return 0;
}
system("pause");
}
}
void mostrar(void){ //Completacion de las funciones
printf("Articulo contiene :");
printf("\n%s %10i\n",puntero->nombre,puntero->codigo); //accso mediante el operador ->
}
void llenar(void){
printf("ingrese el nombre del articulo: ");
scanf("%s",&puntero->nombre);
printf("ingrese el codigo del articulo: ");
scanf("%i",&puntero->codigo);
printf("\n Se ha guardado correctamnte el articulo\n");
}
Como programar en c y no morir en el intento 32
En este ejemplo se declara una estructura global y un puntero a estructura global, para
poder acceder a los datos contenidos en la estructura por el operador -> en vez de usar el
operador . lo cual también seria una forma valida de resolver el problema, aunque el no
crear el puntero nos limitaría a la hora de pedir la memoria.
Al pedir la memoria lo hacemos asignando el retorno de la función malloc al un puntero del
tipo articulo, si se dan cuenta ahora con typedef articulo pasa a ser un tipo de variable al
igual que int, char y todas las demás, como el puntero que retorna malloc es del tipo void y
nuestro puntero es del tipo articulo debemos hacer un casting o cambio de tipo, para ello
usamos (articulo *) lo que convierte al tipo puntero a articulo el puntero que retorna malloc.
Para saber cuantos bytes debemos pedir usamos el operador sizeof aplicado a la estructura o
al tipo de estructura para saber exactamente la cantidad de memoria a pedir.
Después de que la memoria es pedida viene el menú que es tan simple que no lo voy
explicar (si no lo entienden vuelvan ala parte de bucles), lo único que cabe destacar s el
while(1) que se encarga de mostrar el menú nuevamente cundo se han completado las
funciones, para salir se usa el return 0 de la función main.
Después del main vine la Completacion de las funciones que son muy simples, de esta parte
lo importante es como se accesa a los miembros mediante el operador -> esto se hace
poniendo el nombre del puntero->nombre_elemento con lo cual estamos accesando al
elemento deseado, también se pede utilizar el operador . cada cual con el método que le
guste mas, yo prefiero este porque las flechas se ven bonitas en el código… jajaja.
La forma general de hacer un casting (y la única que conozco…) es:
Generalmente esto se le asigna a otra variable la cual es del tipo al que estamos
convirtiendo, pudiendo convertir entre culquer tipo (char a int, int a char,float a int, etc)
3.19-.Ejemplo petición de memoria dinámica
void editar(void){
int opt;
printf("1.- Editar nombre\n");
printf("2.-Editar codigo\n");
printf("Ingrese su opcion: ");
scanf("%i",&opt);
switch(opt){
case 1:
printf("ingrese el nuevo nombre del articulo: ");
scanf("%s",&puntero->nombre);
break;
case 2:
printf("ingrese el nuevo codigo del articulo: ");
scanf("%i",&puntero->codigo);
break;
}
}
3.20-.Cambio de tipo de variable
(nuevo_tipo) nombre_variable
Como programar en c y no morir en el intento 33
3.6.2.- Liberacion de memoria
Es una buna práctica liberar la memoria después de terminar de utilizarla, así si después
necesitamos mas memoria solo la pedimos y no corremos riesgo de quedarnos sin memoria
y que malloc nos devuelva un puntero NULL.
Para liberar la memoria usamos la función free() que recibe como argumento el puntero que
apunta ala memoria que queremos liberar.
La definición general de free es:
Donde puntero_a_ la_memoria es el puntero al cual le asignamos el retorno de malloc.
3.21-.Liberación de memoria
free(puntero_a_la_memoria);
Como programar en c y no morir en el intento 34
4.- Temas mas avanzados del C Si han llegado hasta aquí y han entendido algo los felicito, son secos porque ni yo entiendo
todas las tonteras que escribí… jajaja
Pero hablando enserio si han logrado llegar hasta aquí los felicito, aunque lo que viene
ahora no es fácil pero es importante ya que es lo que le da mayor potencia y versatilidad a
nuestros programas en C, estoy hablando de las listas y de el manejo de ficheros, dos cosas
que mezcladas pueden crear programas sumamente útiles.
4.1.- Listas enlazadas simples
Las listas enlazadas simples son listas enlazadas en un solo sentido. Pero ¿Que es una lista?
Una lista es una sucesión de estructuras que tiene un inicio y un fin.
Para esto se usan punteros que se guardan dentro de la lista, el cual apunta al siguiente
elemento de la lista, cundo se llega al final de la lista nos encontramos que el puntero de la
estructura apunta a NULL.
Para hacerlo un poco más grafico haré un dibujo que explica las listas:
Aquí podemos ver que dentro de cada estructura hay un puntero que sirve para apuntar al
siguiente elemento de la lista y que el puntero del último electo de la lista apunta a NULL
además que a la primera estructura de la lista apunta un puntero el que nos da el comienzo
de la lista.
Esta lista esta enlazada solo en un sentido, lo que nos permite solo recorrerla hacia una
dirección, en este caso partiendo desde la primera hasta la que contiene al puntero que
apunta a NULL, ahora veamos un ejemplo de una lista enlazada simple.
Puntero a primera estructura
NULL
Datos Datos Datos Datos p
u
n
t
e
r
o
Como programar en c y no morir en el intento 35
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct _agenda {
char nombre[20];
int telefono;
struct _agenda *siguiente;
};
struct _agenda *primero, *ultimo;
int telefono;
void mostrar_menu(void) {
system("cls");
printf("\n\nMenu:\n=====\n\n");
printf("1.- Agregar elementos\n");
printf("2.- Borrar elementos\n");
printf("3.- Mostrar lista\n");
printf("4.- Buscar\n");
printf("5.- Salir\n\n");
printf("Escoge una opcion: ");
}
/* Con esta función añadimos un elemento al final de la lista */
void anadir_elemento() {
struct _agenda *nuevo;
/* reservamos memoria para el nuevo elemento */
nuevo = (struct _agenda *) malloc (sizeof(struct _agenda));
if (nuevo==NULL) printf( "No hay memoria disponible!\n");
printf("\nNuevo elemento:\n");
printf("Nombre: ");
scanf("%s",&nuevo->nombre);
printf("Telefono: ");
scanf("%i",&nuevo->telefono);
/* el campo siguiente va a ser NULL por ser el último elemento
de la lista */
nuevo->siguiente = NULL;
/* ahora metemos el nuevo elemento en la lista. lo situamos
al final de la lista */
/* comprobamos si la lista está vacía. si primero==NULL es que no
hay ningún elemento en la lista. también vale ultimo==NULL */
if (primero==NULL) {
printf( "Primer elemento\n");
primero = nuevo;
ultimo = nuevo;
}
else {
/* el que hasta ahora era el último tiene que apuntar al nuevo */
ultimo->siguiente = nuevo;
/* hacemos que el nuevo sea ahora el último */
ultimo = nuevo;
}
Como programar en c y no morir en el intento 36
printf("Se agrego correctamente el elemento\n");
system("pause");
}
void mostrar_lista( struct _agenda *nombre ) {
struct _agenda *auxiliar; /* lo usamos para recorrer la lista */
int i;
i=0;
auxiliar = primero;
printf("\nMostrando la lista completa:\n");
while (auxiliar!=NULL) {
printf( "Nombre: %s, Telefono: %i\n",
auxiliar->nombre,auxiliar->telefono);
auxiliar = auxiliar->siguiente;
i++;
}
if (i==0) printf( "\nLa lista esta vacía!!\n" );
system("pause");
}
void eliminar(int telefono){
struct _agenda *auxiliar, *auxiliar2; /* lo usamos para recorrer la lista */
if(primero->telefono!=telefono || primero==NULL){
auxiliar = primero;
while ( auxiliar!=NULL && auxiliar->telefono!=telefono )
{
auxiliar = auxiliar->siguiente;
}
if(auxiliar!=NULL){
auxiliar2=auxiliar->siguiente;
auxiliar->siguiente=auxiliar2->siguiente;
free(auxiliar2);
}
else printf("No se pudo eliminar %i\n",telefono);
}
else {
auxiliar = primero;
primero=primero->siguiente;
free(auxiliar);
}
system("pause");
}
void buscar2(int valor){
struct _agenda *n = primero;
while (n != NULL && n->telefono != valor){
n = n->siguiente;
}
if(n==NULL)printf("No se encontro %i\n",valor);
else {
printf("\nNombre: %s",n->nombre);
printf("\nDato: %i\n\n",n->telefono);
}
}
Como programar en c y no morir en el intento 37
Como pueden ver en el ejmeplo anterior para recorrer la lista se busca el punteo NULL, así
podemos detener el ciclo, de lo contrario este seria infinito
Lo demas sobre listas es casi lo mismo solo agregando un puntero mas dentro de la
estructura para poder recorrer la lista en ambos sentidos, es decir crear un puntero anterior y
cada vez que se crea un elemento se le asigna el elemento que esta antes
int main() {
int opcion;
struct _agenda *nod;
primero = (struct _agenda *) NULL;
ultimo = (struct _agenda *) NULL;
do {
mostrar_menu();
scanf("%i",&opcion);
switch ( opcion ) {
case 1:
anadir_elemento();
break;
case 2: printf("Ingrese el telefono a eliminar: ");
scanf("%i",&telefono);
eliminar(telefono);
break;
case 3:
mostrar_lista(primero);
break;
case 4:
printf("\nDato a buscar: ");
scanf("%i",&telefono);
buscar2(telefono);
system("pause");
break;
case 5:
exit( 1 );
default:
printf( "Opcion no valida\n" );
system("pause");
break;
}
} while (opcion!=5);
}
4.1.-Ejemplo lista enlazada simple
Como programar en c y no morir en el intento 38
4.2.- Manejo de ficheros
Como ya este libro paso de ser una pequeña guía de C a casi un manual de C voy a saltarme
algunas cosas sobre las listas y voy a ir directamente a los ficheros, talvez en una versión
posterior complete lo de las listas.
4.2.1.-Lectura de ficheros
Los ficheros representan una herramienta muy potente para manejar datos ya que permiten
la continuidad de un programa si este es cerrado, lo hasta ahora visto solo nos permite
manejar datos temporales, ahora aprenderemos a trabajar con archivos para poder hacer
estos datos más durables.
Es importante indicar que los ficheros no son únicamente los archivos que guardamos en el
disco duro, en C todos los dispositivos del ordenador se tratan como ficheros: la impresora,
el teclado, la pantalla,...
Bueno vamos con en ejemplo para ver como se leen los ficheros, primero debemos crear un
archivo que se llame origen.txt y lo dejamos junto con el ejecutable cuyo código es el
siguiente
4.2.- Como abrir un fichero
#include <stdio.h>
#include <stdio.h>
int main()
{
FILE *fichero;
char letra;
fichero = fopen("origen.txt","r");
if (fichero==NULL)
{
printf( "No se puede abrir el fichero.\n" );
system("pause");
exit( 1 );
}
printf( "Contenido del fichero:\n" );
letra=getc(fichero);
while (feof(fichero)==0)
{
printf( "%c",letra );
letra=getc(fichero);
}
if (fclose(fichero)!=0)
printf( "Problemas al cerrar el fichero\n" );
system("pause");
}
Como programar en c y no morir en el intento 39
Bueno hasta aquí dejo este manual de programación en C, falto la parte de escribir en
archivos pero eso es fácil de encontrar en google si es que entendieron algo de lo propuesto
en este libro.
Las fallas y errores ortográficos pueden comunicarlos a mi correo, desde ya muchas
gracias.