| |
 Mostrar Temas
|
|
Páginas: 1 [2] 3
|
|
11
|
Programación / Programación C/C++ / clase FECHA con modificaciones
|
en: 4 Abril 2012, 23:12 pm
|
Hola, esta clase fecha es de un curso que había hecho en mi facultad. La clase no fue escrita por mi, yo sólo agregué las funciones a lo último. Pero me doy cuenta de la utilidad que puede tener para gente iniciada que tiene esta clase de problemas que sus profesores le piden ejercicios con fechas. Les puede servir.
//
//Puede utilizarse para fechas desde el 01/01/1900
class Fecha
{
private:
int dia;
int mes;
int año;
// bool esbisiesto(int);
void NumeroSerieaFecha(int);
public:
bool esbisiesto(int);
Fecha(int d=0,int m=0,int a=0);
int getDia(){return dia;}
int getMes(){return mes;}
int getAnio(){return año;}
void setDia(int d){dia=d;}
void setMes(int m){mes=m;};
void setAnio(int a){año=a;}
void MostrarFecha();
void MostrarFechaTexto();
int NumeroSerie();
bool operator >(Fecha &);
bool operator ==(Fecha &);
Fecha operator+(int);
int operator -(Fecha &);
void operator +=(int);
int operator==(char *);
friend istream & operator>>(istream &, Fecha &);
friend ostream & operator<<(ostream &, Fecha &);
int cantDiasMes();
int cantDiasHabilesMes();
int cantAniosHastaHoy();
bool EsSuperiorAFechaActual(Fecha fx);
int FechaEntreDosFechas(Fecha inicio_de_promocion, Fecha fin_de_promocion, Fecha fecha_de_compra );
unsigned int CalcularEdad(Fecha birthdate);
};
Fecha::Fecha(int d,int m,int a)
{//El constructor asigna los valores recibidos, si le son pasados como parámetros
if(d!=0)
{
dia=d;mes=m;año=a;//¿Qué modificación habría que hacerle al constructor para
} // garantizar que no se asignen valores absurdos? Ej.:65/65/-12
else //si no recibe valores asigna por defecto la fecha actual
{
time_t tiempo;
struct tm *tmPtr;
tiempo = time(NULL);
tmPtr = localtime(&tiempo);
año=tmPtr->tm_year+1900;
mes=tmPtr->tm_mon+1;
dia=tmPtr->tm_mday;
}
}
//Devuelve true si el año recibido es bisiesto.
bool Fecha::esbisiesto(int a)
{
bool bisiesto=false;
if(a%4==0)
bisiesto=true;
if((a%100==0) && (a%400!=0))
bisiesto=false;
return bisiesto;
}
//Muestra la fecha en formato número. Ej.: 15/10/2008
void Fecha::MostrarFecha()
{
cout<<dia<<"/"<<mes<<"/"<<año<<endl;
}//¿Qué modificación habría que hacer para que siempre muestre DD/MM/AAAA?
//Devuelve 1 si la fecha coincide con una cadena que representa un día de la semana
int Fecha::operator==(char *diaSemana)
{
int cantdias=NumeroSerie()-1;//cantidad de días transcurridos desde 01/01/1900
//El 01/01/1900 fue Lunes
int numerodia=cantdias%7;
char mdia[7][10];
strcpy(mdia[0],"Lunes");
strcpy(mdia[1],"Martes");
strcpy(mdia[2],"Miercoles");
strcpy(mdia[3],"Jueves");
strcpy(mdia[4],"Viernes");
strcpy(mdia[5],"Sábado");
strcpy(mdia[6],"Domingo");
if(strcmp(mdia[numerodia],diaSemana)==0)
return 1;
return 0;
}
//Muestra la fecha indicando en texto el día y el mes.Ej.: Lunes 1 de enero de 1900
void Fecha::MostrarFechaTexto()
{
char mmes[12][11];
strcpy(mmes[0],"Enero");
strcpy(mmes[1],"Febrero");
strcpy(mmes[2],"Marzo");
strcpy(mmes[3],"Abril");
strcpy(mmes[4],"Mayo");
strcpy(mmes[5],"Junio");
strcpy(mmes[6],"Julio");
strcpy(mmes[7],"Agosto");
strcpy(mmes[8],"Septiembre");
strcpy(mmes[9],"OCtubre");
strcpy(mmes[10],"Noviembre");
strcpy(mmes[11],"Diciembre");
int cantdias=NumeroSerie()-1;//cantidad de días transcurridos desde 01/01/1900
//El 01/01/1900 fue Lunes
int numerodia=cantdias%7;
char mdia[7][10];
strcpy(mdia[0],"Lunes");
strcpy(mdia[1],"Martes");
strcpy(mdia[2],"Miercoles");
strcpy(mdia[3],"Jueves");
strcpy(mdia[4],"Viernes");
strcpy(mdia[5],"Sábado");
strcpy(mdia[6],"Domingo");
cout<<endl<<mdia[numerodia]<<" "<<dia<<" de "<<mmes[mes-1]<<" de "<<año<<endl;
}
//Devuelve la cantidad de días transcurridos desde el 01/01/1900
int Fecha::NumeroSerie()
{
int cont=0,i;
for(i=1900;i<año;i++) if(esbisiesto(i)) cont++;
int vmes[]={31,28,31,30,31,30,31,31,30,31,30,31},suma=0;
if(esbisiesto(año)) vmes[1]=29;
for(i=0;i<mes-1;i++) suma+=vmes[i];
int cantdias=(año-1900)*365+cont+suma+dia;
return cantdias;
}
//Sobrecargas
bool Fecha::operator>(Fecha &obj)
{
if(NumeroSerie()>obj.NumeroSerie())
return true;
return false;
}
bool Fecha::operator==(Fecha &obj)
{
if(NumeroSerie()==obj.NumeroSerie()) return true;
//Otra posibilidad
//if(dia==obj.dia && mes==obj.mes && año==obj.año)
// return true;
return false;
}
void Fecha::NumeroSerieaFecha(int ns)
{
int suma=0, dia_adicional, suma_ant;
int anio_real=1900;
while(ns>suma)
{
dia_adicional=(esbisiesto(anio_real)?1:0);
suma_ant=suma;
suma+=365+dia_adicional;
anio_real++;
}
año=anio_real-1;
//Cantidad de días pasados desde año
int dias_anio_actual=ns-suma_ant,i=0;
int vmes[]={31,28,31,30,31,30,31,31,30,31,30,31};
if(esbisiesto(año)) vmes[1]=29;
suma=0;
while(dias_anio_actual>suma) suma+=vmes[i++];
mes=i;
dia=dias_anio_actual-(suma-vmes[i-1]);
}
void Fecha::operator +=(int masdias)
{
int ns=NumeroSerie()+masdias;
NumeroSerieaFecha(ns);
}
istream & operator>>(istream &entra, Fecha &f)
{
cout<<"Ingrese el dia: ";
entra>>f.dia;
cout<<"Ingrese el mes: ";
entra>>f.mes;
cout<<"Ingrese el año: ";
entra>>f.año;
return entra;
}
ostream & operator<<(ostream &sale, Fecha &f)
{
cout<<"Dia: ";
sale<<f.dia<<endl;
cout<<"Mes: ";
sale<<f.mes<<endl;
cout<<"Año: ";
sale<<f.año<<endl;
return sale;
}
Fecha Fecha::operator+(int masdias)
{
Fecha aux;
int ns=NumeroSerie()+masdias;
aux.NumeroSerieaFecha(ns);
return aux;
}
int Fecha::operator -(Fecha &obj)
{
return NumeroSerie()-obj.NumeroSerie();
}
int Fecha::cantDiasMes()
{
int vmes[]={31,28,31,30,31,30,31,31,30,31,30,31};
if(esbisiesto(año)) vmes[1]=29;
return vmes[mes-1];
}
// Devuelve la cantidad de días hábiles del mes correspondiente a la fecha
// No tiene en cuenta si en el mes hay o no feriados
// Una posibilidad es que se identifique en una matriz los días feriados del año
// y se compare cada día con esa matriz
int Fecha::cantDiasHabilesMes()
{
int totDias=cantDiasMes();
int dia, cant=0;
Fecha aux=*this;
for(int i=1;i<=totDias;i++)
{
dia=(aux.NumeroSerie()-1)%7;
if(dia<5) cant++;
aux+=1;
}
return cant;
}
//Devuelve la cantidad de años entre una fecha y el día actual
int Fecha::cantAniosHastaHoy()
{
Fecha aux; //por usar un constructor por defecto tiene la fecha de hoy;
int cant=aux.año-año;
if(mes>aux.mes) return cant-1;
if(mes==aux.mes && dia>aux.dia) return cant-1;
return cant;
}
////////////////////////////////////////////////////////////////////////////////////
bool Fecha::EsSuperiorAFechaActual(Fecha fx){
SYSTEMTIME time;
::GetLocalTime(&time);
//
//la promocion debe ser superior a la fecha actual..
if( fx.getAnio()>time.wYear ||
(fx.getAnio()==time.wYear && fx.getMes()>time.wMonth) ||
(fx.getAnio()==time.wYear && fx.getMes()==time.wMonth && fx.getDia()>time.wDay))
{
return true;
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////////////////
int Fecha::FechaEntreDosFechas(Fecha inicio_de_promocion, Fecha fin_de_promocion, Fecha fecha_de_compra ){
//---------------
// PARTE1
if(fecha_de_compra.getAnio() < inicio_de_promocion.getAnio() )return 0;
if(fecha_de_compra.getAnio() == inicio_de_promocion.getAnio() ){
if(fecha_de_compra.getMes() < inicio_de_promocion.getMes())return 0;
}
if(fecha_de_compra.getAnio() == inicio_de_promocion.getAnio() ){
if(fecha_de_compra.getMes() == inicio_de_promocion.getMes())
if(fecha_de_compra.getDia() < inicio_de_promocion.getDia())return 0;
}
//------------------
// PARTE2
if(fecha_de_compra.getAnio() > fin_de_promocion.getAnio() )return 0;
if(fecha_de_compra.getAnio() == fin_de_promocion.getAnio() ){
if(fecha_de_compra.getMes() > fin_de_promocion.getMes())return 0;
}
if(fecha_de_compra.getAnio() == fin_de_promocion.getAnio() ){
if(fecha_de_compra.getMes() == fin_de_promocion.getMes())
if(fecha_de_compra.getDia() > fin_de_promocion.getDia())return 0;
}
//-----------
return 1;
}
///////////////////////
/*
unsigned int Fecha::CalcularEdad(Fecha birthdate)
{
int AnioActual, AA, MesActual, MM, DiaActual, DD;
int año, Mes, Dia;
int MonthDays[2][12] = {
{31, 28, 30, 31, 30, 31, 31, 31, 30, 31, 30, 31},
{31, 29, 30, 31, 30, 31, 31, 31, 30, 31, 30, 31}
};
SYSTEMTIME time;
GetLocalTime(&time);
AA=birthdate.getAnio();
MM=birthdate.getMes();
DD=birthdate.getDia();
AnioActual=time.wYear;
MesActual=time.wMonth;
DiaActual=time.wDay;
año = AA-AnioActual;
if( MesActual <= MM )
{
Mes = MM - MesActual;
}
else
{
Mes = MM+12-MesActual;
año = año -1;
}
if( DiaActual <= DD )
{
Dia = DD - DiaActual;
}
else
{
Dia=DD+MonthDays[birthdate.esbisiesto(AA)][MM-1]-DiaActual;
Mes = Mes -1;
}
if( Mes < 0 )
{
año = año - 1;
Mes = 12 + Mes;
}
unsigned int Arreglo=año*(-1);
//Result = Format('Años: %.0f, Meses: %.0f, Dias: %.0f', [año, Mes, Dia]);
return Arreglo;
}*/
unsigned int Fecha::CalcularEdad(Fecha birthdate)
{
// Initialize variables
int ReturnAge = 0;
SYSTEMTIME stLocal;
GetLocalTime( &stLocal ); // Get local time
ReturnAge = stLocal.wYear - birthdate.getAnio();
if ( stLocal.wMonth <= birthdate.getMes() )
{
if ( stLocal.wMonth == birthdate.getMes() )
{
if ( stLocal.wDay <= birthdate.getDia() )
ReturnAge--;
}
else
ReturnAge--;
}
return ReturnAge;
}
|
|
|
|
|
12
|
Programación / Programación C/C++ / Operadores de bits
|
en: 4 Abril 2012, 15:51 pm
|
Hola, esto viene a ser una demostración con ejemplos más que un tutorial. Básicamente vamos a hacer una revisión de todos los operadores de bits del lenguaje C y mostrar su funcionamiento. & AND
&= AND Asignativo
| OR
|= OR Asignativo
^ XOR
^= XOR Asignativo
~ Complemento de Uno
<< Desplazamiento Izquierdo
<<= Desplazamiento Izquierdo Asignativo
>> Desplazamiento Derecho
>>= Desplazamiento Derecho Asignativo
Para mostrar su funcionamiento, pongo ejemplos de este enlace: http://www.lix.polytechnique.fr/~liberti/public/computing/prog/c/C/CONCEPT/bitwise.htmlSólo que traduje lo que estaba en otro idioma e hice una combinación de todos los ejemplos como para que quede algo entendible.
AND - OR - XOR ( requieren dos operandos y hacen comparaciones de bits.)
=================================================
AND & copia un bit al resultado si existe en los dos operandos. unsigned int a = 60; /* 60 = 0011 1100 */
unsigned int b = 13; /* 13 = 0000 1101 */
unsigned int c = 0;
c = a & b; /* 12 = 0000 1100 */
copia un bit al resultado si existe en algún operando. unsigned int a = 60; /* 60 = 0011 1100 */
unsigned int b = 13; /* 13 = 0000 1101 */
unsigned int c = 0;
c = a | b; /* 61 = 0011 1101 */
copia un bit al resultado si existe en un operando y no en otro. unsigned int a = 60; /* 60 = 0011 1100 */
unsigned int b = 13; /* 13 = 0000 1101 */
unsigned int c = 0;
c = a ^ b; /* 49 = 0011 0001 */
======================================
NOT ~ tiene el efecto de invertir bits. unsigned int Valor=4; /* 4 = 0000 0100 */
Valor = ~ Valor; /* 251 = 1111 1011 */
============
Los siguientes operadores se usan para desplazar bits a la derecha o izquierda. El valor del operando izquierdo es movido a la derecha o izquierda por el número de bits especificado en el operando derecho. Por ejemplo: unsigned int Valor=4; /* 4 = 0000 0100 */
unsigned int Desplazamiento=2;
Valor = Valor << Desplazamiento; /* 16 = 0001 0000 */
Valor <<= Desplazamiento; /* 64 = 0100 0000 */
printf("%d\n", Valor); /* Muestra 64 */
Usualmente, El bit vacío resultante es asignado como cero (padding). Nota: Siempre use variables 'unsigned' con estos operadores para eludir resultados impredecibles. Los usos de enumeran a continuación pero los ejemplos se los dejo para que los busquen en la red, o si los usuarios del foro de C/C++ se animan a poner sus ejemplos personales del uso de estos operadores XD Usos para Operadores de Bits:
=====================
- Extraer y borrar valores
- Insertar y combinar valores
- Intercambiar variables
- Reemplazar operaciones aritméticas
De todas formas dejo para descargar un proyecto que es parte de esta demostración, y dentro de la carpeta que tiene, hay otra con ejemplos tomados de la web original. Proyecto MSVC++ 6.0 |
|
|
|
|
13
|
Programación / Programación C/C++ / [Tutorial] Obtener dirección de struct dinámicamente
|
en: 3 Abril 2012, 21:44 pm
|
Hola, esto es parte de un test que había hecho hace un tiempo, y a decir verdad la idea me la dió un usuario de este foro (Karman), aunque esto estaba hecho hace mucho tiempo atrás en otros sitios. Esta demostración es completamente por medio de código, pero en la realidad lo que ocurre es que nosotros necesitamos saber por ejemplo, la dirección de una struct llamada 'Player' de un juego X. Osea que tendremos que usar algún depurador y obtenerla manualmente. Este tutorial no es acerca de eso, sino que se muestra como se puede obtener la dirección de una struct en memoria, de forma dinámica; sólo pasándole ciertos parámetros necesarios para que el programa pueda hallarla en memoria. A continuación dejo el código, se trata de saber manejar punteros como para ir navegando la posición de la struct. El código tiene algunos comentarios, me da la impresión que no necesita mucha explicación. //////////////////////////////////////////////////////////////////
//
// UTN FRGP
// 2012
// david_BS
// EMAIL: david_bs@live.com
//
//////////////////////////////////////////////////
#include <windows.h>
#include <stdio.h>
typedef int (*pfnUserMsgHook)(const char *pszName, int iSize, void *pbuf);
struct paquete {
int index;
double asd;
double rr;
float gg;
};
struct paquete pak0_s;
struct paquete* pak1_s;
static int callmuestra(char *szMsgName, pfnUserMsgHook pfn);
static int hookmuestra(char *szMsgName, pfnUserMsgHook pfn);
int main(){
BYTE* address=(BYTE*)&hookmuestra;// ustedes sabrán porque es BYTE* (para luego incrementar de a 1 byte :p)
DWORD* address2=(DWORD*)&callmuestra;// DWORD incrementa de a 4 bytes
printf("hookmuestra: %x\n", address);//401040
printf("callmuestra: %x\n", address2);//401030
struct paquete* ptr = (paquete*) (
*(DWORD*)
(
(
(address+=10)
+
*(DWORD*)(address+1)
+
5
)
+
2
)
);
printf("La direccion de la struct es: %x\n", ptr);
// Logueamiento parte por parte
// printf("address %x\n", address);
//printf("address %x\n", address+=10);//sólo sino se usa ptr que ya incrementa 10
// printf("address %x\n", *(DWORD*)(address+1));
// printf("address %x\n", address + *(DWORD*)(address+1) +5);
// printf("address %x\n", *(DWORD*)((address + *(DWORD*)(address+1) +5) +2 ));
system("pause");
return 0;
}
La función 'callmuestra' contiene la referencia a la struct static int callmuestra(char *szMsgName, pfnUserMsgHook pfn){
pak0_s.index = 5;
return 0;
}
static int hookmuestra(char *szMsgName, pfnUserMsgHook pfn){
callmuestra(szMsgName,pfn);
return 0;
}
Con un debugger o depurador, pueden acceder a la memoria de este programa y observar el código de cada función, y de la localización de la struct. Pueden usar el depurador que viene con el compilador, en mi caso uso el depurador del MSVC++ 6.0 , o el de codeblocks. también dejé algunos comentarios en el ASM de los dumps //callmuestra
00401030 C705 10A94000 05>MOV DWORD PTR DS:[40A910],5 //+2 (direccion de struct)
0040103A 33C0 XOR EAX,EAX
0040103C C3 RETN
//hookmuestra
00401040 8B4424 08 MOV EAX,DWORD PTR SS:[ESP+8]
00401044 8B4C24 04 MOV ECX,DWORD PTR SS:[ESP+4]
00401048 50 PUSH EAX
00401049 51 PUSH ECX //+10
0040104A E8 E1FFFFFF CALL ptr_to_s.00401030 //+1=E8 (+5 = E8+offset)
0040104F 83C4 08 ADD ESP,8
00401052 33C0 XOR EAX,EAX
00401054 C3 RETN
0040A940 0000 ADD BYTE PTR DS:[EAX],AL
0040A942 0000 ADD BYTE PTR DS:[EAX],AL
0040A944 0000 ADD BYTE PTR DS:[EAX],AL
0040A946 0000 ADD BYTE PTR DS:[EAX],AL
0040A948 0000 ADD BYTE PTR DS:[EAX],AL
0040A94A 0000 ADD BYTE PTR DS:[EAX],AL
0040A94C 0000 ADD BYTE PTR DS:[EAX],AL
0040A94E 0000 ADD BYTE PTR DS:[EAX],AL
0040A950 0000 ADD BYTE PTR DS:[EAX],AL
0040A952 0000 ADD BYTE PTR DS:[EAX],AL
0040A954 0000 ADD BYTE PTR DS:[EAX],AL
0040A956 0000 ADD BYTE PTR DS:[EAX],AL
0040A958 0000 ADD BYTE PTR DS:[EAX],AL
0040A95A 0000 ADD BYTE PTR DS:[EAX],AL
0040A95C 0000 ADD BYTE PTR DS:[EAX],AL
0040A95E 0000 ADD BYTE PTR DS:[EAX],AL
0040A960 0000 ADD BYTE PTR DS:[EAX],AL
0040A962 0000 ADD BYTE PTR DS:[EAX],AL
0040A964 0000 ADD BYTE PTR DS:[EAX],AL
0040A966 0000 ADD BYTE PTR DS:[EAX],AL
0040A968 0000 ADD BYTE PTR DS:[EAX],AL
0040A96A 0000 ADD BYTE PTR DS:[EAX],AL
0040A96C 0000 ADD BYTE PTR DS:[EAX],AL
0040A96E 0000 ADD BYTE PTR DS:[EAX],AL
0040A970 0000 ADD BYTE PTR DS:[EAX],AL
0040A972 0000 ADD BYTE PTR DS:[EAX],AL
0040A974 0000 ADD BYTE PTR DS:[EAX],AL
0040A976 0000 ADD BYTE PTR DS:[EAX],AL
0040A978 0000 ADD BYTE PTR DS:[EAX],AL
0040A97A 0000 ADD BYTE PTR DS:[EAX],AL
0040A97C 280A SUB BYTE PTR DS:[EDX],CL
0040A97E 0000 ADD BYTE PTR DS:[EAX],AL
0040A980 0105 00000500 ADD DWORD PTR DS:[50000],EAX
Que sigan bien ;-D |
|
|
|
|
14
|
Programación / Programación C/C++ / manipulación de un objeto multidimensional
|
en: 3 Abril 2012, 03:49 am
|
Un ejemplo que muestra varias cosas, uso de punteros, manipulación de un objeto multidimensional, uso de static en el objeto, y lo que sea, que puede ayudar a iniciados en el lenguaje C/C++. Como siempre, trato de loguear cierta información que permita saber el comportamiento del programa. //////////////////////////////////////////////////////////////////
//
// UTN FRGP
// 2012
// david_BS
// EMAIL: david_bs@live.com
//
//////////////////////////////////////////////////
#include <windows.h>
#include <stdio.h>
struct somestruct{
int index;
};
#define MAX 8
typedef float tMatrix[MAX][3][4];
float**** Inicializar( void ){
static float mmf[8][3][4];// para que no cambie de dirección
// inicializamos el objeto tridimensional
for(int i=0; i<8; i++)
for(int j=0; j<3; j++){
for(int k=0; k<4; k++){
switch(i){
case 0: {
switch(j){
case 0: {
switch(k){
case 0: {mmf[i][j][k]=0.02f;break;}
case 1: {mmf[i][j][k]=0.022f;break;}
case 2: {mmf[i][j][k]=0.0222f;break;}
case 3: {mmf[i][j][k]=0.02222f;break;}
}
break;
}
case 1: {mmf[i][j][k]=0.03f;break;}
case 2: {mmf[i][j][k]=0.04f;break;}
}
break;
}
case 1: {mmf[i][j][k]=0.05f;break;}
case 2: {mmf[i][j][k]=0.7f;break;}
case 3: {mmf[i][j][k]=99;break;}
case 4: {mmf[i][j][k]=0.11f;break;}
case 5: {mmf[i][j][k]=88;break;}
case 6: {mmf[i][j][k]=33;break;}
case 7: {mmf[i][j][k]=100;break;}
}
}
}
return (float****)&mmf;// retornamos la dirección del objeto
}
void Mostrar (float m[3][4]){
for(int i=0; i<3; i++)
for(int j=0; j<4; j++)
printf("%f\n",m[i][j]);
}
int main(){
// pB va a ser un puntero a un objeto de 3 dimensiones
tMatrix *pB = ( tMatrix* )Inicializar( );
struct somestruct vS[8];
vS[0].index=0;
vS[1].index=1;
vS[2].index=2;
vS[3].index=3;
vS[4].index=4;
vS[5].index=5;
vS[6].index=6;
vS[7].index=7;
struct somestruct* pS;
pS=vS;
Mostrar((*pB)[pS[0].index]);// dentro de pB hay una matriz de 3x4
system("pause");
return 0;
}
|
|
|
|
|
15
|
Programación / Programación C/C++ / manipulación de punteros (ejemplo con float)
|
en: 3 Abril 2012, 03:26 am
|
Hola, dejo un código en el que utilizo algunas de las manipulaciones diferentes de punteros, para este ejemplo uso el tipo 'float'. Esto puede ayudar a ciertos iniciados a entender el manejo de punteros, al menos para tipos de datos como int o float. También se remarca la diferencia entre un vector de punteros y un puntero a vector. //////////////////////////////////////////////////////////////////
//
// UTN FRGP
// 2012
// david_BS
// EMAIL: david_bs@live.com
//
//////////////////////////////////////////////////
#include <windows.h>
#include <stdio.h>
int main(){
float vec1[5]={ 0.5f, 0.2f, 0.22f, 0.01f, 0.0f };
float vec2[5]={ 0.5f, 0.2f, 0.22f, 0.01f, 0.0f };
float vec3[5]={ 0.5f, 0.2f, 0.22f, 0.01f, 0.0f };
float (*vec4)[5];// puntero a vector de floats
float (*vec5)[5];// puntero a vector de floats
float (*vec6)[5];// puntero a vector de floats
vec4=&vec1;
vec5=&vec2;
vec6=&vec3;
float* pf1[3]; //vector de punteros a vectores de float
pf1[0]=&vec1[0];
pf1[1]=&vec2[0];
pf1[2]=&vec3[0];
float* pf2[3]; //vector de punteros a vectores de float
pf2[0]=*vec4;
pf2[1]=*vec5;
pf2[2]=*vec6;
float** ppf1;
ppf1 = (float**)&pf1;//se le asigna la direccion de un vector de punteros a vectores de float
float** ppf2;
ppf2 = (float**)&pf2;//se le asigna la direccion de un vector de punteros a vectores de float
printf("vec1: %x\n",vec1);
printf("vec4: %x\n",vec4);
printf("pf1: %x\n",pf1);
printf("pf1[0]: %x\n",pf1[0]);
printf("ppf1: %x\n",ppf1);
printf("*ppf1: %x\n",*ppf1);
printf("vec3: %x\n",vec3);
printf("ppf1[2]: %x\n",ppf1[2]);
printf("*ppf1[0]: %f\n",*ppf1[0]);
printf("*ppf1[1]: %f\n",*ppf1[1]);
printf("*ppf1[2]: %f\n",*ppf1[2]);
printf("*(ppf1[0]+1): %f\n",*(ppf1[0]+1));
printf("*(ppf1[1]+1): %f\n",*(ppf1[1]+1));
printf("*(ppf1[2]+1): %f\n",*(ppf1[2]+1));
system("pause");
return 0;
}
|
|
|
|
|
16
|
Programación / Programación C/C++ / ejemplo de ordenamientos básicos
|
en: 2 Abril 2012, 02:30 am
|
Un par de ejemplos de ordenamientos, uno para enteros que deben ordenarse de menor a mayor, y otro para cadenas que deban ordenarse alfabéticamente.
//
// UTN FRGP
// 2012
// David_BS
// david_bs@live.com
///////////////////////////////////////////////////
#include <windows.h>
#include <stdio.h>
void TratarVectorDeInt(){//de menor a mayor
printf("\n");
int vec[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
int aux;
for(int i=0; i< (11-1); i++){
for(int j=(i+1); j< 11; j++){
if(vec[j]<vec[i]){
aux=vec[i];
vec[i]=vec[j];
vec[j]=aux;
}}}
for(int k=0;k<11;k++)
printf("%d\n",vec[k]);
system("pause");
}
int ComparaDosCadenas(const char* str1, const char* str2);
void TratarVectorDeStrings(){//orden alfabético
printf("\n");
char vec[][16] =
{
"Guatemala\0",
"Brasil\0",
"Estados Unidos\0",
"Paraguay\0",
"Argentina\0",
"Chile\0",
"Peru\0",
"Mexico\0",
"Cuba\0",
"Honduras\0"
};
char aux[16];
for(int i=0;i<(10-1);i++){
for(int j=(i+1); j< 10; j++){
if(ComparaDosCadenas(vec[j],vec[i])>0){
memset(aux,0,sizeof(aux));
strcpy(aux,vec[i]);
strcpy(vec[i],vec[j]);
strcpy(vec[j],aux);
}}}
for(int k=0;k<10;k++)
printf("%s\n",vec[k]);
system("pause");
}
int main()
{
// 1: ordenar un vector de enteros
TratarVectorDeInt();
// 2: ordenar una matriz de char (vector de strings)
TratarVectorDeStrings();
return 0;
}
int ComparaDosCadenas(const char* str1, const char* str2){//si la 1 es menor a la 2
// printf("str1: %s ; str2: %s\n",str1,str2);
int l1=strlen(str1);//brasil
int l2=strlen(str2);//guatemala
char aux1[16];strcpy(aux1,str1);
char aux2[16];strcpy(aux2,str2);
strlwr(aux1);
strlwr(aux2);
// printf("str1: %s ; str2: %s\n",aux1,aux2);
int len=l1;
if(l2<l1) len=l2;
for(int i=0; i<len; i++){
// printf("str1: %c ; str2: %c\n",aux1[i],aux2[i]);
if(aux1[i]<aux2[i]) return 1;
else
if(aux1[i]>aux2[i]) return 0;
}
if(l1>l2) return 1;
return 0;
}
|
|
|
|
|
17
|
Programación / Programación C/C++ / Ejemplo de programa WinApi32 GUI
|
en: 2 Abril 2012, 00:08 am
|
Un proyecto de un programa básico con interfáz gráfica de Windows. Está hecho con MSVC++ 6.0 proyectohttp://www.mediafire.com/?yd4vpb42j4p1pi6winmain.cpp//
// UTN FRGP
// 2011
// david_BS
// EMAIL: david_bs@live.com
//
//////////////////////////////////////////////////
//#define WINVER 0x0500 //WINVER as 0x0500 enables features specific to Win 98 and 2000
//#define VC_EXTRALEAN
#include <windows.h>
//gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib
/////////////////////////
// Globales
HWND EditControl1;
HWND EditControl2;
HWND EditControl3;
HWND StaticControl1;
const int ID_EDIT1=1, ID_EDIT2=2, ID_EDIT3=3, ID_EDIT4=4, ID_EDIT5=5;
const int ID_OK = 6;
const int ID_CANCEL = 7;
const int ID_LABEL1 = 0;
/////////////////////////////
void getCentradoGlobal(int vXY[2], int h, int w);
///////////////
// Controles de ventana
void RegistrarControlesDeVentanaPrincipal(HWND hWin)
{
static char* t1 = TEXT("Ingrese 3 numeros");
unsigned long EstiloHijo1 = WS_VISIBLE | WS_CHILD;
unsigned long EstiloHijo2 = WS_CHILD | WS_VISIBLE | WS_BORDER;
unsigned long EstiloHijo3 = WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON;
unsigned long EstiloHijo4 = WS_CHILD | WS_VISIBLE | LBS_NOTIFY | LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP;
long editstyle =WS_CHILD|WS_VISIBLE|WS_BORDER|WS_TABSTOP;//|ES_AUTOHSCROLL;//|WS_TABSTOP;
int offs = 30;
int X=20;
int Y=10;
int W=80;
int H=25;
StaticControl1 = CreateWindow( TEXT("static"),
t1,
EstiloHijo1,
20,10,180,20,
hWin,
(HMENU)ID_LABEL1,
NULL,
NULL);
EditControl1 = CreateWindow( TEXT("Edit"),
NULL,
editstyle,
X,
Y+20,
W,
H,
hWin,
(HMENU)ID_EDIT1,
NULL,
NULL);
EditControl2 = CreateWindow( TEXT("Edit"),
NULL,
editstyle,
X,
Y+20+(offs*1),
W,
H,
hWin,
(HMENU)ID_EDIT2,
NULL,
NULL);
EditControl2 = CreateWindow( TEXT("Edit"),
NULL,
editstyle,
X,
Y+20+(offs*2),
W,
H,
hWin,
(HMENU)ID_EDIT3,
NULL,
NULL);
CreateWindow( TEXT("button"),
TEXT("Sumar"),
EstiloHijo1,
X,130,60,H,
hWin,
(HMENU) ID_OK,
NULL,
NULL);
CreateWindow( TEXT("button"),
TEXT("Salir"),
EstiloHijo1,
X+70,130,50,H,
hWin,
(HMENU)ID_CANCEL,
NULL,
NULL);
}
//////////
// CallBack
INT_PTR CALLBACK WinProc(HWND hWin, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_CREATE:
{
RegistrarControlesDeVentanaPrincipal(hWin);
}
break;
case WM_KEYDOWN:
{
if(wParam==VK_TAB){
}
}
break;
case WM_COMMAND:
{
switch(LOWORD(wParam))
{
case ID_OK:
{
char chBuffer1[128];
memset(chBuffer1,0,sizeof(chBuffer1));
GetDlgItemText( hWin,ID_EDIT1, chBuffer1, sizeof( chBuffer1 ) );
char chBuffer2[128];
memset(chBuffer2,0,sizeof(chBuffer2));
GetDlgItemText( hWin,ID_EDIT2, chBuffer2, sizeof( chBuffer2 ) );
int i_res = atoi(chBuffer1)+atoi(chBuffer2);
char ch_res[128];
itoa(i_res,ch_res,10);
HWND Edit3 = GetDlgItem(hWin,ID_EDIT3);
SendMessage(Edit3 , WM_SETTEXT, 0, (LPARAM)ch_res);
}
break;
case ID_CANCEL:
{
SendMessage(hWin, WM_CLOSE, 0, 0);
return TRUE;
}
break;
}
}
break;
case WM_CLOSE:
{
DestroyWindow(hWin);
return TRUE;
}
/////////////////////////////
case WM_DESTROY:
{
PostQuitMessage(0);
return TRUE;
}
default:
return DefWindowProc(hWin,uMsg,wParam,lParam);
}
return 0;
//return DefWindowProc(hWin,uMsg,wParam,lParam);
}
////////////
// Clase de ventana
void RegistrarClaseVentana(WNDCLASS* wc)
{
// HICON hIconImg = (HICON)LoadImage(NULL, "BS.ico", IMAGE_ICON, 542, 449, LR_LOADFROMFILE);
wc->lpszClassName = TEXT("Window");
wc->hInstance = GetModuleHandle(NULL);
//wc->hbrBackground = GetSysColorBrush(COLOR_3DFACE);
wc->hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
wc->lpfnWndProc = (WNDPROC)WinProc;
wc->style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc->cbClsExtra = 0;
wc->cbWndExtra = 0;
//wc->hIcon = LoadIcon(NULL,"IDI_ICON1");
wc->hIcon = LoadIcon(NULL,"IDI_WINLOGO");
wc->hCursor = LoadCursor(NULL,IDC_ARROW);
wc->lpszMenuName = NULL;
RegisterClass((struct tagWNDCLASSA *)wc);
}
//////////////
// Punto de entrada ('WinMain' : must be '__stdcall')
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE h0, LPSTR lpCmdLine, int nCmdShow){
HWND hWin;
WNDCLASS wc = {0};
RegistrarClaseVentana(&wc);
int ancho=250;
int alto=200;
int dim[2];
getCentradoGlobal(dim, ancho, alto);
unsigned long Estilo1 = WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
hWin = CreateWindow( wc.lpszClassName,
"GUI32",
Estilo1,
dim[0],
dim[1],
ancho,
alto,
NULL,
NULL,
hInst,
NULL);
// ShowWindow(hWin,nCmdShow);
ShowWindow(hWin, SW_SHOWDEFAULT);
//UpdateWindow(hWin);
MSG msg;
while(GetMessage(&msg, NULL, 0, 0)>0) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
////////
void getCentradoGlobal(int vXY[2], int h, int w)
{
RECT rcP;
GetWindowRect(GetDesktopWindow(), &rcP);
int centerX = (rcP.right/2)-(w/2)-(w/4);
int centerY = (rcP.bottom/2)-(h/2)+(h/6);
vXY[0]=centerX;
vXY[1]=centerY;
}
|
|
|
|
|
19
|
Programación / Programación C/C++ / uso de llaves para poder declarar variables del mismo nombre
|
en: 31 Marzo 2012, 17:43 pm
|
Esto es algo que muchos iniciados no saben, y es que las llaves de c/c++ son para marcar ámbitos, por ejemplo el ámbito de una función es lo que está dentro de sus llaves. por ejemplo, si quisiera crear dos FOR que utilicen una misma variable llamada 'i', y quiero declararla dos veces, esto normalmente no se puede hacer dentro de una función, pero si lo hacemos dentro de otro ámbito separado por llaves es posible. void Funcion_Dummy()
{
{
for(int i=0; i<5; i++)
{
}
}
/* vuelvo a declarar 'i' pero dentro de otro ámbito de llaves */
{
for(int i=0; i<5; i++)
{
}
}
} parece ser un pequeño truquillo, pero es muy útil si les gusta usar los mismos nombres de variables, por ejemplo en los FOR siempre nos gusta usar i,j,k, etc La consigna es tener consciencia del ámbito en el que estamos. Que estén bien ;-D |
|
|
|
|
20
|
Programación / Programación C/C++ / processar matrices
|
en: 14 Marzo 2012, 18:59 pm
|
ak muestro como se puede procesar una matríz de int's de 6 formas diferentes, si se les ocurre otras formas pueden mostrarlas.. se da una matríz de 2x5 inicializada y se trata de listar los 10 números de la misma, de formas diferentes usando también notación de punteros. void procesar_mat1(int **m){
for(int i=0;i<10;i++){
cout << "m: " << (int)m[i] << endl;
}
}
void procesar_mat2(int (*m)[5]){
for(int i=0;i<2;i++){
for(int j=0; j<5; j++){
cout << "m: " << m[i][j] << endl;
}
}
}
void procesar_mat3(int m[2][5]){
for(int i=0;i<2;i++){
for(int j=0; j<5; j++){
cout << "m: " << m[i][j] << endl;
}
}
}
void procesar_mat4(int **m){
int *p=(int*)&m[0];
for(int i=0;i<10;i++){
cout << "p: " << p[i] << endl;
}
}
void procesar_mat5(int *m){
for(int i=0;i<10;i++){
cout << "m: " << m[i] << endl;
}
}
void procesar_mat6(int (*m)[]){
int *p=(int*)m;
for(int i=0;i<10;i++){
cout << "p: " << p[i] << endl;
}
}
int main()
{
int mat[2][5] = { { 1,2,3,4,5 },{ 1,2,3,4,5 } };
//procesar_mat1((int**)mat);
//procesar_mat2(mat);
//procesar_mat3(mat);
//procesar_mat4((int**)mat);
//procesar_mat5((int*)mat);
//procesar_mat5(*mat);
procesar_mat6((int (*)[])mat);
PAU
return 0;
}
Hasta luego |
|
|
|
|
|
| |
|
