EJERCICIO DE PROGRAMACION
Juan EsquedaTarea31 de Octubre de 2018
2.147 Palabras (9 Páginas)128 Visitas
Santiago de Querétaro, Qro. Viernes 21 de Septiembre del 2018
INSTITUTO TECNOLÓGICO DE QUERÉTARO
[pic 1]
ACTIVIDAD
Juan Manuel Esqueda Pérez.
ALGORIRMOS Y PROGRAMACION
GRUPO 5V
- SUMA DE DOS NUMEROS.
#include
#include
int i;
main()
{
printf("\n\n ESQUEDA PEREZ JUAN MANUEL");
//PROGRAMA QUE IMPRIME DEL 1 AL 10
for(i=1;i<=10;i++)
{
printf("\n%d",i);
getch();
}
getch();
return 0;
}
[pic 2]
- PROGRAMA QUE IMPRIME DEL 1 AL 10.
#include
#include
int a,b,c;
main()
{
printf("\n\nESQUEDA PEREZ JUAN MANUEL");
//PROGRAMA QUE SUMA DOS NUMEROS
{printf("\n dame el valor de a");
scanf("%d",&a);
printf("\n dame el valor de b");
scanf("%d",&b);
c=a+b;
printf("\n_el_resultado_es_%d",c);
}
getch();
return 0;
}
[pic 3]
- UNIR EJERCICIO 1 Y 2.
#include
#include
int i,a,b,c,d,e,f,g,h,j,k;
main()
{
printf("\n\n ESQUEDA PEREZ JUAN MANUEL");
//PROGRAMA QUE IMPRIME 10 SUMAS
for(i=1;i<=10;i++)
{
printf("\n%d",i);
getch();
}
{
a=i+i;
printf("\n_el_resultado_es_%d",a);
b=i+a;
printf("\n_el_resultado_es_%d",b);
c=i+b;
printf("\n_el_resultado_es_%d",c);
d=i+c;
printf("\n_el_resultado_es_%d",d);
e=i+d;
printf("\n_el_resultado_es_%d",e);
f=i+e;
printf("\n_el_resultado_es_%d",f);
g=i+f;
printf("\n_el_resultado_es_%d",g);
h=i+g;
printf("\n_el_resultado_es_%d",h);
j=i+h;
printf("\n_el_resultado_es_%d",j);
k=j+j;
printf("\n_el_resultado_es_%d",k);
}
getch();
return 0;
}[pic 4]
- EJERCICIO 3.14
- SUMA
//EJERCICIO 3.14
#include
#include
main()
{
printf("\n\n ESQUEDA PEREZ JUAN MANUEL");
//SUMA DE PARES DEL 20 AL 400
int i,suma=0;
for(i=20;i<=400;i+=2)
{
suma += i;
}
printf("\nla suma de los numeros pares es: %i",suma);
return 0;
}
[pic 5]
4. EJERCICIO 3.14
- MULTIPLICACION
#include
#include
main()
{
printf("\n\n ESQUEDA PEREZ JUAN MANUEL");
//PRODUCTO DE PARES DEL 20 AL 400
int i,producto=20;
for(i=20;i<=400;i*=2)
{
producto *= i;
}
printf("\nel producto de los numeros pares es: %i",producto);
return 0;
}
[pic 6]
- EJERCICIO 3.16
#include
#include
int IVA,CANTIDAD,PRECIO_SIN_IMPUESTO,PRECIO_BRUTO,DESCUENTO,TOTAL;
main()
{
printf("\n\n ESQUEDA PEREZ JUAN MANUEL");
//EJERCICIO 3.16
{
printf("\n dame el valor de PRECIO_SIN_IMPUESTO");
scanf("%d",&PRECIO_SIN_IMPUESTO);
printf("\n dame el valor de CANTIDAD");
scanf("%d",&CANTIDAD);
PRECIO_SIN_IMPUESTO=PRECIO_SIN_IMPUESTO*CANTIDAD;
printf("\n_el_precio_sin_impuesto_es_%d",PRECIO_SIN_IMPUESTO);
IVA=PRECIO_SIN_IMPUESTO*0.15;
printf("\n_el_iva_es_%d",IVA);
PRECIO_BRUTO=PRECIO_SIN_IMPUESTO+IVA;
printf("\n_el_precio_bruto_es_%d",PRECIO_BRUTO);
{
if(DESCUENTO,PRECIO_BRUTO>=1000)
DESCUENTO=PRECIO_BRUTO*.05;
printf("\n_el_descuento_es_%d",DESCUENTO);
}
}
TOTAL=PRECIO_BRUTO-DESCUENTO;
printf("\n_EL TOTAL_ES %d",TOTAL);
getch();
return 0;
}
[pic 7]
[pic 8]
- EJERCICIO 3.19
#include
#include
int primer_numero,segundo_numero,tercer_numero,cuarto_numero,quinto_numero,sexto_numero,septimo_numero,octavo_numero,noveno_numero,decimo_numero,suma_total;
main()
{
printf("\n\n ESQUEDA PEREZ JUAN MANUEL");
//EJERCICIO 3.19
{
printf("\n dame el valor de primer_numero");
scanf("%d",&primer_numero);
printf("\n dame el valor de segundo_numero");
scanf("%d",&segundo_numero);
printf("\n dame el valor de tercer_numero");
scanf("%d",&tercer_numero);
printf("\n dame el valor de cuarto_numero");
scanf("%d",&cuarto_numero);
printf("\n dame el valor de quinto_numero");
scanf("%d",&quinto_numero);
printf("\n dame el valor de sexto_numero");
scanf("%d",&sexto_numero);
printf("\n dame el valor de septimo_numero");
scanf("%d",&septimo_numero);
printf("\n dame el valor de octavo_numero");
scanf("%d",&octavo_numero);
printf("\n dame el valor de noveno_numero");
scanf("%d",&noveno_numero);
printf("\n dame el valor de decimo_numero");
scanf("%d",&decimo_numero);
printf("\n dame el valor de tercer_numero");
suma_total=primer_numero+segundo_numero+tercer_numero+cuarto_numero+quinto_numero+sexto_numero+septimo_numero+octavo_numero+noveno_numero+decimo_numero;
printf("\n_el_resultado_es_%d",suma_total);
}
getch();
return 0;
}[pic 9]
Contenidos BASES TEÓRICAS. INTRODUCCIÓN A LA POO................................................ 1 INTRODUCCIÓN...............................................................................................................................1 PARADIGMAS DE PROGRAMACIÓN.....................................................................................................1 PROGRAMACIÓN IMPERATIVA ..........................................................................................................2 Tipos de datos.............................................................................................................................2 Operadores y expresiones...............................................................................................................3 Algoritmos y estructuras de control .................................................................................................4 Funciones y procedimientos...........................................................................................................4 Constantes y variables ..................................................................................................................5 PROGRAMACIÓN MODULAR .............................................................................................................6 TIPOS ABSTRACTOS DE DATOS..........................................................................................................6 PROGRAMACIÓN ORIENTADA A OBJETOS ...........................................................................................7 Objetos y mensajes......................................................................................................................7 Clases........................................................................................................................................7 Herencia y polimorfismo...............................................................................................................7 Programación con objetos..............................................................................................................7 EL LENGUAJE C++..................................................................................... 9 INTRODUCCIÓN...............................................................................................................................9 CONCEPTOS BÁSICOS......................................................................................................................9 Estructura de los programas............................................................................................................9 Tipos de datos y operadores.......................................................................................................... 10 Estructuras de control.................................................................................................................. 11 Funciones................................................................................................................................. 12 Soporte a la programación modular................................................................................................ 12 Soporte a los Tipos de Datos Abstractos......................................................................................... 13 Soporte a la programación Orientada a Objetos................................................................................ 13 TIPOS DE DATOS, OPERADORES Y EXPRESIONES................................................................................. 13 Tipos de datos........................................................................................................................... 13 Tipos elementales...................................................................................................................... 13 Tipos enumerados...................................................................................................................... 14 Tipos derivados.......................................................................................................................... 15 Tipos compuestos...................................................................................................................... 16 Constantes (literales).................................................................................................................. 18 Variables.................................................................................................................................. 19 Conversiones de tipos................................................................................................................. 20 Operadores y expresiones............................................................................................................. 21 ESTRUCTURAS DE CONTROL ........................................................................................................... 24 Estructuras de selección............................................................................................................... 24 Estructuras de repetición.............................................................................................................. 26 Estructuras de salto..................................................................................................................... 27 FUNCIONES.................................................................................................................................. 28 Declaración de funciones.............................................................................................................. 28 Definición de funciones............................................................................................................... 28 Paso de parámetros..................................................................................................................... 29 Parámetros array ........................................................................................................................ 29 Retorno de valores...................................................................................................................... 30 Sobrecarga de funciones............................................................................................................... 30 Parámetros por defecto ................................................................................................................ 30 Parámetros indefinidos................................................................................................................ 31 Recursividad.............................................................................................................................. 32 Punteros a funciones................................................................................................................... 33 La función main() ...................................................................................................................... 33 VARIABLES DINÁMICAS................................................................................................................. 34 Punteros y direcciones................................................................................................................. 34 El puntero NULL....................................................................................................................... 35 Punteros void............................................................................................................................ 35 Aritmética con punteros .............................................................................................................. 36 Punteros y parámetros de funciones ............................................................................................... 37 iv Punteros y arrays........................................................................................................................37 Operadores new y delete...............................................................................................................38 Punteros y estructuras.................................................................................................................39 Punteros a punteros ....................................................................................................................39 PROGRAMACIÓN EFICIENTE............................................................................................................40 Estructura de los programas..........................................................................................................40 El preprocesador.........................................................................................................................42 Funciones inline ........................................................................................................................43 Inclusión de rutinas en ensamblador ...............................................................................................43 Eficiencia y claridad de los programas.............................................................................................44 CLASES........................................................................................................................................44 Introducción ..............................................................................................................................44 Clases y miembros.....................................................................................................................45 Métodos estáticos y funciones amigas ............................................................................................50 Construcción y destrucción...........................................................................................................51 HERENCIA Y POLIMORFISMO...........................................................................................................56 Clases derivadas o subclases .........................................................................................................56 Clases abstractas........................................................................................................................60 Herencia múltiple.......................................................................................................................61 Control de acceso .......................................................................................................................63 Gestión de memoria....................................................................................................................64 SOBRECARGA DE OPERADORES .......................................................................................................64 Funciones operador.....................................................................................................................64 Conversiones de tipos.................................................................................................................66 Operadores y objetos grandes ........................................................................................................67 Asignación e inicialización...........................................................................................................67 Subíndices................................................................................................................................68 Llamadas a función.....................................................................................................................68 Dereferencia...............................................................................................................................69 Incremento y decremento..............................................................................................................69 Sobrecarga de new y delete ...........................................................................................................69 Funciones amigas o métodos........................................................................................................70 TEMPLATES..................................................................................................................................70 Genericidad................................................................................................................................70 Funciones genéricas....................................................................................................................71 Clases genéricas.........................................................................................................................72 MANEJO DE EXCEPCIONES..............................................................................................................73 Programación y errores................................................................................................................73 Tratamiento de excepciones en C++ (throw - catch - try)....................................................................73 ENTRADA Y SALIDA.......................................................................................................................76 Introducción ..............................................................................................................................76 Objetos Stream..........................................................................................................................76 Entrada y salida..........................................................................................................................76 Ficheros...................................................................................................................................79 PROGRAMACIÓN EN C++................................................................................................................80 El proceso de desarrollo ...............................................................................................................80 Mantenibilidad y documentación....................................................................................................80 Diseño e implementación.............................................................................................................81 Elección de clases.......................................................................................................................81 Interfaces e implementación..........................................................................................................81 LIBRERÍAS DE CLASES....................................................................................................................81 Diseño de librerías......................................................................................................................82 Clases Contenedor......................................................................................................................82 Clases para aplicaciones...............................................................................................................83 Clases de Interface ......................................................................................................................83 Eficiencia temporal y gestión de memoria ................................... 5 Bibliografía básica — Brian W. Kernighan, Dennis M. Ritchie, The C Programming Language, Second Edition, Prentice Hall, 1988 — Bjarne Stroustrup, The C++ Programming Language, Second Edition, Addison-Wesley, 1991 — Enrique Hernández Orallo, José Hernández Orallo, Programación en C++, Paraninfo, 1993 1 Bases teóricas. Introducción a la POO. INTRODUCCIÓN Para comenzar a estudiar cualquier lenguaje de programación se debe conocer cuales son los conceptos que soporta, es decir, el tipo de programación que vamos a poder realizar con él. Como el C++ incorpora características nuevas respecto a lenguajes como Pascal o C, en primer lugar daremos una descripción a los conceptos a los que este lenguaje da soporte, repasando los paradigmas de programación y centrándonos en la evolución desde la programación Funcional a la programación Orientada a Objetos. Más adelante estudiaremos el lenguaje de la misma manera, primero veremos sus características funcionales (realmente la parte que el lenguaje hereda de C) y después estudiaremos las extensiones que dan soporte a la programación orientada a objetos (el ++ de C++). PARADIGMAS DE PROGRAMACIÓN Según los conceptos en que se basa un lenguaje de programación tenemos distintas maneras de aproximarnos a la resolución de los problemas y diferentes estilos de programación. Podemos clasificar los lenguajes de programación en varios tipos: — Imperativos — Orientados a Objetos — Funcionales — Lógicos Las dos primeras opciones se basan en la abstracción de los tipos de datos. Básicamente se trata de representar las características variables de los objetos mediante tipos que el ordenador pueda tratar, como por ejemplo números enteros o caracteres alfanuméricos. Nuestro programa será una colección de algoritmos que opere sobre los datos que hemos modelado. La diferencia entre las dos aproximaciones se verá en puntos posteriores. Los lenguajes funcionales, al contrario que los imperativos, eliminan totalmente la idea de tipo de datos, se limitan a tratar todos los datos como símbolos y hacen hincapié en las operaciones que podemos aplicar sobre estos símbolos, agrupados en listas o árboles. Es importante indicar que en estos lenguajes se emplea únicamente el concepto de función aplicado a símbolos, siendo una de sus características principales el empleo de las funciones recursivas. Como ejemplo de este tipo de lenguajes podríamos citar el LISP. 2 Los lenguajes lógicos son los que trabajan directamente con la lógica formal, se trata de representar relaciones entre conjuntos, para luego poder determinar si se verifican determinados predicados. El lenguaje lógico más extendido es el Prolog. PROGRAMACIÓN IMPERATIVA Como ya hemos mencionado anteriormente, la programación imperativa trata con tipos de datos y algoritmos, los primeros representan la información utilizada por los programas, mientras que los segundos se refieren a la manera en que tratamos esa información. En los puntos que siguen revisaremos de forma breve los conceptos fundamentales de la programación imperativa clásica, también llamada programación procedural. La idea básica de esta aproximación es la de definir los algoritmos o procedimientos más eficaces para tratar los datos de nuestro problema. Tipos de datos Cuando nos planteamos la resolución de problemas mediante computador lo más usual es que queramos tratar con datos que son variables y cuantificables, es decir, que toman un conjunto de valores distintos entre un conjunto de valores posibles, además de poder almacenar los valores de estos datos en alguna forma aceptable para el computador (ya sea en la memoria o en periféricos de almacenamiento externo). En un lenguaje de programación el concepto de tipo de datos se refiere al conjunto de valores que puede tomar una variable. Esta idea es similar a la que se emplea en matemáticas, donde clasificamos las variables en función de determinadas características, distinguiendo entre números enteros, reales o complejos. Sin embargo, en matemáticas, nosotros somos capaces de diferenciar el tipo de las variables en función del contexto, pero para los compiladores esto resulta mucho más difícil. Por este motivo debemos declarar explícitamente cada variable como perteneciente a un tipo. Este mecanismo es útil para que el computador almacene la variable de la forma más adecuada, además de permitir verificar que tipo de operaciones se pueden realizar con ella. Se suelen diferenciar los tipos de datos en varias categorías: — Tipos elementales, que son aquellos cuyos valores son atómicos y, por tanto, no pueden ser descompuestos en valores más simples. Entre las variables de estos tipos siempre encontramos definidas una serie de operaciones básicas: asignación de un valor, copia de valores entre variables y operaciones relacionales de igualdad o de orden (por lo tanto, un tipo debe ser un conjunto ordenado). Los tipos más característicos son: booleanos = {verdadero, falso} enteros = {… -2, -1, 0, +1, +2, …} reales = {… -1.0, …, 0.0, …, +1.0, …} caracteres = {… 'a', 'b', …, 'Z', …} Generalmente existen mecanismos para que el usuario defina nuevos tipos elementales por enumeración, es decir, definiendo el conjunto de valores explícitamente. Por ejemplo podríamos definir el tipo día como {lunes, martes, miércoles, jueves, viernes, sábado, domingo}, las variables definidas como día sólo podrían tomar estos valores. Por último mencionaremos otro tipo de datos elemental de características especiales, el puntero, que es el tipo que almacena las direcciones de las variables (la dirección de memoria en la que se almacena su valor). Analizaremos este tipo más adelante. 3 — Tipos compuestos o estructurados, que son los tipos formados a partir de los elementales. Existen varias formas de agrupar los datos de tipos elementales: La más simple es la estructura indexada, muy similar a los vectores o matrices de matemáticas, en donde lo que hacemos es relacionar unos índices (pertenecientes a un tipo de datos) con los valores de un tipo determinado. Sobre estas estructuras se pueden realizar las operaciones de consulta o asignación de un valor (a través de su índice). Otra estructura compuesta muy importante es el registro, que no es más que una sucesión de elementos de distintos tipos, denominados campos, que llevan asociados un identificador. Sobre estos tipos se definen las operaciones de asignación y de acceso a un campo. Algunos lenguajes también soportan la operación de asignación para toda la estructura (la copia de todos los campos en un solo paso). El tipo cadena de caracteres es un caso especial de tipo de datos, ya que algunos lenguajes lo incorporan como tipo elemental (con un tamaño fijo), mientras que en otros lenguajes se define como un vector de caracteres (de longitud fija o variable) que es una estructura indexada. Como se ve, los campos de un registro pueden ser de otros tipos compuestos, no sólo de tipos elementales. — Tipos recursivos, que son un caso especial de tipos compuestos, introduciendo la posibilidad de definir un tipo en función de sí mismo. Para terminar nuestro análisis de los tipos de datos, hablaremos de la forma en que los lenguajes de programación relacionan las variables con sus tipos y las equivalencias entre distintos tipos. Hemos dicho que el empleo de tipos de datos nos sirve para que el computador almacene los datos de la forma más adecuada y para poder verificar las operaciones que hacemos con ellos. Sería absurdo que intentáramos multiplicar un carácter por un real pero, si el compilador no comprueba los tipos de los operandos de la multiplicación, esto sería posible e incluso nos devolvería un valor, ya que un carácter se representa en binario como un número entre 0 y 255. Para evitar que sucedan estas cosas los compiladores incorporan mecanismos de chequeo de tipos, verificando antes de cada operación que sus operandos son de los tipos esperados. El chequeo se puede hacer estática o dinámicamente. El chequeo estático se realiza en tiempo de compilación, es decir, antes de que el programa sea ejecutable. Para realizar este chequeo es necesario que las variables y los parámetros tengan tipos fijos, elegidos por el programador. El chequeo dinámico se realiza durante la ejecución del programa, lo que permite que las variables puedan ser de distintos tipos en tiempo de ejecución. Por último señalaremos que existe la posibilidad de que queramos realizar una operación definida sobre un tipo de datos, por ejemplo reales, aplicada a una variable de otro tipo, por ejemplo entera. Para que podamos realizar esta operación debe de existir algún mecanismo para compatibilizar los tipos, convirtiendo un operando que no es del tipo esperado en éste, por ejemplo transformando un entero en real, añadiendo una parte decimal nula, o transformando un real en entero por redondeo. Operadores y expresiones Como ya hemos dicho con los datos de un tipo podemos realizar determinadas operaciones pero, ¿cómo las expresamos en un lenguaje de programación? Para resolver este problema aparecen lo que llamamos operadores. Podemos decir que un operador es un símbolo o conjunto de símbolos que representa la aplicación de una función sobre unos operandos. Cuando hablamos de los operandos no sólo nos referimos a variables, sino que hablamos de cualquier elemento susceptible de ser evaluado en alguna forma. Por ejemplo, si definimos una variable entera podremos aplicarle operadores aritméticos (+, -, *, /), de asignación (=) o relacionales (>,
...