BLOQUE #2
UNIDAD EDUCATIVA SALESIANA DON BOSCO
NOMBRE:MICHELLE PAREDES
CURSO:2 INFORMATICA
Modo gráfico en Dev C++
La librería winbgim tiene como objetivo emular la librería graphics.h de Borland C++ y facilitar algunas funciones del mouse. La ventaja de esta librería es que nos permite crear aplicaciones gráficas con compiladores GNU tales como el ambiente de desarrollo Dev C++ de la misma manera como se crean en el compilador comercial Borland C++.
Originalmente el autor nos ofrecía una colección de archivos que se debían ubicar en carpetas especiales e incluir ciertos comandos al la configuración del linker y del compilador, esta operación tenia cierta complejidad y para muchos se convirtió en un dolor de cabeza.
Con el fin de facilitar el uso de esta librería me tome la libertad de realizar un instalador para la versión 4.9.9.1 del Dev C++ que realiza todas las configuraciones necesarias.
Ahora cada ves que queramos realizar un programa con soporte para gráficos solo es necesario seguir los siguientes pasos:
1 - Crear un nuevo proyecto:
2 - Seleccionar la aplicación de consola con gráficos:
3 - Aparecerá la ventana de código, ya se pueden hacer modificaciones y utilizar el modo gráfico:
Ejercicio en el modo gráfico de Dev cpp
Bus en movimiento
En el siguiente ejercicio se puede observar un ejemplo muy sencillo acerca de la utilización del modo gráfico en Dev cpp. El programa consiste únicamente en el movimiento sincronizado de un conjunto de líneas y formas.
#include <winbgim.h> //en este espacio se coloca a la librería destinada para la utilización del modo gráfico
#include <conio.h>
int i,j;
int main()
{
initwindow(880,400); //en está línea se inicia la ventana del modo gráfico
settextstyle(0,0,2);
while(!kbhit()) //este comando sirve para crear un bucle de repetición con lo que se encuentre dentro de sus llaves, hasta presionar un botón
{
for(j=0;j<=70;j++){ //en este 'for' se controla el movimiento del sol en función de la variable 'j'
setcolor(YELLOW); //aquí se coloca el color de la figura
circle(750,40,j);} //en esta línea se gestiona el tipo de forma y sus coordenadas
cleardevice(); //aquí se borra la pantalla cada vez que 'i' aumenta su valor, para darle paso al siguiente valor de 'i'
i++;
if(i>getmaxx()) //en esta línea y la de abajo se controla lo que pasará en caso de que el eje 'x' se llene
i=-250;
{
setcolor(BLUE);
outtextxy(60,60,"Presione cualquier tecla"); //es el texto que saldrá en pantalla
setcolor(BLUE);{
line(i,200,i,300); //se controla el punto de inicio de cada línea
line(i,200,i+250,200);
line(i+250,200,i+250,300);}
{
line(i,300,i+35,300);
line(i+85,300,i+165,300);
line(i+215,300,i+250,300);}
circle(i+60,300,25);
circle(i+190,300,25);
rectangle(i+190,210,i+240,260);
setcolor(WHITE);
arc(i+190,300,0-i,60-i,25);
arc(i+60,300,0-i,60-i,25);
sleep(5);
}
}
getch();
}
Es importante resaltar que los comandos '!kbhit()' y 'getmaxx' son necesarios para el funcionamiento del programa, ya que sin ellos se debería buscar otros equivalentes que creen el movimiento en el gráfico.
Ejercicio sobre herencias.
En este ejercicio, se obtiene acceso a las funciones y atributos de una función padre para ingresar el nombre y la cédula de una persona, además, se agrega una función en la clase hija que determina que las funciones se están inicializando desde un objeto instanciado desde la clase hija.
#include <iostream> //espacio de bibliotecas
#include <conio.h>
#include <string.h>
using namespace std;
class Alguien{ //creación de la clase 'Alguien'
private:
char nom[10];
char edad[10];
public:
void ingresar();
void imprimir();
};
void Alguien::ingresar(){ //función de lectura de los datos
cout<<"Ingrese nombre:";
cin>> nom;
cout<<"Ingrese edad:";
cin>> edad;
}
void Alguien::imprimir(){ //función de impresión de los datos
cout<<"Nombre:" <<nom <<'\n';
cout<<"Cedula:" <<edad <<'\n';
}
class Alguien2: public Alguien{ //establecimiento de la herencia 'Alguien' a 'Alguien2'
public:
public:
void hija(){cout<<"Solo hija";} //función de la clase hija 'Alguien2'
};
int main(){ //inicialización del programa
Alguien2 persona; //instanciación del objeto desde la clase hija
persona.ingresar();
persona.imprimir();
persona.hija();
getch();} //finalización del programa
Ejercicio sobre clases.
En este ejercicio, se imprime la información de un empleado, pero esta no ingresa por el teclado, sino que solamente se declara en 'main', gracias a que la protección de los atributos de la clase utilizada, es pública.
#include <iostream> //espacio de bibliotecas
#include <conio.h>
using namespace std;
class Empleado{ //establecimiento de la clase 'Empleado'
public: //seguridad de los atributos
char nom[20]; //atributos de la clase 'Empleado'
char dep[30];
int edad;
public: //seguridad de los métodos o funciones miembro
void imprimirinfo(); //función miembro de la clase 'Empleado'
};
void Empleado::imprimirinfo(){ //instrucciones de la función
cout<<"Nombre: " <<nom <<'\n';
cout<<"Edad: " <<edad <<'\n';
cout<<"Departamento: " <<dep <<'\n';
}
int main(){ //inicialización del programa
Empleado empleado1; //instanciación del objeto
empleado1.edad=16; //declaración del valor de 'edad'
strcpy(empleado1.dep, "Sistemas Informaticos"); //declaración del valor de 'dep'
strcpy(empleado1.nom, "Joz Pérez"); //declaración del valor de 'nom'
empleado1.imprimirinfo(); //aplicación de la función
getch();} //finalización del programa
Constructores y destructores.
Constructores.
Son funciones miembro especiales que sirven para inicializar un objeto de una determinada clase al mismo tiempo que se declara.
Características:
· Tienen el mismo nombre que la clase a la que pertenecen.
· No tienen tipo de retorno, y por lo tanto no retornan ningún valor.
· No pueden ser heredados.
· Deben ser públicos, no tendría ningún sentido declarar un constructor como privado, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.
Sintaxis.
class <identificador de clase> {
public:
<identificador de clase> (<lista de parámetros>) [: <lista de constructores>] {
<código del constructor>}
... }
Destructores.
Su objetivo es retirar de la memoria al objeto, o sea, el destructor hace todo lo contrario que el constructor.
Características:
· Tienen el mismo nombre que la clase a la que pertenecen, pero tienen el símbolo ˜ delante.
· No tienen tipo de retorno, y por lo tanto no retornan ningún valor.
· No tienen parámetros.
· No pueden ser heredados.
· Deben ser públicos, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.
· No pueden ser sobrecargados, puesto que no tienen valor de retorno ni parámetros, no hay posibilidad de sobrecarga.
Clases y objetos.
Objeto: Está compuesta por atributos, que es el nombre que se le da a las variables que lo componen, y también contiene funciones. Se corresponden con los objetos reales del mundo que nos rodea, o con objetos internos del sistema.
Clase: Es es el sitio en el que se determinan los atributos y las funciones que trabajan en relación a estos, para ser aplicados en un objeto. Sin una clase no se puede tener un objeto, debido a que solo mediante esta, se puede inicializar uno.
Herencia: Las herencias son enlaces entre una clase padre y las hijas, que sirven para poder acceder a las propiedades de la clase padre, y además de eso poder agregar atributos y funciones propios de las clases hijas, y con esto se puede decidir que atributos y funciones utilizar, y cuales no, de las clases padre.
Encapsulamiento: Es el nivel de seguridad que se le otorga a cada parte de una clase, la sección de atributos o funciones miembro. esta puede ser pública (public), privada (private), o protegida (protected), las dos últimas sirven para poder inicializar atributos, únicamente en funciones miembro de la clase. Generalmente solo se le puede dar un nivel de seguridad protegido o privado, las secciones de atributos, debido a que las funciones no podrían ser inicializadas de ninguna manera, de estar privadas o protegidas.
Sobrecarga de operadores: Algunas funciones miembro pueden tener el mismo nombre, pero cumplir diferentes funciones, que se reconocen a través de los parámetros que se determinan dentro de ellas. Si es que las funciones miembro tienen los mismos parámetros declarados se producirá un error.
Cálculo del último dígito de la cédula ecuatoriana.
Como ya se explicó en la entrada anterior, para calcular el último dígito de la cédula ecuatoriana, se necesita de un algoritmo especial, de modo que los datos no se repitan, en función de los nueve primeros dígitos ingresados, se calculará el décimo.
#include <stdio.h> //en este espacio se agregan las bibliotecas
#include <stdio.h>
#include <conio.h>
char ced[10]; //se declara una variable que almacene los 10 dígitos como tipo texto
int cede[10]; //esta variable se utilizará para asignar un valor entero, a los dígitos en texto
int par,impar,suma,im1,im2,im3,im4,im5,c,d,final;
main(){ //se inicia el programa
printf("Ingrese su cedula\n");
scanf("%s", & ced); //se lee la cédula en la variable tipo char
printf("Cedula\n");
for(int i=0;i<10;i++){ //en este 'for', se asigna un valor entero a cada dígito en texto
if(ced[i]==48){
cede[i]=0;}
if(ced[i]==49){
cede[i]=1;}
if(ced[i]==50){
cede[i]=2;}
if(ced[i]==51){
cede[i]=3;}
if(ced[i]==52){
cede[i]=4;}
if(ced[i]==53){
cede[i]=5;}
if(ced[i]==54){
cede[i]=6;}
if(ced[i]==55){
cede[i]=7;}
if(ced[i]==56){
cede[i]=8;}
if(ced[i]==57){
cede[i]=9;}
printf("%d",cede[i]);}
im1=cede[0]*2; //en este espacio, se multiplica los números en posiciones enteras, por 2
im2=cede[2]*2;
im3=cede[4]*2;
im4=cede[6]*2;
im5=cede[8]*2;
if(im1>9){ //en este 'if'', se determina si alguno de los números de resultado en el //proceso anterior, son mayores a nueve, y se resta
im1=im1-9;}
if(im2>9){
im2=im2-9;}
if(im3>9){
im3=im3-9;}
if(im4>9){
im4=im4-9;}
if(im5>9){
im5=im5-9;}
impar=(im1+im2+im3+im4+im5); //aquí se suma el resultado de los impares en el //proceso anterior
par=cede[1]+cede[3]+cede[5]+cede[7]; //aquí se suman las posiciones pares
suma=par+impar;
printf("\n par: %d", par);
printf("\n impar: %d", impar);
printf("\n suma: %d", suma);
c=suma/10; //en estas dos lineas
d=(c*10)+10; //se determina la decena superior
final=d-suma;
if(final>9){ //en este 'if', se determina si el número calculado es mayor a 9, en ese //caso, le corresponderá el valor de 0. luego se imprime
final=final-10;}
else{
final=d-suma;}
printf("\n £ltimo n£mero: %d", final);
if(cede[9]==final){ //en este 'if', se compara el dígito ingresado por el dígito calculado y //se determina si la cédula es verdadera
printf("\n La cedula es verdadera");}
else{
printf("\n La cedula es falsa");}
getch();
} //se finaliza el programa
Cálculo de último dígito de la cédula ecuatoriana.
Para comprobar la autenticidad del número de cédula ecuatoriana, se debe seguir una serie de pasos con el propósito de calcular el dígito final, de manera que nada quede al azar, en el siguiente ejercicio se enseñará como hacerlo.
En este ejercicio, se ingresa el número de cédula en una sola celda, después se separan los dígitos en una celda para cada uno y se empieza a operar con ellos, con el algoritmo prescrito para obtener el número final.
En el algoritmo, se debe separar las posiciones pares de las impares, las posiciones 2, 4, 6 y 8, suman los valores que tienen en ellas, mientras que con las posiciones 1, 3, 5, 7 y 9, de cada uno por separado, se multiplica por 2, los valores correspondientes en estas posiciones y luego, si es que alguno de los valores resultantes es mayor al número 9, éste se resta de dichos valores.
E.g.
Además, en el ejercicio presentado se determinará si la cédula es verdadera o no, en función del último dígito proporcionado, comparado con el último dígito que calcule el programa.
El ejercico para excel se puede descargar del enlace que se deja en la página.
E.g.
Pos.1
|
Pos.2
|
Pos.3
|
Pos.4
|
Pos.5
|
Pos.6
|
Pos.7
|
Pos.8
|
Pos.9
|
Pos.10
|
1
|
7
|
1
|
8
|
7
|
5
|
4
|
3
|
7
|
5
|
Después se suman los valores que resultan de este proceso y a su resultado se lo suma con el resultado de la suma de los números pares. Finalmente, se resta este número por la decena mayor más cercana, por ejemplo, si el número es 24 su decena superior será 30. Sólo en el caso en que el número sea múltiplo de 10, el resultado de la resta será 0, y este será el dígito que corresponda a la posición
10.
E.g.
imp
|
par
|
multi. Imp
|
t. imp
| |||
1
|
1*2=2
|
2
| ||||
7
| ||||||
1
|
1*2=2
|
2
| ||||
8
| ||||||
7
|
7*2=14
|
14-9=5
| ||||
5
| ||||||
4
|
4*2=8
|
8
| ||||
3
| ||||||
7
|
7*2=14
|
14-9=5
|
Suma totales
|
Decena superior
|
Último número
| |
23
|
22
|
23+25=45
|
50
|
50-45=5
| ||
Además, en el ejercicio presentado se determinará si la cédula es verdadera o no, en función del último dígito proporcionado, comparado con el último dígito que calcule el programa.
El ejercico para excel se puede descargar del enlace que se deja en la página.
CORRECCIÓN DE LA PRUEBA
Definir cuál será el resultado de las variables especificadas de acuerdo con lo que se declara.
#include <conio.h>
#include <stdio.h>
typedef struct nodo{
int dia=12;
int mes;
int anio;
}fecha;
main(){
printf("%d", dia);
getch();
}
| |
#include <conio.h>
#include <stdio.h>
struct nodo{
int info=2.
struct nodo * sgt;
};
main(){
printf("%d", info);
getch();
}
| |
#include <conio.h>
#include <stdio.h>
int x;
int y;
main(){
x=3;
y=x;
y=x+3;
printf("y = %d", y);
getch();
}
| |
#include <conio.h>
#include <stdio.h>
int a;
int b;
main(){
b=12;
a=b-2;
b=a+2;
a=a*a;
printf("a = %d",a);
getch();
}
| |
#include <conio.h>
#include <stdio.h>
int x;
int y;
main(){
x=2;
y=x+6;
x=x+1;
y=x-5;
printf("y = %d",y);
getch();
}
| |
#include <conio.h>
#include <stdio.h>
int hola;
int otra;
int nose;
main(){
hola=-7;
no_se=12;
otra=hola+no_se;
no_se=hola+no_se;
hola=no_se+otra;
printf("y = %d",y);
getch();
}
|
#include <conio.h>
#include <stdio.h>
#include <string.h>
struct persona{
char nombre[30];
int edad;
};
main(){
persona per1,per2;
strcpy(per1.nombre,"pedro");
strcpy(per2.nombre,"maria");
per1.edad=23;
per2.edad=17;
printf("nombre:%s \n edad:%d\n",per1.nombre,per1.edad);
printf("nombre:%s \n edad: %d\n",per2.nombre,per2.edad);
getch();
}
|
Complete los siguientes literales con la respuesta correcta, según lo que se indique en los cuadros.
Escriba la sintaxis de la función principal de c++.
|
main(){
//instrucciones
}
|
Escriba los tipo de variables que se utilizan en c.
|
int
float
double
struct
char
|
Escriba una función de tipo int con un argumento res de tipo float.
|
int main(){
float res;
}
|
Realice las sintaxis de una estructura que contenga dos datos enteros.
|
struct datos{
int d1;
int d2;
}dat;
|
Escoja la respuesta correcta.
¿En qué consiste la estructuras de datos o registro?
Ninguna de las anteriores.
¿Qué es un puntero?
Ninguna de las anteriores.
¿Qué es una estructura dinámica?
Son estructuras que cuya dimensión puede crecer o disminuir durante la ejecución del programa.
¿Qué es una lista?
Es una estructura de datos que nos permite agrupar elementos de una manera organizada.
¿Qué es una pila?
Es un tipo de lista en la que sólo se pueden insertar y eliminar nodos en uno de sus extremos.
¿Qué es una cola?
Es una estructura, caracterizada por ser una secuencia de elementos FIFO.
¿Qué un nodo?
Es un puntero que contiene un dato de interés y al menos un puntero para hacer referencia otro nodo.
¿Defina que es una variable?
Todas las anteriores










Comentarios
Publicar un comentario