martes, 10 de noviembre de 2015

Programación grafica en DEV-C++

La librería winbgim.h a sido creada originalmente por Konstantin Knizhnik's winbgi shareware  y posteriormente modificada por Mark Richardson  y Michael Main, esta librería 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.2 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 una aplicación de consola con gráficos
Y listo!

A continuación algunos ejemplos
Para iniciar el modo gráfico se usa la función void initwindow (int width, int height);

Ejemplo:
 initwindow(400,300); // Abre una ventana gráfica de 400x300 color rgb
Para cerrar el modo gráfico se usa la función  closegraph();
 4.9.9.2
Aqui en esta pagina te indica todo , hasta como instalar y como hacer las graficas en c 
http://www.monografias.com/trabajos94/graficas-funciones-dev-cpp/graficas-funciones-dev-cpp.shtml

Ejemplo

#include <winbgim.h>
 int main()
{
 initwindow(400,300);         // Abre una ventana gráfica de  400x300 pixeles
moveto(0,0);                         // Pone el cursor en 0,0
lineto(50,50);                        // Dibuja una línea desde 0,0 hasta 50,50
while(!kbhit());                    // Espera a que el usuario presione una tecla
closegraph();                       // Cierra la ventana gráfica
return 0;

EXPLICACION:
Este programa presenta o demuestra el moviemiento de un auto y con los postes en movimiento
#include <winbgim.h>

void waitForLeftMouseClick();

int main()
{
    initwindow(1500,1000); //open a 400x300 graphics window
    
    // delete these lines and replace them with your own code:
    settextstyle(0,0,2);
    for(int i=1;i<=1000;i=i+10){
            setcolor(YELLOW);
    rectangle(20+i,500,200+i,400);
    rectangle(5+i,600,300+i,500);
    circle(60+i,650,50);
    circle(250+i,650,50);
    setcolor(BLUE);
    rectangle(400-i,400,375-i,50);
    rectangle(600-i,400,575-i,50);
    rectangle(800-i,400,775-i,50);
    rectangle(1000-i,400,975-i,50);
    rectangle(1200-i,400,1175-i,50);
    rectangle(460-i,100,300-i,75);
    rectangle(460-i,200,300-i,175);
    rectangle(700-i,100,500-i,75);
    rectangle(700-i,200,500-i,175);
    rectangle(900-i,100,775-i,75);
    rectangle(900-i,200,775-i,175);
    rectangle(1100-i,100,975-i,75);
  
    sleep(50);
    
    setcolor(BLACK);
    rectangle(20+i,500,200+i,400);
    rectangle(5+i,600,300+i,500);
    circle(60+i,650,50);
    circle(250+i,650,50);
    rectangle(400-i,400,375-i,50);
    rectangle(600-i,400,575-i,50);
    rectangle(800-i,400,775-i,50);
    rectangle(1000-i,400,975-i,50);
    rectangle(1200-i,400,1175-i,50);
    rectangle(460-i,100,300-i,75);
    rectangle(460-i,200,300-i,175);
    rectangle(700-i,100,500-i,75);
    rectangle(700-i,200,500-i,175);
    rectangle(900-i,100,775-i,75);
    rectangle(900-i,200,775-i,175);
    rectangle(1100-i,100,975-i,75);
}
    
                
    // while(!kbhit());     // wait for user to press a key
    waitForLeftMouseClick(); // use one or the other of these--not both


    closegraph();        //close graphics window
return 0;
}

void waitForLeftMouseClick()
{
    clearmouseclick(WM_LBUTTONDOWN);
    const int DELAY = 50; // Milliseconds of delay between checks
    int x, y;
    while (!ismouseclick(WM_LBUTTONDOWN))
        delay(DELAY);
    getmouseclick(WM_LBUTTONDOWN, x, y);

}

VIDEO DE REFERENCIA DEL TEMA:https://www.youtube.com/watch?v=sfU_SQanYVI

lunes, 19 de octubre de 2015

UNIDAD EDUCATIVA FISCOMISIONAL"DON BOSCO"

NOMBRE: BRYAN NARVAEZ Y JOAN RODRIGUEZ 

CURSO:2DO INF 

TEMA : CORRECCION DEL EXAMEN

1) Determina el valor que obtendra la variable
int A;
A=5;
A=A+7;
A=A-10;
          A=A^2:
          =4 
int A;
int B;
A=1;
B=2;
A=A+B;
=3

int X;
int y;
x=3;
y=x
y=x+3
error

int A;
int B;
B=12;
A=B+1;
A=B-7;
A=A*A;
=25

int x;
int y;
X=2;
Y=X+6;
X=X+1;
Y=X-5;
=-2

int hola;
int NO_SE :
int OTRA;
HOLA =2;
NO_SE=12;
OTRA=HOLA+NO_SE;
NO_SE=HOLA+NO_SE:
HOLA=NO_SE+OTRA;
=28

int A;
int B;
A=0;
B=5;
B=a+B;
B=A;
=error

int A;
int B;
int C;
A=1;
B=A-1;
B=C-B;
= basura


2.-Definir cuál sería la salida en pantalla del siguiente código de C++ si la cadena ingresada es (1, 2, 3, 4, 5, 6, 7, 8, 9, 0). 
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
char ced[9];
char  *ptrced;

main(){

printf(“Ingrese su num de ced\n”);
gets(ced);
printf(“%d\n”,ced);
for(int i=0;i<10;i++){
     ptrced=&ced[i];
     //printf(“\n%p\n”,&ptrced);
    printf(“%d\n”,*ptrced);
}
getch();
}


 https://drive.google.com/file/d/0BzI-qCgczca3eXpLQWZIWXlvY1E/view?usp=sharing



3.-Encierre la letra de la respuesta correcta a la pregunta
¿Qué es matriz?
a)       Es una zona de almacenamiento de memoria contiguo
b)      Es un tipo de dato que asigna valor de memoria de un solo tipo char
c)       Es una estructura dinámica
d)      Ninguna de las anteriores

¿Qué es un puntero?
a)       Es una matriz que hace referencia a una región de memoria
b)       Es un valor entero que da referencia a una región de memoria
c)        Ninguna de las anteriores
d)       Es una variable independiente de memoria que sirve para apuntar a un puntero

¿Qué es una estructura dinámica?
a)       Son estructuras que cuya dimensión puede crecer o disminuir durante la creación del programa
b)       Son estructuras que cuya dimensión puede crecer o disminuir durante el diseño del programa
c)        Son estructuras que cuya dimensión puede crecer o disminuir durante la ejecución del programa
d)      Ninguna de las anteriores

¿Qué es una lista?
a)       Es un puntero de datos que nos permite agrupar elementos de una manera organizada
b)      Es un dominio de datos que nos permite agrupar elementos de una manera organizada
c)       Es una estructura de datos que nos permite agrupar elementos de una manera organizada
d)      Ninguna de las anteriores

¿Qué es pila?
a)       Es un tipo de lista en la que solo se puede insertar y eliminar nodos en uno de sus extremos
b)       Es un tipo de puntero en la que solo se puede insertar y eliminar nodos en uno de sus extremos
c)       Es un tipo de dato int que solo se puede insertar y eliminar nodos en uno de sus extremos de las lista
d)      Ninguna de las anteriores



miércoles, 7 de octubre de 2015

PROGRAMA PUNTEROS
EXPLICACIÓN:
Este programa nos pide que ingresemos la edad el nombre y el genero y nuestros datos personales es lo que nos va a imprimir en pantalla pero con el codigo del 0123456789ABCDEF

#include <conio.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int edad;
char genero;
int *ptredad;
char *ptrgenero;
char nom;
char *ptrnom;
main()
{
int *ptredad=&edad;
char *ptrnom=&nom;
char *ptrgenero=&genero;

printf("Ingrese el nombre\n");
scanf("%s",&nom);
printf("Ingrese la edad\n");
scanf("%i",&edad);
printf("Ingrese el genero\n");
scanf("%s",&genero);
printf("\n");
printf("%s       %p\n",ptrnom,ptrnom);
printf("%i       %p\n",ptredad,ptredad);
printf("%s       %p\n",ptrgenero,ptrgenero);
getch();
}
MATRICES Y VECTORES
EXPLICACION
Este es un programa de punteros con vectores ya que el problema o el programa nos pide que utilizamos matrices ya que necesitamos encontrar valores numericos .
#include <conio.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
char ingreso[20][9];
int i;
int j;
int num;
char *ptringreso[20][9];
main()
{
num=1;
for(i=0;i<10;i++)
{
 for(j=0;i<10;i++)
{
printf("Ingrese el valor %i\n",num);
scanf("%s",&ingreso[i][j]);
ptringreso[i][j]=&ingreso[i][j];
num++;
}
}


num=1;

for(i=0;i<10;i++)
{
printf("%i  %s\n",num,*ptringreso[i]);
num++;
}

getch();
}
Con esta referencia de este vídeo puedes aprender a como aplicar las matrices en los punteros es una manera mas facil de aprender y hacer los ejercicios con guia
LINK DEL VIDEO : https://www.youtube.com/watch?v=cgw3rT9z_vc

martes, 29 de septiembre de 2015

TEORIA DE PUNTEROS
OBJETIVO: Aprender y Entender la teoría de punteros en c , ya que es un tema muy importante en la programación , que debemos dominarlo , para poder resolver problemas sobre este tema , es importante y la vez entretenido , este tema es muy extenso y existen varias formas de aprender y de resolver
TEORIA DE PUNTEROS
CONCEPTO: Un puntero o apuntador es una variable que contiene una dirección de memoria. En esa posición de memoria se encuentra almacenada una variable de un tipo determinado (entera, real o carácter). Su tamaño es de 4 bytes.
Se dice que la primera variable (el puntero) apunta a la segunda.
Un puntero también puede apuntar a otro puntero, es decir, almacenar la dirección de memoria de otro puntero.
DECLARACIÓN:
Para que un puntero pueda apuntar a una variable debe ser declarado de la siguiente manera:
tipo*identificador
donde tipo es el tipo de variable a la que apunta (si es variable entera, int; si es real, float o double; y si es un carácter, char), * indica que es un puntero, e identificador es el nombre del puntero.
Los punteros sólo pueden apuntar a variables del mismo tipo que ellos.
(A partir de ahora llamaremos p, q... a identificadores de punteros en general, que deberemos inicializar para poder usarlos).
Si queremos que un puntero q apunte a otro p se declara así:
tipo* *q

OPERADORES:
Los operadores que se usan con los punteros son &, *, y el operador asignación =.

-En C, al contrario que en otros lenguajes de programación, se puede obtener directamente la dirección de memoria de cualquier variable sobre la que opera el puntero. Esto es posible hacerlo con el operador referencia & de la siguiente forma:
p=&x
donde x es la variable a la que apunta el puntero.

-Para acceder a la variable a la que apunta el puntero se utiliza el operador desreferencia * de esta forma:
x=*p 
donde x es la variable que obtiene un nuevo valor (el valor de la variable a la que apunta el puntero).
Si un puntero q apunta a otro p, se utiliza dos veces el operador *.
ARITMÉTICA DE PUNTEROS:
-Suma/resta de punteros:
Sólo puede hacerse suma y resta de un puntero con un entero. Esta operación avanza o retrasa el puntero tantas veces como indica el entero con el que se opera. Se procede así:
p=p+n 
donde n es un entero. (Por ejemplo, si n=1, el puntero p avanza 4 bytes).

-Comparación de punteros:
Se pueden comparar punteros, es decir, comparar las relativas posiciones de memoria:
Si tenemos que p>q, significa que p apunta a una dirección de memoria mayor que q.
Si tenemos que p<q, significa que p apunta a una dirección de memoria menor que q.

ERRORES COMUNES CON PUNTEROS:
-Asignar punteros de distinto tipo (un float con un char, un int con un double...).
Por ejemplo:
int a=1 ;
int *p ;
double b=2.0 ;
double *q ;
p=&a ;
q=&x ;
q=p; ERROR 

-Usar punteros no inicializados.
Por ejemplo:
char *p;
*p='a';
(FALTARÍA PONER: char c;
p=&c; )

-Asignar valores al puntero en vez de a la variable:
Por ejemplo:
int x;
int *p;
p=&x;
p=7; MAL (DEBERÍA SER *p=7)

-Hacer asignaciones a la dirección de memoria NULL (dirección de memoria cero).
Por ejemplo:
int *p=NULL;
*p=6; // ERROR (NO SE PUEDE ASIGNAR NADA A LA DIRECCIÓN DE MEMORIA NULL)
RELACIÓN ENTRE PUNTEROS Y VECTORES:
Un vector es un conjunto de variables del mismo tipo que se referencian con un mismo nombre y con un índice.
En C, los punteros y los vectores están fuertemente relacionados, hasta el punto de que el nombre de un vector es un puntero al primer elemento del vector. Para ir avanzando sobre el vector, cuyos elementos están situados en memoria consecutivamente, basta ir moviendo el puntero con simples incrementos sobre el vector. Así pues, siendo v el nombre de un vector en general, tenemos que:
v[i] es equivalente a *(v+i) 
(Ej: v[4]=v[3]+7 es equivalente a *(v+4)=*(v+3)+7)
&v[i] es equivalente a (v+i) 
(Ej: &v[2] es equivalente a (v+2))
Por tanto, todas las operaciones que utilizan vectores e índices pueden realizarse mediante punteros.
Sin embargo, hay que tener cuidado a la hora de no rebasar los límites del trozo de memoria donde se almacena el vector.

RELACIÓN ENTRE PUNTEROS Y MATRICES:
Una matriz es un conjunto de variables del mismo tipo que se referencian con un mismo nombre y con dos índices.
Al igual que con vectores, en C, al declarar una matriz, se crea un puntero con el mismo nombre que la matriz. También se puede avanzar en la matriz y realizar operaciones de idéntica forma que con los vectores.
Siendo m una matriz en general, m[DIM1][DIM2], tenemos que:
m[i] es equivalente a &m[i][0] 
(Ej: m[7]=&m[7][0])
m[i][j] es equivalente a *(m[i]+j) y es equivalente a *(m[0]+i*DIM2+j)
(Ej: m[2][3]=20 es equivalente a *(m[2]+3) y es equivalente a *(m[0]+2*DIM2+3)
(m+i) es equivalente a &m[i]
(Ej: (m+4) es equivalente a &m[4])
m[i][j] es equivalente a *(*m+i*DIM2+j) 
(Ej: m[5][6] es equivalente a *(*m+5*DIM2+6))
EJEMPLOS DE COLA Y PILA
Ejemplo: Pila basada en un arreglo estático
#include <iostream>
using namespace std;
 
#define STACK_SIZE 256 /* capacidad máxima */
typedef char arreglo[STACK_SIZE];
 
class Stack {
  
 int sp; /* puntero de lectura/escritura */
 int items; /* número de elementos en lista */
 int itemsize; /* tamaño del elemento */
 arreglo pila;  /* el arreglo */
  
 public:
  // constructor
  Stack() {
   sp = STACK_SIZE-1;
   items = 0;
   itemsize = 1;
   }
  
  // destructor
  ~Stack() {};
  
 /* regresa el número de elementos en lista */
 int size() { return items; }
  
 /* regresa 1 si no hay elementos en la lista, o sea, si la lista está vacia */
 int empty() { return items == 0; }
  
 /* insertar elemento a la lista */
 int put(char d)
 {
  if ( sp >= 0) {
   pila[sp] = d;
   sp --;
   items ++;
  }
  return d;
 }
  
 /* retirar elemento de la lista */
 int get()
 {
  if ( ! empty() ) {
   sp ++;
   items --;
  }
  return pila[sp];
 }
  
}; // fin de clase Stack
 
 
// probando la pila. 
// Nota: obseve cómo los elementos se ingresan en orden desde la A hasta la Z,
// y como los mismos se recuperán en orden inverso.
int main()
{
    int d;
    Stack s;  // s es un objeto (instancia) de la clase Stack
 
    // llenando la pila
    for (d='A'; d<='Z'; d++) s.put(d);
 
    cout << "Items =" << s.size() << endl;
 
    // vaciando la pila
    while ( s.size() ) cout << (char)s.get() << " ";
 
    cout << "\nPara terminar oprima <Enter>...";
    cin.get();
    return 0;
}
}
Ejemplo: Pila basada en un arreglo dinámico
/*---------------------------------------------------------------+
+ ejemplo de una pila ( STACK ) enlazada dinámicamente +
+ +
+ Autor: Oscar E. Palacios +
+ email: oscarpalacios1@yahoo.com.mx +
+ +
+ Manifiesto: +
+ Este programa puede distribuirse, copiarse y modificarse de +
+ forma libre. +
+---------------------------------------------------------------*/
#include <iostream>
//#include <conio.h>

using namespace std;

/* tipo de dato que contendrá la lista */
typedef char DATA_TYPE;

// declaraci¢n de estructura nodo
struct nodo {
 DATA_TYPE data;
 nodo *next;
};

class StackDin {

    // atributos
    int ITEMS;    /* número de elementos en la lista */
    int ITEMSIZE; /* tamaño de cada elemento */
    nodo *SP;     /* puntero de lectura/escritura */

public:
    // constructor
    StackDin() : SP(NULL), ITEMS(0), ITEMSIZE(sizeof(DATA_TYPE)) {}

    // destructor
    ~StackDin() {}

    /* agregar componente a la lista */
    DATA_TYPE put(DATA_TYPE valor)
    {
 nodo *temp;

 temp = new nodo;
 if (temp == NULL) return -1;

 temp->data = valor;
 temp->next = SP;
 SP = temp;
 ITEMS ++;
 return valor;
    }

    int empty() { return ITEMS == 0; }


    /* retirar elemento de la lista */
    DATA_TYPE get()
    {
 nodo *temp;
 DATA_TYPE d;

 if ( empty() ) return -1;

 d = SP->data;
 temp = SP->next;
 if (SP) delete SP;
 SP = temp;
 ITEMS --;
 return d;
    }

}; // fin de la clase StackDin


/* punto de prueba para la clase StackDin */
int main()
{
    //clrscr();

    StackDin s;
    DATA_TYPE d;

    for (d='A'; d<='Z'; d++) s.put(d);

    while ( ! s.empty() )
 cout << (DATA_TYPE)s.get() << " ";

    cout << "\nPara terminar presione <Enter>...";
    cin.get();
    return 0;
}COLA
cola
  |
+---+---+---+---+---+
|   |   |   |   |   |    al principio
+---+---+---+---+---+
  |
  cabeza
      cola
      |
+---+---+---+---+---+    put('A');
| A |   |   |   |   |    después de haber agregado el primer elemento
+---+---+---+---+---+
  |
  cabeza
...
                  cola
                  |
+---+---+---+---+---+
| A | B | C | D |   |    después de haber agregado cuatro elementos
+---+---+---+---+---+
  |
  cabeza
Vaciando la cola.
  cabeza
  |
+---+---+---+---+---+
| A | B | C | D |   |    antes de haber retirado elementos
+---+---+---+---+---+
      cabeza
      |
+---+---+---+---+---+    get();
| A | B | C | D |   |    después de haber retirado un elemento
+---+---+---+---+---+
...
                  cabeza
                  |
+---+---+---+---+---+    al final
| A | B | C | D |   |    después de haber retirado todos los elementos
+---+---+---+---+---+
                  |
                  cola






CONCLUSION:

Este tema de punteros me pude dar cuenta que es muy útil e importante para aprender a programar muy fácilmente, debemos saber como resolver ya que este tema es muy complejo , y un poco difícil de entender , si fallas una linesa programación no te puede salir

BIBLIOGRAFÍA: