Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
PROGRAMACION
Curso de Programacin
LOPEZ LIRA ARTURO
EN C
MONDRAGON FLORES VICTOR HUGO
GRUPO: 4CX01
Objetivo........................................................................................................................... 5
Justificacion...................................................................................................................... 5
Capitulo I
Introduccion..................................................................................................................... 6
Lenguaje de programacion............................................................................................... 6
Algoritmos........................................................................................................................ 7
Programa......................................................................................................................... 7
Capitulo II
2
Variables.........................................................................................................13
Inicializacin de variables..................................................................................13
Constantes......................................................................................................13
Operadores Logicos...........................................................................................13
Palabras reservadas..........................................................................................14
Capitulo III
Estructuras de control.......................................................................................16
Tipos de estructuras de control...........................................................................17
Variable local...................................................................................................18
Variable Global.................................................................................................18
If Else.............................................................................................................19
While..............................................................................................................19
Do While.........................................................................................................20
For.................................................................................................................21
Capitulo IV
Arreglos..........................................................................................................23
Importancia de los arreglos................................................................................23
Arreglos Unidimensionales.................................................................................24
Arreglos en la memoria.....................................................................................24
Inicializacion de un arreglo unidimensional...........................................................26
Lectura e Impresin de un arreglo.......................................................................27
Modificacin de un arreglo.................................................................................28
Arreglo de caracteres........................................................................................28
Arreglos Bidimensionales (Matrices)....................................................................29
Inicializacin de matrices...................................................................................29
Lectura e impresin de matrices.........................................................................30
Modificacin de una matriz.................................................................................30
3
Capitulo V
Modularidad.....................................................................................................33
Programa principal y funciones...........................................................................33
Variables.........................................................................................................34
Recursividad....................................................................................................35
Funciones predefinidas en lenguaje C..................................................................36
Capitulo VI
Declaracion de un puntero.................................................................................38
Diferencia entre * y &..................................................................................38
Inicializacion de un puntero................................................................................39
Generacin de codigo........................................................................................39
Errores mas comunes........................................................................................40
Primer caso......................................................................................................40
Segundo caso...................................................................................................42
Tercer caso......................................................................................................44
Conclusiones....................................................................................................45
4
CAPITULO 1
Conceptos bsicos
INTRODUCCIN
5
Se pueden utilizar muchos lenguajes para programar una computadora. El ms
bsico es el lenguaje de mquina, una coleccin de instrucciones muy detallada
que controla la circuitera interna de la mquina. Este es el dialecto natural de la
mquina.
LENGUAJE DE PROGRAMACIN
6
Lenguaje de Alto Nivel: Los lenguajes de programacin de alto nivel (BASIC,
pascal, cobol, fortran, etc.) son aquellos en los que las instrucciones o sentencias a
la computadora son escritas con palabras similares a los lenguajes humanos (en
general en ingls), lo que facilita la escritura y comprensin del programa.
ALGORITMO
Salir de la cama
Quitarse la pijamas
Darse un bao
Vestirse
Desayunar
PROGRAMA
7
CAPITULO 2
Los datos y
operaciones
bsicas
8
DEFINICIN DEL PROBLEMA
Esta fase est dada por el enunciado del problema, el cual requiere una definicin
clara y precisa. Es importante que se conozca lo que se desea que realice la
computadora; mientras esto no se conozca del todo no tiene mucho caso continuar
con la siguiente etapa.
Los datos de entrada. Cul es la informacin que se desea producir (salida) los
mtodos y frmulas que se necesitan para procesar los datos. Una recomendacin
muy prctica es el que nos pongamos en el lugar de la computadora y analicemos
que es lo que necesitamos que nos ordenen y en que secuencia para producir los
resultados esperados.
9
PRUEBA Y DEPURACIN
DOCUMENTACIN
10
IDENTIFICADOR. Un identificador es una serie de caracteres formados por
letras, dgitos y el carcter subrayado (_) que no inicie con dgito, as mismo es el
nombre que damos a todo lo que manipulamos dentro de un programa (variables,
constantes, funciones, etc.). Por ejemplo variables, constantes, funciones, tipos
definidos por el usuario etc.
TIPOS DE DATOS. Todos los datos tienen un tipo asociado con ellos. Un dato
puede ser un simple carcter, tal como b, un valor entero tal como 35. El tipo de
dato determina la naturaleza del conjunto de valores que puede tomar una
variable.
TIPO ENTERO: representa nmeros enteros con o sin signo, que estarn
compuestos por los dgitos del 0 al 9, pudiendo ser precedidos por los signos + o
-.
int edad;
11
TIPO REAL: Se emplean para representar nmeros reales (con decimales). Para
definir datos reales se antepone la palabra reservada float al identificador de la
variable.
float numero3;
Una constante tipo char se representa como un solo carcter encerrado entre
comillas simples.
char letra=a;
12
VARIABLES. Una variable es un identificador que puede tomar diferentes valores
dependiendo del tipo que esta se declare. Una variable es un identificador que
puede cambiar de valor durante la ejecucin de un programa. Una variable es una
posicin de memoria donde se puede almacenar un valor para uso de un
programa.
INICIALIZACIN DE VARIABLES
4. OPERADORES
13
Prioridad de los Operadores Lgicos
1. Not
2. And
3. Or
Aritmticas
Relacinales
Lgicas
PALABRAS RESERVADAS
14
CAPITULO 3
Programacin
Estructurada
ESTRUCTURAS DE CONTROL
15
En lenguajes de programacin, las estructuras de control permiten modificar el
flujo de ejecucin de las instrucciones de un programa.
Con las estructuras de control se puede:
16
TIPOS DE ESTRUCTURA DE CONTROL
Ejecucin secuencial
Seleccin if simple
Se trata de una estructura de control que permite redirigir un curso de accin
segn la evaluacin de una condicin simple, sea falsa o verdadera.
Si la condicin es verdadera, se ejecuta el bloque de sentencias 1, de lo contrario,
se ejecuta el bloque de sentencias 2.
switch-case
Esta sentencia permite ejecutar una de entre varias acciones en funcin del valor
de una expresin. Es una alternativa a if then else cuando se compara la misma
expresin con diferentes valores.
17
Cuando se encuentra la primera coincidencia, se ejecuta el bloque de
sentencias correspondiente y se sale de la estructura Select-Case.
Select (Expresin)
Case Valor1
(Bloque de sentencias 1)
Case Valor2
(Bloque de sentencias 2)
Case Valor n
(Bloque de sentencias n)
Case Else
(Bloque de sentencias "Else")
End Select
Las reglas de mbito de un lenguaje son las reglas que controlan si un fragmento
de cdigo conoce o tiene acceso a otro fragmento de cdigo o de datos.
18
UNA VARIABLE GLOBAL es aquella que se define fuera del cuerpo de cualquier
funcin, normalmente al principio del programa, despus de la definicin de los
archivos de biblioteca (#include), de la definicin de constantes simblicas y antes
de cualquier funcin.
if (condicin) {
} else {
// Haz esto
} En caso contrario {
BUCLES: WHILE
19
If else nos permita decidir si queramos ejecutar o no una instruccin en funcin
de una condicin, los bucles nos permiten utilizar una condicin para determinar
cuntas veces queremos ejecutar una instruccin.
While (condicin) {
Los bucles do while, son muy parecidos a los bucles while, slo que comprobamos
si la condicin es cierta al final del bucle en lugar de al principio. As nuestras
instrucciones se ejecutan siempre al menos una vez, lo que no ocurre en las
condiciones while si la condicin es falsa.
$cantidad = 1;
Do {
echo ($cantidad);
} while ($cantidad<1);
En nuestro lenguaje seria
$cantidad = 1
Do (// ejecuta
20
while ($cantidad<1); mientras cantidad sea mayor que 1 -> la condicin es falsa
luego el programa sale del bucle, pero ha escrito una vez el valor de $cantidad. El
resultado en pantalla sera 1
BUCLES: FOR
Los bucles for funcionan exactamente igual que en C . Con una sola instruccin
controlamos todo el bucle, as que para los vaguetes est muy bien.
21
CAPITULO 4
Arreglos
22
ARREGLOS
DEFINICIN:
23
arreglo de tal forma que la computadora pueda reservar la cantidad apropiada de
memoria.
Para reservar 100 elementos para el arreglo a y 50 elementos para el arreglo x, ambos de
tipo entero, se puede utilizar la siguiente declaracin:
PSEUDOCODIGO LENGUAJE C
PSEUDOCODIGO LENGUAJE C
Tipo_dato_ident_arreglo[tam_ar Tipo_dato_ident_arreglo[tam_arr
reglo] eglo];
Dnde:
Tipo_dato: Se refiere al tipo de dato de cada elemento del arreglo; puede ser
entero, real, carcter, etctera.
ARREGLOS EN LA MEMORIA:
24
Si tomamos la declaracin del arreglo lista del ejemplo anterior, as se representara en
memoria entero lista [4]:
Lista 0 1 2 3
PSEUDOCODIGO LENGUAJE C
ELEMENT
OS
Este arreglo contiene ocho elementos almacenados entre la posicin (0-7). Para
referirnos a un elemento en particular dentro del arreglo, especificamos el nombre
del arreglo y el nmero de posicin donde se encuentra ubicado. La posicin del
arreglo va entre parntesis cuadrados o corchetes ([ ]) para el lenguaje C;
segn el lenguaje de programacin ser la sintaxis requerida.
25
el pseudocdigo en C. Por lo tanto el primer elemento de un arreglo x se
encuentra en la posicin cero y se conoce como x [0], el segundo como x [1], el
sptimo como x [6] y en general, el elemento de orden i del arreglo x ser x [i-1],
ya que se encuentra en la posicin i1, donde i es un subndice que sirve para
hacer referencia a la posicin en el arreglo.
Ejemplo para imprimir los valores contenidos en los primeros elementos del arreglo x:
PSEUDOCODIGO LENGUAJE C
Imprimir a printf(%f,a)
Donde la variable a es de tipo real, ya que los elementos del arreglo x son de ese
tipo.
Sintaxis:
PSEUDOCODIGO LENGUAJE C
26
La asignacin de los valores se realiza al declarar el arreglo mediante el operador
de asignacin (<-/=) y los valores contenidos dentro de las llaves { } a cada
posicin del arreglo; los valores dentro de las llaves se deben separar por una
coma (,) y no es necesario asignarle un valor a cada posicin ya que el compilador
del lenguaje C se encargar de hacerlo segn el lugar donde se haya declarado el
arreglo, comenzando por la posicin cero. Si el nmero de valores es menor al
tamao del arreglo a las posiciones faltantes les asigna cero.
27
MODIFICACIN DE UN ELEMENTO DEL ARREGLO UNIDIMENSIONAL
PSEUDOCODIGO LENGUAJE C
ARREGLOS DE CARACTERES
Los arreglos son necesarios para la implementacin de cadenas de caracteres. Una cadena
de texto es un conjunto de caracteres. Hay que recordar que en el lenguaje C no existe el
tipo de dato cadena (string) como en otros lenguajes de programacin, por lo que se
utiliza un arreglo de caracteres, para poder almacenar una cadena:
PSEUDOCODIGO LENGUAJE C
28
Un arreglo bidimensional es un conjunto de n elementos del mismo tipo almacenados en
memoria contigua en una matriz o tabla. A diferencia de los arreglos unidimensionales que
slo requieren de un subndice, los arreglos bidimensionales para acceder a cada
elemento del arreglo requieren de dos ndices o subndices declarados en dos pares de
corchetes, donde el primer corchete se refiere al tamao de filas y el segundo al tamao
de columnas.
PSEUDOCODIGO LENGUAJE C
Dnde:
Sintaxis:
PSEUDOCODIGO LENGUAJE C
29
t_dato identif[fil] [col] <- T_dato identif[fil] [col={valores};
{valores}
Int a [3][3] = {1, 2, 3, 4, 5, 6, 7, 8,
Entero a[3][3]<-[1, 2, 3, 4, 5, 6, 9};
7, 8, 9}
Para la lectura la computadora requiere de dos ciclos anidados (para ubicar la fila y la
columna), y la instruccin leer (scanf) o leercad (gets), almacenando con ello los valores
en cada celda de la tabla o matriz.
El siguiente segmento de programa muestra cmo se pueden almacenar datos en una
matriz mat de 3 filas y 4 columnas, se utiliza la instruccin leer (scanf) para guardar o leer
los datos:
PSEUDOCODIGO LENGUAJE C
30
PSEUDOCODIGO LENGUAJE C
Ejemplo:
Note que el arreglo x slo tiene un ndice i, esto quiere decir que se est
almacenando en uno de los 50 posibles lugares y en los 20 posibles sitios que
tiene para cada carcter.
31
CAPITULO 5
MODULARIDAD
32
MODULARIDAD
Una de las funciones es main (), donde se inicia la ejecucin del programa. El
resto de las funciones se llaman desde main () y desde el interior de otras
funciones.
El papel ms importante del programa principal (main ()) es coordinar a las otras
funciones mediante llamadas o invocaciones.
Funcin
Es un subprograma que realiza una tarea especfica que puede o no recibir valores
(parmetros). En C podemos devolver cualquier tipo de datos escalares (puntero,
tipo numrico y el tipo carcter o en su caso regresar un valor nulo que
llamaremos nada o ninguno). Asimismo, no se pueden devolver arreglos ni
estructuras.
El uso de funciones es una prctica comn y recomendable ya que permite dividir
el cdigo, simplificando as el desarrollo y la depuracin del mismo. Para utilizar
funciones en un programa es necesario declararlas previamente.
Las funciones pueden ir antes o despus del programa principal, pero si se ubican
despus es necesario escribir el prototipo de la funcin (el encabezado) antes del
programa principal. Una funcin puede que regrese o no regrese nada (void). En el
primer caso se comporta como una variable, ya que la podemos imprimir, asignar
a otra variable, comparar, utilizar como parmetro, etc. En el segundo caso, el
resultado lo tenemos que imprimir dentro de la funcin (slo las variables globales
se imprimirn fuera).
33
Funciones sin paso de parmetros
Son aquellas que no reciben parmetros o valores, ya que stos se solicitan dentro
de la funcin, luego se realizan las instrucciones (clculos u operaciones) y
normalmente se imprime el resultado.
A continuacin aparece la sintaxis correspondiente:
void Identif_funcion ( )
{
Declaracin de variables;
Cuerpo de la funcin;
}
VARIABLES
34
Prototipo de una funcin
RECURSIVIDAD
#include <conio.h>
#include <stdio.h>
float factorial(int n)
{
float f;
if (n==0) f=1;
else f=n*factorial(n-1);
return f;
}
main()
{
float fact;
int n;
35
printf("\nDame un numero: ");
scanf("%d",&n);
fact=factorial(n);
printf("\nEl factorial=%f\n",fact);
getch();
return 0;
36
CAPITULO 6
APUNTADORES
37
DECLARACIN DE UN PUNTERO
TIPO * nombre_puntero ;
Donde TIPO es cualquier tipo definido. Asi, un puntero a caracter se declararia de
la siguiente forma:
char *pchar;
38
INICIALIZACIN DE UN PUNTERO
Hay varias maneras de inicializar un puntero. Una ya ha sido vista en los ejemplos
del punto anterior ( pchar = &a; ); y al igual que el resto, consiste bsicamente en
lo mismo; asignar una direccion de memoria al puntero. Para hacer un paralelismo
Modula-2 - C, en C existe el equivalente al procedimiento NEW; la funcin malloc:
#include <stdio.h>
#include <malloc.h>
char *pchar;
int *pint;
pchar = malloc (6); /* pchar apunta al primer byte de los que se han
reservado */
pint = malloc (sizeof(int)*2);
/* pint apunta al primero de los dos enteros
que se han reservado */
Otra forma es inicializarlo con el valor de otro puntero.
.
.
.
int *pint2;
pint2 = pint;
GENERACIN DE CDIGO
39
La pila es el espacio de memoria donde se reservan todas las variables locales y
globales; esto significa que cada vez que se llama a una funcin, sus variables se
crean en tiempo de ejecucin en la pila, y se destruyen en cuanto el flujo de
ejecucin retorna al punto en que se llam a la funcin.
ERRORES MS COMUNES
PRIMER CASO
40
.
.
.
Por que es incorrecta la inicializacin? Analicemos la pila al realizar la llamada:
| |
SP --->+---------------+
| copia de buff | <------- Parmetro pasado a inicializa()
+---------------+
| @ de retorno |
+---------------+ <------- Hasta aqu llega la pila antes de
| buff = NULL | llamar a inicializa()
+---------------+
| resto de vars |
| locales al |
| main |
+---------------+
Tras la llamada tenemos lo siguiente en la pila
| |
+---------------+
| @ de 'a' |
+---------------+
| @ de retorno |
SP --->+---------------+
| buff = NULL |
+---------------+
| resto de vars |
| locales al |
| main |
+---------------+
y 'buff' sigue valiendo NULL, ya que en la Funcion 'inicializa' lo nico que se ha
modificado es la copia de 'buff' que se ha pasado como parmetro en la pila.
La forma correcta de hacerlo es declarando la Funcion as:
41
.
.
.
}
void inicializa ( char **buffer)
{
*buffer = malloc (1);
*buffer = 'a';
}
.
.
.
ya que la pila ahora queda de la siguiente forma tras la llamada:
| |
+---------------+
| @ de buff |
+---------------+
| @ de retorno |
SP --->+---------------+
| *buff = 'a' |
+---------------+
| resto de vars |
| locales al |
| main |
+---------------+
SEGUNDO CASO
char *inicializa();
void otra_funcion();
main()
{
char *buff;
.
.
.
buff = NULL;
buff = inicializa();
/* hasta aqui todo parece correcto */
otra_funcion();
/* aqui ya no se puede asegurar buff = "hola"*/
42
.
.
.
}
char *inicializa()
{
char buffer[5];
sprintf(buffer,"hola");
return(buffer);
}
.
.
.
Volvamos a analizar la pila:
| |
SP --->+---------------+
| 5 bytes para | <------- Espacio reservado para la variable
| buffer | local buffer
+---------------+
| @ de retorno |
+---------------+
| buff = NULL |
+---------------+
| resto de vars |
| locales al |
| main |
+---------------+
Cuando la funcion retorna tenemos la siguiente situacin:
| |
+---------------+
| "hola\0" | @ base de 'buffer'
+---------------+
| @ de retorno |
SP --->+---------------+
| buff= @buffer |
+---------------+
| resto de vars |
| locales al |
| main |
+---------------+
En cuanto se llama a otra funcin, el espacio destinado a 'buffer' es destinado a
parmetros de la llamada o a las variables locales de la funcin invocada, con lo
que "hola\0" ser machacado por otros valores. Solo funcionaria si el resto de
funciones invocadas no tuvieran ni parmetros ni variables locales.
43
La forma correcta de hacerlo sera:
char *inicializa();
main()
{
char *buff;
.
.
.
buff=inicializa();
.
.
.
}
char *inicializa()
{
char *buffer;
buffer = malloc (5);
sprintf(buffer,"hola");
return (buffer);
}
.
.
.
ya que tendramos la siguiente disposicin en memoria:
PILA HEAP
| | | |
+---------------+ | |
| @ de "hola\0" | --------------+ | |
+---------------+ | | |
| @ de retorno | | | |
SP --->+---------------+ | | |
| buff | --------------+ | |
+---------------+ | +-----------------+
| resto de vars | +----->| "hola\0" |
| locales al | +-----------------+
| main | | |
+---------------+ | |
TERCER CASO
44
La cuestin es que este error algunas veces pasa por alto, sobre todo en mquinas
gobernadas por un SO sin proteccin de memoria, caso de los PC's con MS-DOS.
En una maquina Unix tambin puede ocurrir si el valor del puntero cae dentro de
nuestro espacio de memoria, con lo que el problema llega a ser muy grave y
prcticamente indetectable sin la utilizacin del debugger.
Ejemplo:
main()
{
char *pchar;
int *pint;
*pchar='a';
printf("Direccion de 'a': %p",pchar);
pint=malloc(sizeof(int));
*pint=0;
/* Ahora lo apuntado por pchar puede haber cambiado de valor */
}
CONCLUSIONES
En el proyecto realizado, se logr recabar informacin para saber cules son las
deficiencias en cuanto a programacin que tienen algunos alumnos de ESIME
Culhuacn con el fin de poder con nuestro proyecto hacer que los alumnos cuenten
con ms conocimiento acerca de programacin con el fin de cuenten con una
programacin bsica de manera que les sea de ayuda para poder lograr entender
otros sistemas de programacin logrando nuestro objetivo principal el cual es que
los alumnos no tengan deficiencias en cuanto conocimiento.
45