Buscar en el Blog

Mostrando entradas con la etiqueta c plus plus. Mostrar todas las entradas
Mostrando entradas con la etiqueta c plus plus. Mostrar todas las entradas

domingo, 28 de febrero de 2016

Estructura de Datos y Algoritmos en C ++


Estructura de Datos y Algoritmos en C ++
Data Structure and Algorithms in C++
Second Edition
Michael T. Goodrich
Roberto Tamassia
David Mount

Idioma: Ingles
Páginas: 738

domingo, 14 de febrero de 2016

#include "" vs #include <>



Para #include "nombre de archivo" las búsquedas del preprocesador en el mismo directorio que el archivo que contiene la Directiva. Este método se utiliza normalmente para incluir archivos de cabecera definidos por el programador.

Para #include <fichero> las búsquedas de preprocesador en una forma dependiente de la aplicación, normalmente en los directorios de búsqueda pre-designado por el compilador / IDE. Este método se utiliza normalmente para incluir archivos de cabecera de la biblioteca estándar.

martes, 2 de febrero de 2016

Advanced qt Programing - Creación de un gran software con Qt C ++



Creación de un gran software con Qt C ++

 Autor: Mark Summerfield
Idioma: Ingles
Páginas: 554

martes, 26 de enero de 2016

Pilas C++

Una pila es un tipo especial de lista en la que sólo se pueden insertar y eliminar nodos en uno de los extremos de la lista. Estas operaciones se conocen como "push" y "pop",
Estas características implican un comportamiento de lista LIFO (Last In First Out), el último en entrar es el primero en salir.
 




  Estructura Nodo.


typedef struct _nodo
{
    int valor;
    struct _nodo *siguiente;
}tiponodo;
 
 
la variable valor es la razon de ser de la estructura(nodo). 
Aqui se almacena el valor del nodo.

struct _nodo sirve para almacenar la direccion del siguiente nodo. Al inicio este 
valor el nulo.


typedef tiponodo *pNodo; Nodo para poder crear los nuevos nodos.
typedef tiponodo *cima; Sirve para almacenar el nodo que esta en la cima de todos
los elementos. 

 Funciones

Push(Insertar)
 En las lineas

    pNodo nuevoNodo;//declarando
    /*creando*/
    nuevoNodo=(pNodo)malloc(sizeof(tiponodo ));
 
Se crea un nodo con valores nulos.
 
 

En la linea nuevoNodo->valor=valor;
Aqui recien se esta almacenando un valor a la variable "valor". Ejemplo el numero 10.

En  nuevoNodo->siguiente=*l;

El nuevo nodo apunto a la direccion de memoria del elemento que estaba en la cima. Si es este "nuevo nodo" el primero elemento y como cima al iniciar es nulo, entonces "siguente"  almacenará NULL.


En  *l=nuevoNodo;

Aqui decimos que el nuevo nodo es la nueva cima.  




 void Push(cima *l, int valor)
{
    pNodo nuevoNodo;//declarando
    /*creando*/
    nuevoNodo=(pNodo)malloc(sizeof(tiponodo ));
    nuevoNodo->valor=valor;
    /*Añadimos la cima a la continuacion del nuevo nodo*/
    nuevoNodo->siguiente=*l;
    *l=nuevoNodo;
}






Esto pasa si es el primero elemento. Caso contrario en lugar de apuntar a null, el nuevo elemento y/o la cima  apuntaria al elemento anterior.





Ahora el Pop
Para el eliminar un elemento de la pila, simplemente obtenemos el elemento siguiente de la pila y hacemos q cima apunto a ese siguiente elemento. En cuanto al elemento que estaba en la cima(el elemento a eliminar), simplemente se libera de la memoria.










int Pop(cima *l)
{
    pNodo nodo;//variable auxiliar
    int r;
    nodo=*l;//apuntando el primer elemento de la cima;
    if(!nodo) return 0;
    *l=nodo->siguiente;
    r=nodo->valor;
    free(nodo);//libera la memoria
    return r;
}
 
 

Codigo Completo



#include <iostream>

using namespace std;
typedef struct _nodo
{
    int valor;
    struct _nodo *siguiente;
}tiponodo;
typedef tiponodo *pNodo;
typedef tiponodo *cima;

/*Protipos de funciones con las cimas*/
void Push(cima *l ,int valor);
int Pop(cima *l);
int main()
{

    cima micima=NULL;
    Push(&micima,10);
    Push(&micima,20);
    Push(&micima,30);


 
      cout<<Pop($micima);
      cout<<Pop($micima);
      cout<<Pop($micima); 

    return 0;
}

void Push(cima *l, int valor)
{
    pNodo nuevoNodo;//declarando
    /*creando*/
    nuevoNodo=(pNodo)malloc(sizeof(tiponodo ));
    nuevoNodo->valor=valor;
    /*Añadimos la cima a la continuacion del nuevo nodo*/
    nuevoNodo->siguiente=*l;
    *l=nuevoNodo;
}

int Pop(cima *l)
{
    pNodo nodo;//variable auxiliar
    int r;
    nodo=*l;//apuntando el primer elemento de la cima;
    if(!nodo) return 0;
    *l=nodo->siguiente;
    r=nodo->valor;
    free(nodo);
    return r;


}

viernes, 18 de diciembre de 2015

Desarrollo de un evaluador de expresiones algebraicas




Desarrollo de un evaluador de
expresiones algebraicas.
En C++, C#, Visual Basic .NET, Java, PHP, JavaScript y  Object Pascal
 Rafael Alberto Moreno Parra

Páginas 308 

jueves, 26 de noviembre de 2015

ESTRUCTURA DE DATOS ORIENTADA A OBJETOS Algoritmos con C++


ESTRUCTURA DE DATOS
ORIENTADA A OBJETOS
Algoritmos con C++
Silvia Guardati Buemo
Instituto Tecnológico Autónomo de México
 Páginas 586
 
 

sábado, 20 de junio de 2015

Descomponer un numero en factores primos (C++)




 Descomponer un numero en factores primos (C++)
#include <iostream>
using namespace std;
int main()
{
    int n1,n2;
    cout << "Ingrese un numero: ";
    cin >> n1  ;
    for(int i=2;i<=n1;i++)
    {
        n2=n1%i;
        if(n2==0)
        {
          cout<<"numero ->"<<n1<<endl;
          cout<<"Multiplo->"<<i<<endl;
          n1=n1/i;
        }
    }
    return 0;
}


sábado, 25 de abril de 2015

C++/OOP UN ENFOQUE PRÁCTICO



RICARDO DEVIS BOTELLA
Paginas 297


Es costumbre que las primeras líneas de un texto procuren, de alguna manera, al lector una suerte de explicación del talante y ánimo del autor al escribir la obra que tiene ante sí. Bien: he aquí un enésimo libro sobre C++ y -¿cómo no?- sobre Programación Orientada a Objetos. De acuerdo, pensará el lector, pero ¿por qué éste y no otro?; o mejor, ¿qué tiene de especial el presente texto? Y la respuesta es... ¡una intención eminentemente didáctica! Lo que se pretende es introducir al lector en los esquemas básicos de la programación orientada-a-objetos -que en adelante llamaremos OOP a través del uso de un lenguaje de amplia aceptación industrial, cual es C++. La aproximación será, sobre todo, práctica: procuraré no perderme en la maraña de siglas y conceptos que pueblan esta metodología y que frecuentemente desaniman al principiante, de forma que, tras el inevitable discurso teórico, siempre se buscará la aplicación concreta de lo expuesto mediante código en C++. Se trata, pues, de una introducción al lenguaje
C++, pero, atención, utilizando de forma inseparable las técnicas y conceptos de OOP. El texto también quiere ser, por fin, ameno y, en lo posible, divertido: la tradición norteamericana de obras en las que el rigor no está reñido con un cierto humor, en ocasiones salvaje, será aquí observada con cierta complacencia. El tono será, pues, desenfadado pero exacto: a veces elemental, a veces no tanto.

martes, 3 de marzo de 2015

Qt C++ Capturar la tecla presionada - Keypress

Agregamos la siguiente linea en el archivo de cabecera para reimplementar la funcion eventFilter.

//Filtrar los eventos
bool eventFilter(QObject *obj, QEvent *event);

en el archivo cpp implementamos la funcion.

bool MainWindow::eventFilter(QObject *obj, QEvent *event)
{
     //Si el evento es del Tipo Keypress
    if (event->type() == QEvent::KeyPress) {
    //Hacemos un Cast
    QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
    qDebug("Tecla Presionada %d", keyEvent->key());
    return true;
    } else {
    // 
    return QObject::eventFilter(obj, event);
    }
}
Ademas incluir en el archivo cpp los siguientes archivos.



#include <QKeyEvent>
#include <QDebug>


 
 
 
Ahora vamos instalar el eventFilter, es decir, en que objecto queremos hacer 
el filtro  de eventos. Para eso colocamos la siguiente linea de codigo en el
constructor de la clase.
 
 ui->lineEdit->installEventFilter(this);
 
 
 
 
Entonces el archivo quedaria asi.
 

#include "mainwindow.h"
#include "ui_mainwindow.h"

#include <QDebug>
#include <QKeyEvent>
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{


    ui->setupUi(this);
   


 ui->lineEdit->installEventFilter(this);
}


MainWindow::~MainWindow()
{
    delete ui;
}




bool MainWindow::eventFilter(QObject *obj, QEvent *event)
{
    if (event->type() == QEvent::KeyPress) {
    //and here put your own logic!!
    QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
    qDebug("Ate key press %d", keyEvent->key());
    return true;
    } else {
    // standard event processing
    return QObject::eventFilter(obj, event);
    }
}

Al Ejecutar y digitar en la aplicacion en la ventana Output debe salir un resultado 
similar al de la siguiente imagen.




Nota: EL Debug sirve para mostrar los resultados en la consola de Qt Creator

lunes, 17 de febrero de 2014

Como programar en C/C++ H. M. Deitel


Como programar en C/C++ H. M. Deitel


Programacion C++ - Relaci on de Ejercicios y Soluciones II




Tema 1: Almacenamiento en Memoria Secundaria. Ficheros 2
Tema 2: Tipos Abstractos de Datos 15
Tema 2.1: Programacion Modular . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Tema 2.2: Tipos Abstractos de Datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Tema 2.3: Tipos Abstractos de Datos Gen ericos . . . . . . . . . . . . . . . . . . . . . . . . 49
Tema 3: Gesti on de Memoria Din amica 74
Tema 3.1: Listas Enlazadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Tema 3.2: Abstracci on en la Gesti on de Memoria Din amica . . . . . . . . . . . . . . . . . 93
Tema 3.3: Genericidad en la Gesti on de Memoria Din amica . . . . . . . . . . . . . . . . . 136
Tema 4: Colecciones 147
Pr acticas de Laboratorio 162
Pr actica 1: Almacenamiento Persistente de Datos . . . . . . . . . . . . . . . . . . . . . . . 162
Pr actica 2: Tipos Abstractos de Datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Pr actica 3: Tipos Abstractos de Datos Gen ericos . . . . . . . . . . . . . . . . . . . . . . . 181
Pr actica 4: Gesti on de Memoria Din amica . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Pr actica 5: Abstracci on en la Gesti on de Memoria Din amica . . . . . . . . . . . . . . . . . 200
Pr actica 6: Biblioteca Est andar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Problemas de Examen 214
Examen 1: Gesti on de Agencia de Viajes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Examen 2: Juego de Ajedrez . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Examen 3: Gesti on de Hotel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231





Escribir un programa con la opci on de encriptar y de desencriptar un chero de texto, dependiendo de la
extensi on del chero de entrada. La encriptaci on (codi caci on) consiste en que dado un chero de texto
de entrada (extensi on txt) genere otro chero de salida encriptado (extensi on cod). Esta codi caci on
consiste reemplazar cada letra por la tercera siguiente de forma circular (ej. a!d, b!e, , w!z, x!a,
y!b, z!c). La opci on de desencriptado consiste en leer un chero codi cado (extensi on cod) y recuperar
la informaci on original en un chero de texto (extensi on txt).


Soluci on
#include <iostream>
#include <fstream>
using namespace std;
const unsigned DESPL = 3;
enum Operacion {
CIFRAR, DESCIFRAR, ERROR
};
// cifrado rotacional (DESPL) de letra
char cifrar(char c)
{
if (c >= 'a' && c <= 'z') {
c = char(c + DESPL);
if (c > 'z') {
c = char('a' + c - 'z' - 1);
}
} else if (c >= 'A' && c <= 'Z') {
c = char(c + DESPL);
if (c > 'Z') {
c = char('A' + c - 'Z' - 1);
}
}
return c;
}
// descifrado rotacional (DESPL) de letra
char descifrar(char c)
{
if (c >= 'a' && c <= 'z') {
c = char(c - DESPL);
if (c < 'a') {
c = char('z' + c - 'a' + 1);
}
} else if (c >= 'A' && c <= 'Z') {
c = char(c - DESPL);
if (c < 'A') {
c = char('Z' + c - 'A' + 1);
}
}
return c;
}
// transforma una letra segun el codigo de operacion
char transformar(char c, Operacion op)
{
char res;
if (op == CIFRAR) {

res = cifrar(c);
} else {
res = descifrar(c);
}
return res;
}
// trasnforma el fichero de entrada y lo escribe en el fichero de salida
void transformar_fichero(const string& entrada, const string& salida,
Operacion op, bool& ok)
{
ifstream f_ent;
f_ent.open(entrada.c_str());
if (f_ent.fail()) {
ok = false;
} else {
ofstream f_sal;
f_sal.open(salida.c_str());
if (f_sal.fail()) {
ok = false;
} else {
char ch;
f_ent.get(ch);
while (! f_ent.fail() && ! f_sal.fail()) {
f_sal.put(transformar(ch, op));
f_ent.get(ch);
}
ok = (f_ent.eof() && ! f_sal.fail());
f_sal.close();
}
f_ent.close();
}
}
// busca un caracter e una cadena
unsigned buscar(const string& nombre, char c)
{
unsigned i = 0;
while ((i < nombre.size())&&(c != nombre[i])) {
++i;
}
return i;
}
// devuelve la extension del nombre de fichero
string extension(const string& nombre)
{
string res = "";
unsigned i = buscar(nombre, '.');
if (i < nombre.size()) {
res = nombre.substr(i+1, nombre.size()-(i+1));
}
return res;
}
// calcula la operacion a realizar a partir de las extensiones de los
// ficheros de entrada y salida
Operacion codigo_op(const string& entrada, const string& salida)
{
Operacion res;
if ((extension(entrada)=="txt")&&(extension(salida)=="cod")) {
res = CIFRAR;
} else if ((extension(entrada)=="cod")&&(extension(salida)=="txt")) {
res = DESCIFRAR;
} else {
res = ERROR;
}
return res;
}
int main()
{
bool ok;
cout << "Introduzca el nombre del fichero de entrada: ";

string nombre_ent;
cin >> nombre_ent;
cout << "Introduzca el nombre del fichero de salida: ";
string nombre_sal;
cin >> nombre_sal;
Operacion op = codigo_op(nombre_ent, nombre_sal);
if (op != ERROR) {
transformar_fichero(nombre_ent, nombre_sal, op, ok);
if (ok) {
cout << "Procesamiento correcto" << endl;
} else {
cout << "Error al procesar el fichero" << endl;
}
} else {
cout << "Error: extensiones erroneas" << endl;
}
}





sábado, 15 de febrero de 2014

Practicas de Programacion: Ejercicios Desarrollados C++



UNIVERSIDAD DE M ALAGA
Dpto. Lenguajes y CC. Computaci on
E.T.S.I. Telecomunicaci on



Conceptos B asicos de Programaci on
1. El siguiente programa escrito en C++ calcula la cantidad bruta y neta a pagar por un trabajo realizado
en funci on de las horas y d as trabajados. Contiene errores, encu entrelos y corr jalos.

# include < iostream >
using namespace std ;
const tasa : 25.0;
const PRECIO_HORA = 60.0;
int main ()
{
double horas ,dias ,total , neto ;
cout << " Introduzca las horas trabajadas : ";
cin << horas ;
cout << " Introduzca los dias trabajados : ";
cin >> dias ;
horas * dias * PRECIO_HORA = total ;
neto = total - TASA ;
cout >> "El valor total a pagar es: " >> total >> endl ;
cout << "El valor neto a pagar es: " << NETO << endl ;
}


# include < iostream >
using namespace std ;
//􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀
const double TASA = 25.0;
const double PRECIO_HORA = 60.0;
//􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀􀀀
int main ()
{
double horas , dias , total , neto ;
cout << " Introduzca las horas trabajadas : ";
cin >> horas ;
cout << " Introduzca los dias trabajados : ";
cin >> dias ;
total = horas * dias * PRECIO_HORA ;
neto = total - TASA ;
cout << "El valor total a pagar es: " << total << endl ;
cout << "El valor neto a pagar es: " << neto << endl ;
}



Google+ Seguidores