Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Capitulo 1 y 2
Capitulo 1 y 2
Conceptos
bsicos
INTRODUCCIN
1.2. ALGORITMO
La palabra algoritmo se deriva de la traduccin al latn de la palabra
rabe alkhowarizmi, nombre de un matemtico y astrnomo rabe que
escribi un tratado sobre manipulacin de nmeros y ecuaciones en el
siglo IX.
La solucin a cualquier problema de cmputo involucra la ejecucin de
una serie de acciones en orden especfico. Un procedimiento para
resolver un problema en trminos de: a) Las acciones a ejecutarse y b)
el orden en el cual estas acciones deben ejecutarse se llama algoritmo.
Un ejemplo de un algoritmo para llegar a la escuela:
Salir de la cama
Quitarse la pijamas
Darse un bao
Vestirse
Desayunar
1.3 PROGRAMA
Secuencia de instrucciones mediante las cuales se ejecutan diferentes
acciones de acuerdo con los datos que se estn procesando. Es un
algoritmo desarrollado para ser utilizado por la computadora. Expresin
de un algoritmo en un lenguaje preciso que puede llegar a entender una
mquina de cmputo.
CAPITULO 2
Los datos y
operaciones
bsicas
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.
2.4 CODIFICACIN
La codificacin es la operacin de escribir la solucin del problema (de
acuerdo a la lgica del diagrama de flujo o pseudocdigo), en una serie
de instrucciones detalladas, en un cdigo reconocible por la
computadora, la serie de instrucciones detalladas se le conoce como
cdigo fuente, el cual se escribe en un lenguaje de programacin o
lenguaje de alto nivel.
2.6 DOCUMENTACIN
2.7 MANTENIMIENTO
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 -.
Algunos ejemplo de datos enteros son: 0, 23, -176, -1, etc.
Para definir variables en C se antepone la palabra reservada del tipo al
identificador de la variable. El tipo de datos entero se define en el
lenguaje de programacin C por la palabra reservada int.
Para definir un tipo de dato en C se escribe lo siguiente:
int nombre_variable = valor;
No es necesario que la variable tenga un valor predeterminado. Se
puede definir sin asignarle ningn valor. Si tenemos varios datos que
son del mismo tipo, se pueden definir todas en la misma lnea de cdigo
escribiendo un nico int, separando el nombre de las variables por ,.
Una vez que se haya acabado de definir variables, se cierra la lnea de
cdigo con ;,
Por ejemplo: int edad = 24;
int edad;
int edad, num, contador;
un
el
de
la
Aritmticas
Relacinales
Lgicas
PALABRAS RESERVADAS.
Son palabras que tienen un significado especial para el lenguaje y no se
pueden utilizar como identificadores. Por ejemplo: int, float, char, void,
class, struct, etc.
CAPITULO 3
Programacin
Estructurada
ESTRUCTURAS DE CONTROL
Ejecutar un grupo
condicin (Do-Until)
de
se
cumpla
una
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.
1)
2)
n)
"Else")
} else {
// Haz esto
} En caso contrario {
2- BUCLES: WHILE
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) {
}
3- BUCLES: DO WHILE
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
4- 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.
for (valor inicial; condicin; ejecutar en cada bucle) {
//
}
Instrucciones
ejecutar
mientras
la
condicin
sea
cierta
CAPITULO 4
Arreglos
ARREGLOS
DEFINICIN:
Un arreglo es un tipo de dato estructurado que almacena en una sola
variable un conjunto limitado de datos o elementos del mismo tipo.
Asimismo, es un conjunto de localidades de memoria contiguas donde la
direccin ms baja corresponde al primer elemento y la direccin ms
alta al ltimo. Por s mismo, el nombre del arreglo apunta a la direccin
del primer elemento del arreglo. Los datos se llaman elementos del
arreglo y su posicin se numera consecutivamente: 1, 2, 3n. Un
arreglo en lenguaje C inicia en la posicin cero, por lo tanto el i-simo
elemento est en la posicin i-1, es decir si el arreglo llamado a tiene n
elementos, sus nombres son: a[0], a[1], ..., a[n-1].
El tipo de elementos almacenados en el arreglo puede ser cualquier tipo
de dato.
Para acceder a un elemento especfico de un arreglo se usa un ndice o
subndice.
Un arreglo se caracteriza por:
1. Ser una lista de un nmero finito de n elementos del mismo tipo.
2. Almacenar los elementos del arreglo en memoria contigua.
3. Tener un nico nombre de variable que representa a todos los
elementos y stos se diferencian por un ndice o subndice.
4. Acceder de manera directa o aleatoria a los elementos individuales
del arreglo, por el nombre del arreglo y el ndice o subndice.
5. Se clasifican en arreglos unidimensionales, bidimensionales, y
multidimensionales.
LENGUAJE C
Int a[100], x[50];
LENGUAJE C
Tipo_dato_ident_arreglo[tam_a
rreglo];
Dnde:
Tipo_dato: Se refiere al tipo de dato de cada elemento del arreglo;
puede ser entero, real, carcter, etctera.
ident_arreglo: Es el nombre que representa a todo el arreglo
tam_arreglo: Es la cantidad de elementos que contiene el arreglo.
ARREGLOS EN LA MEMORIA:
Si tomamos la declaracin del arreglo lista del ejemplo anterior, as se
representara en memoria entero lista [4]:
Posicin de
memoria
Lista
100
0
100
1
1002
1003
1004
1005
100
6
1007
3
LENGUAJE C
Float x[8];
x[0]
7.1 x[5] 1
x[1]
x[2]
x[6]
x[7]
0.5
57.9 55.1
x[3]
x[4]
Posicione
s
12
ELEMENT
OS
Este arreglo contiene ocho elementos almacenados entre la posicin (07). 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.
LENGUAJE C
a = x[0] + x[1] + x[2]
printf(%f,a)
LENGUAJE C
Tipo_dato identif[tam_arreglo]
= {valores}
Int lista [5] = {10, 17, 8, 4, 9}
PSEUDOCODIGO
Tipo_dato ident_arr[pos]<valor
Entero b[3] <- 18
LENGUAJE C
Tipo_dato ident_arr[pos] = valor;
Int b[3] = 18;
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
caracter cad[ ]<-Lenguaje
LENGUAJE C
Char cad[ ]=Lenguaje;
LENGUAJE C
Tipo_dato ident_arr [tam_fila]
[tam_col];
Int b [3][4];
Dnde:
tipo_dato es el tipo de dato de todo el arreglo.
ident_arr es el nombre del arreglo.
tam_fila es el total de filas.
tam_col es el total de columnas.
B
Fila 0
Fila 1
Fila 2
Col 0
b[0][0]
b[1][0]
b[2][0]
Col 1
b[0][1]
b[1][1]
b[2][1]
Col 2
b[0][2]
b[1][2]
b[2][2]
Col 3
b[0][3]
b[1][3]
b[2][3]
LENGUAJE C
T_dato identif[fil] [col={valores};
Int a [3][3] = {1, 2, 3, 4, 5, 6, 7, 8,
9};
PSEUDOCODIGO
Desde( i<-0, i<3, <-i+1)
Desde( j<-0, j<4, <-j+1)
Leer mat[i][j]
LENGUAJE C
for( i<-0, i<3, <-i+1)
for( j<-0, j<4, <-j+1)
scanf(%d, &mat[i][j]);
PSEUDOCODIGO
tipo_dato ident_arr[fil] [col] <valores
Entero b[3][5]<- 18
LENGUAJE C
tipo_dato ident_arr[fil]
[col=valores;
Int a [3][5] = 18;
Ejemplo:
Programa que guardar los nombres de los alumnos de un saln de
clases en un arreglo y posteriormente imprimirlos.
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.
El segundo desde (for) sirve para imprimir en pantalla la lista de
nombres.
CAPITULO 5
MODULARIDAD
MODULARIDAD
CAPITULO 6
APUNTADORES
DECLARACIN DE UN PUNTERO
Un puntero, en C, se declara como sigue:
TIPO * nombre_puntero ;
Donde TIPO es cualquier tipo definido. Asi, un puntero a caracter se
declararia de la siguiente forma:
char *pchar;
DIFERENCIA ENTRE "*" Y "&"
pchar = &a;
+---------------+
| @ 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:
void inicializa ( char **buffer);
main()
{
char *buff;
.
.
.
buff = NULL;
/* y pasando buff por referencia */
inicializa ( &buff );
/* ahora *buff = 'a' */
.
.
.
}
void inicializa ( char **buffer)
{
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.
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
El caso ms trivial de todos: no reservar espacio creyendo que la
declaracin del puntero ya lo hace por s misma.
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 */
}