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


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)


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


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 */

}


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:


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.


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:


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 */





}

/*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 */


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í:


2.2.- Variación del ejemplo 1



/*declaramos al función suma */





}


int main(void){

int num_1, num_2, resultado; /*declaramos 3 variables enteras */





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 */



}

2.3.- Otra variación del ejemplo 1



int suma(int a, int b); /*declaramos al función suma */


int main(void){

int num_1, num_2; /*declaramos 2 variables enteras */





printf(“\n%i + %i = %i\n”,num_1,num_2,suma(num_1,num_2)); /* Imprime resultado */



} /* termina la función main() */

int suma(int a, int b){ /* completamos la función suma*/




}

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).


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.


2.4.- Ejemplo de operadores




int main(void){

int num_1, num_2, resultado; /*declaramos 3 variables enteras */





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 */



}

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




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 */



}


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 */


b = a--; /* postdecremento de a y guardado en b */


b= --a; /* predecremento de a y guardado en b */


system("pause");

return 0;

}


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




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;

}


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;

}


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);

}

}


return 0;

}


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

}


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;

}


return 0;

}


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);

}


return 0;

}


#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;

}


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;

}


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];


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;


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=&numero;

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");

}


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;


...

};

3.10.-Declaración y uso de estructuras

struct nombre_del_tipo {



...

}nombre_estructura1, nombre_estructura2...;

(aquí mas codigo..);

struct nombre_del_tipo nombre_estructura_3;


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;

}


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.


typedef struct {



...

} nombre_del_tipo ;


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;


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);

}


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);


#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");

}


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


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);


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


#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;

}


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 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


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");

}


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.

como programar en c y no morir en el intento

Documents