Guia Fundamentos
Guia Fundamentos
Guia Fundamentos
ACADEMIA DE COMPUTACION
1. Introduccion.
1.1 Que es una computadora. Es una máquina de calcular con una secuencia de
operaciones establecidas en un programa almacenado dentro de ella.
1.2 Cuáles son las partes de una computadora. Son el HARDWARE y el SOFTWARE. Similar
al cuerpo de un ser vivo y el estado de no estar muerto.
1.3.1.1.2 Byte o carácter es cualquiera de los caracteres con los que se opera.
Es un conjunto de 8 bits y según la combinación de ellos, es el
carácter, todo esto de acuerdo a un código, el más usual es el código
ASCII.
1.3.2 PERIFERICOS. Son dispositivos que están alrededor de la UPC y son los que
interactúan con la memoria central para proporcionar información o para
recibirla después de haber sido procesada. Son de ENTRADA, SALIDA y
ENTRADA/SALIDA.
1.3.2.3 ENTRADA/SALIDA. Tiene las dos funciones. Ejemplos: disco duro. Esta
característica es 3 de 3 que determina la potencia de un equipo de cómputo.
Todas las acciones de la computadora pasan por el S.O. y estas órdenes están
en lenguaje de máquina o binario.
1.4.3 INTERPRETES. Son lenguajes que operan 1 instrucción en lenguaje fuente hasta
generar la acción correspondiente, pasando por el ensamblador y lenguaje de
máquina, para después operar la siguiente instrucción. Esto hace que, al
encontrar un error, se termine la ejecución del programa. Ejemplos de
intérpretes es el basic, dBase. En posteriores ejecuciones se repite en su
totalidad este procedimiento.
1.4.4 COMPILADORES. Son lenguajes que operan todas las instrucciones del lenguaje
fuente, generan el programa ensamblador y posteriormente el programa en
lenguaje de máquina, para después operar la totalidad de acciones. En el caso
de encontrar errores, se termine la ejecución del programa en el paso que vaya,
reportando la totalidad de ellos. Cuando el proceso es exitoso, el programa
ejecutable en su totalidad se guarda, permitiendo que en posteriores ocasiones
se opere este archivo, sin necesidad de compilarlo nuevamente. Ejemplos de
compiladores son Fortran, Cobol, Pascal, “C”, etc.
Estructurados VS No-estructurados:
2.1 Definición del problema. Se refiere a entender el problema, considerando los datos
significativos para la solución y desechando los datos intrascendentes.
2.2 Análisis del problema. Detectar de los datos significativos cuales son los necesarios
como alimentación de entrada y cuál es el/los datos de salida.
2.4 Interfaz de usuario. Es un esquema que muestra lo que deseamos que aparezca en el
periférico de salida (monitor, impresora, etc), cuando se ejecuta el programa.
2.5 Pasos computacionales. Indica con palabras el conjunto de acciones que realizará la
computadora en el proceso. Se distinguen 5 pasos que normalmente constituyen el
proceso de un programa iterativo (repetitivo). Este tipo de programa es el más usual,
constituye como el 99% de los programas. El otro tipo de programas es el directo (datos
de entrada, cálculos, resultado; 3 módulos).
2.6 Diagrama de flujo. Es una representación gráfica de los Pasos computacionales. Implica
tener una serie de símbolos con un significado predefinido. (es independiente del
lenguaje).
2.7 Codificación. Es una traducción del diagrama de flujo, (es particular de cada lenguaje) a
instrucciones de un lenguaje en particular.
2.8 Prueba del programa. Con la computadora se checa que no tenga errores de sintaxis, si
los hay se corrigen.
Se checa que no halla errores de lógica comparando el resultado con uno previamente
obtenido y comprobado. Si los hay se corrigen.
2.9 Liberación del programa. Al pasar exitosamente el punto 2.8, se libera el programa para
su explotación.
3.1.2 Directivas al compilador. Precedidas por “#”. Son archivos de cabecera (header
files) que intercalan librerías con seudoinstrucciones para la ejecución; son
definiciones de valores numéricos, letreros o fórmulas. Ejemplos:
#include <stdio.h>
#define PI 3.14159
Int main()
3.2 Variables. Son identificadores que almacenan diferentes valores dentro del proceso.
- X es un carácter alfabético.
Ejemplos:
int a,b,c,primero=0,d;
float balance=123.45;
3.2.6 Parámetros. Se refieren a las variables que se mandan cuando se llama a una
función, para que pueda operar.
nombre_de_la_variable = expresión
3.3 Constantes. Son identificadores que almacenan permanentemente valores dentro del
proceso. Los tipos de constantes son los mismos que las variables. Dentro de las de tipo
char, existen unas constantes especiales con un significado:
\f salto de página
\n salto de línea
\r retorno de carro
\t tabulador horizontal
\” comillas dobles
\’ comillas sencillas
\0 nulo
\\ diagonal inversa
\v tabulador vertical
\a alarma
\o constante octal
\x constante hexadecimal
3.4 Operadores. Son símbolos que realizan una acción con 1 o 2 operandos (variables o
expresiones). Son:
3.4.1 Aritméticos:
Resta - 1
Suma + 1
Producto * 2
División / 2
División en modulo % 2
Decremento -- 3
Incremento ++ 3
3.4.2 Lógicos:
A B A&&B A||B ¡A
F F F F V
F V F V V
V F F V F
V V V V F
Dirección = &variable
Contenido = *dirección
Operador sizeof
Se dividen en:
3.5.1 if
sintaxis:
if(expression) sentencia;
3.5.2 if/else
sintaxis:
if(expresión) sentencia1;
else sentencia2;
3.5.3 if anidado
sintaxis:
if(expresión)sentencia1;
else if(expreion2)sentencia3;
else if(expreion3)sentencia4;
………
else sentencian;
3.5.4 switch
sintaxis:
switch(variable){
case constante1:
secuencia de sentencias;
break;
case constante2:
secuencia de sentencias;
break;
case constante3:
secuencia de sentencias;
break;
……………
default:
secuencia de sentencias;
3.5.5 while
sintaxis
while(condicion)sentencia;
3.5.6 do/while
sintaxis
do{
sentencia;
}while(condicion);
3.5.7 for
sintaxis
for(inicialización;condición_final;modificación ) sentencia;
3.5.8 continue
En un bucle (while, do/while, for) permite iniciar una nueva iteración
anticipadamente.
Sintaxis: continue;
3.5.9 break
Sintaxis: break;
3.5.10 exit
Sintaxis: exit(0);
3.5.11 return
3.6 Funciones.
3.6.1 Definicion: Es un subprograma que realiza una tarea y que es llamado por
“main” u otra función y que opcionalmente regresa un valor
(int,float,doublé,char, etc). Para operar, opcionalmente requiere de datos
(parámetros). Al terminar regresa el control a la siguiente instrucción de donde
fue llamado.
3.6.2.1 Prototipo o firma de función. Similar a una caja negra, informa del nombre
de la función, que regresa al terminar y que datos requiere para operar.
3.6.4 Parámetros de una función. Cuando son necesarios son los datos que requiere
la función para operar, pueden ser por VALOR o por REFERENCIA.
3.6.4.1 Parámetros por VALOR. Se transfiere una copia de la variable, de tal forma
que en si es otra variable. Los cambios que se realicen dentro de la función
se pierden al regresar al main/otra-función.
3.7 Arreglos.
3.7.1 Definición
3.7.2 Tipo de arreglos. Similar a las variables. Pueden ser int, float, doublé, char, etc.
3.7.5 Operación.
char ce[2][3][4]=
{ {“111”},{“112”},{“113”},{“114”} },
{ {“121”},{“122”},{“123”},{“124”} },
{{“131”},{“132”},{“133”},{“134”}}
{ {“211”},{“212”},{“213”},{“214”} },
{ {“221”},{“222”},{“223”},{“224”} },
{{“231”},{“232”},{“233”},{“234”}}
};
Int id[2][3][4]=
{111,112,113,114},
{121,122,123,124},
{131,132,133,134}
},
{211,212,213,214},
{221,222,223,224},
{231,232,233,234}
};
strcpy(cc[0], “aa”);
strcpy(cc[1], “bb”);
Arreglo de n dimensiones.
3.8 Punteros.
3.8.1 Definición.
3.8.3 Operación
3.9 Estructuras.
3.9.1 Definición.
Es un tipo de dato definido por el usuario y que aglutina a varias variables básicas (char, int,
float, doouble), y/o otras estructuras.
3.9.2 Operación
int a,b;
3.9.3 Ejemplo:
struct Fecha{
int aa,mm,dd;
};
struct Alumno{
char nom[30];
int edad;
float prom;
strcpy(A1.nom, “nomA1”);
pA2→edad=22;
A3[5].prom=7.8;
pA4[3]→fNac.aa=2016;
A3[4].fNac.mm=12;
A1.fNac.dd=30;
3.10 Uniones.
3.10.1 Definición.
Es un tipo de dato definido por el usuario y se refiere a que un espacio de memoria se puede
manipular con diferente formato. Similar a que al perfil del país, por medio de acetatos, se
observen las entidades federativas, o los ríos, o las cadenas montañosas.
3.10.2 Operación
int a,b;
3.10.3 Ejemplo:
struct X{
char nom[30];
int edad;
union vistas{
//vista a
struct {
int d1;
char d2[20];
float d3;
}vt1;
//vista b
struct {
int d1;
char d2[20];
float d3;
} vt2;
//vista c
struct {
int da;
char db[40];
} vt3;
//vista d
char x[30];
//vista e
int y;
} unionVistas4;
};
struct X var;
strcpy(var.nom,”nomX”);
var.edad=20:
switch bandera{
case 1:
//vista a
var.unionVista4.vt1.d1=100;
break;
case 2:
//vista b
strcpy(var.unionVista4.vt2.d2, “dato2char”);
var.unionVista4.vt2.d1=-22;
break;
case 3:
//vista c
var.unionVist4.vt3.da=33;
strcpy(var.unionVista4.vt3.db,”XXXXXXX”);
break;
case 4:
//vista 4
strcpy(var.unionVista4.x,”XXXXXXX”);
break;
default:
//vista e
var.unionVist4.y=33;
} //switch
3.11 Enumeraciones.
3.11.1 Definición.
Es un tipo de dato definido por el usuario y se refiere a que a una serie de números enteros
normalmente iniciada con cero se les nombra mnemónicamente con caracteres. Lo anterior
para que dentro del programa se haga referencia a esos nombres en lugar de los valores
numéricos.
3.11.2 Operación
int a,b;
3.11.3 Ejemplo:
enum defEnum {v1=1, v2, v3, v4, v5}; // de lo contrario seria v1=0
struct X{
char nom[30];
int edad;
// variable bandera, indica que formato o vista, es una var tipo enum
union vistas{
//vista a
struct {
int d1;
char d2[20];
float d3;
}vt1;
//vista b
struct {
int d1;
char d2[20];
float d3;
} vt2;
//vista c
struct {
int da;
char db[40];
} vt3;
//vista d
char x[30];
//vista e
int y;
} unionVistas4;
};
B) Creación variables tipo enum definida para operar una union (varias vistas) dentro de
la definición de una estructura
struct X var;
strcpy(var.nom,”nomX”);
var.edad=20:
switch bandera{
//vista a
var.unionVista4.vt1.d1=100;
break;
case v2:
//vista b
strcpy(var.unionVista4.vt2.d2, “dato2char”);
var.unionVista4.vt2.d1=-22;
break;
case v3:
//vista c
var.unionVist4.vt3.da=33;
strcpy(var.unionVista4.vt3.db,”XXXXXXX”);
break;
case v4:
//vista 4
strcpy(var.unionVista4.x,”XXXXXXX”);
break;
default:
//vista e
var.unionVist4.y=33;
} //switch