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.
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();
}

Determinar el resultado del programa que se presenta a continuación:
#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