Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Temas - david_BS

#1
Buenas, tengo un código que había usado hace bastante tiempo para la administración de un grupo de vectores que usaba para un funcionalidad especial en mi hack de Counter-Strike. Quisiera comentar que los vectores 3D, cuando hablamos de videojuegos 3D, se refiere a un vector que contiene tres datos los cuales son las dimensiones del mundo ("world") dentro del videojuego mismo. Estas dimensiones son las mismas en un juego 3D que en la realidad, y estas son x, y, z.
Algo rápido que encontré:
http://en.wikipedia.org/wiki/Cartesian_coordinate_system


Entonces, esa funcionalidad que había mencionado antes, se llama "Aimbot", y se trata de conseguir ciertos vectores que determinen la posición deseada para poder apuntar al enemigo. El tema no es como hacer el aimbot porque ya está hecho hace rato y el código lo publiqué hace tiempo también..
Pero quería postear por separado el código con el cual tenía un manejo de esos vectores particulares que les decía.

También les dejo el proyecto:
http://www.mediafire.com/?qs2wha3b0qdajbg

EDITADO:

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
// UTN FRGP TSP
// BS
// mail: david_bs@live.com
// web: Etalking.Com.Ar
// 2012
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <stdio.h>
#include <fstream.h>
#include <vector>

using namespace std;

struct vec
{
float h;
float f;
float r;
};

#define VEC_INDEX_MAX 32
vector<vec> Vecs[VEC_INDEX_MAX];

#define VECS 6


Como en todo sistema de administración básico, tenemos funciones de agregar, borrar y listar.

void func_vec_add(int index, float x, float y, float z)
{
vec v;
v.h = z;
v.f = x;
v.r = y;  
if(index<=VECS){
Vecs[index].push_back(v);
}
}

void func_vec_clear(int index)
{
   if(index == -1){
      for(int i=0;i<=VECS;i++)
  Vecs[i].clear();
   }
else if(index>=0&&index<=VECS){
           Vecs[index].clear();
   }
}

void func_vec_list(int index)
{
cout << "\n";

if(index == -1){

int cantidad=0;

for(int i=0;i<=VECS;i++)
for(vector<vec>::iterator si = Vecs[i].begin(); si != Vecs[i].end();++si)
{
cantidad++;
printf("Height: %f Forward: %f Right: %f\n",si->h,si->f,si->r);
}

if(cantidad==0)
cout << "no hay elementos !" << endl;
}

else
{
if(index<=VECS){
  for(vector<vec>::iterator si = Vecs[index].begin(); si != Vecs[index].end();++si)
  {
printf("Height: %f Forward: %f Right: %f\n",si->h,si->f,si->r);
  }
}
}
}


Esta función main es sólo para pruebas..

int main(){

func_vec_add(0, 100, 200, 0.61f);
func_vec_add(1, 100, 200, 0.98f);
func_vec_add(2, 100, 200, 0.59f);
func_vec_add(3, 100, 200, 0.15f);
func_vec_add(4, 100, 200, 0.00f);
       func_vec_add(5, 100, 500, 1.00f);
func_vec_add(6, 100, 900, 2.00f);

//func_vec_list(0);
func_vec_list(-1);

func_vec_clear(-1);

func_vec_list(-1);

cin.get();
return 0;
}


si quieren ver un aimbot de vectores para el Counter-Strike en acción (o mejor dicho, implementado), vean:
http://foro.elhacker.net/programacion_cc/hurricane_linea_i_ii_y_iii-t360899.0.html
#2
Esto es una muestra de código que demuestra como se usa una list para guardar elementos de tipo struct 'ScheduledCommand', que hace referencia a comandos que se van guardando y ejecutándose, dado que este código estaba aplicado a un sistema con consola de comandos. Lo que hice fue aislar el código referente al uso de list y demostrarlo con un ejemplo. Créditos para el proyecto OGC.

Descarga: http://www.mediafire.com/?pujccy7douubkgo


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
// UTN FRGP TSP
// BS
// mail: david_bs@live.com
// web: Etalking.Com.Ar
// 2012
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <stdio.h>
#include <fstream.h>
#include <list>
#include <string>

using namespace std;

struct ScheduledCommand
{
string comando;
int prioridad;
};

typedef list<ScheduledCommand> ScheduleList;
ScheduleList scheduleList;


Las funciones de agregar, listar y borrar

void IngresarComando(){

string cmd;
char comando[21];
memset(comando,0,sizeof(comando));
cout << "Ingrese un comando" << endl;
cin.getline(comando,20,'\n');
cmd.assign(comando);

// cout << const_cast<char*>(cmd.c_str()) << endl;
// system("pause");

if(cmd.empty()) // Si se ingresa una línea en blanco procede a mostrar los comandos en lista
{
list<ScheduledCommand>::iterator pos;
for(pos=scheduleList.begin();pos!=scheduleList.end();++pos)
{
printf("pri:%d -- cmd:\"%s\"\n", (*pos).prioridad, (*pos).comando.c_str() );
}
return;
}

ScheduledCommand tmp;
tmp.comando=cmd;
tmp.prioridad=1;
if(scheduleList.size()<32){
scheduleList.push_back(tmp);
}
}

void BorrarComandos(){

scheduleList.erase(scheduleList.begin(),scheduleList.end());
}

void VerificarComandos(){

cout << "\n";

int cantidad=0;
for( ScheduleList::iterator pos = scheduleList.begin(); pos != scheduleList.end(); ++pos)
{
// cantidad++;
if( (*pos).prioridad == 1 )
{
cantidad++;
cout << "Comando: " << const_cast<char*>((*pos).comando.c_str()) << endl;
scheduleList.erase(pos); // lo borra luego de verificarlo
break;
}
}

if(cantidad==0)
cout << "No hay comandos !" << endl;
}


La función main para realizar las pruebas..

int main(){

IngresarComando();
IngresarComando();
IngresarComando();

VerificarComandos();
VerificarComandos();
VerificarComandos();

BorrarComandos();

VerificarComandos();

cin.get();
return 0;
}

#3
Hola de nuevo.
Voy a mostrar un ejemplo del uso de un vector para manejar una especie de lista de entidades. Una entidad en este caso, se representa mediante una struct. Para este ejemplo, la struct va a tener algunos miembros de tipo entero solamente, con el fin de simplificar.

Es un código básico en el cual se permite mediante funciones, agregar y borrar entidades, y listar datos de entidades.

Se trata de mostrar un uso básico de 'vector' de la STL

Créditos al proyecto OGC por su aplicación original.

El proyecto en MSVC++ se puede descargar a continuación:
http://www.mediafire.com/?jq1tfjylz5qj8js


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
// UTN FRGP TSP
// BS
// mail: david_bs@live.com
// web: Etalking.Com.Ar
// 2012
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <stdio.h>

#include <fstream.h>
#include <string>
#include <vector>

using namespace std;

typedef struct estructura_s{
int a;
int b;
int c;
}estructura_t;

struct ent_info{
estructura_s* ent;
};

vector<ent_info> vEntidad;


Las estructuras representativas de una entidad ya fueron mostradas, luego se crea un vector de entidades.

Agregar y borrar entidades; listar items de una entidad.

void AgregarEntidad(struct estructura_s* ent)
{
ent_info dummy;
dummy.ent = ent;
if(vEntidad.size()<64)
vEntidad.push_back(dummy);
}

void BorrarVectorDeEntidades()
{
vEntidad.clear();
}

void ListarItemsDeEntidades(){

for(unsigned int ab=0; ab<vEntidad.size(); ab++){

cout << "La entidad: " << ab << endl;
cout << "Item 1: " << vEntidad[ab].ent->a << endl;
cout << "Item 2: " << vEntidad[ab].ent->b << endl;
cout << "Item 3: " << vEntidad[ab].ent->c << endl;
}
}



int main(){

BorrarVectorDeEntidades();

struct estructura_s ent1;
struct estructura_s ent2;
struct estructura_s ent3;
ent1.a=111;
ent1.b=222;
ent1.c=333;
ent2.a=444;
ent2.b=555;
ent2.c=666;
ent3.a=777;
ent3.b=888;
ent3.c=999;

AgregarEntidad(&ent1);
AgregarEntidad(&ent2);
AgregarEntidad(&ent3);

ListarItemsDeEntidades();

cin.get();
return 0;
}

#4
Hola, voy a postear un ejemplo en el que se muestra el uso de map y vector, para lograr un manejo de datos, en este caso, de nombres de elementos almacenados y obtener su número de identificador. Para el vector se usa una struct con dos miembros, uno el nombre del elemento y otro el identificador. También se usa un puntero a un registro de tipo struct 'PrivateData', con el cual podemos hacer uso de los métodos de map y string. La idea de este código pertenece al proyecto OGC pero lo que he tratado de hacer es "aislar" el método para demostrar su uso con un ejemplo.

Dejo el proyecto para descargar:
http://www.mediafire.com/?4sawtvs9czbd17s

En este ejemplo no se usan los defines pero están para mayor comodidad

#define INDEXFIND_BY_ID   (((PrivateData*)my_data)->findByID)
#define INDEXFIND_BY_NAME (((PrivateData*)my_data)->findByName)



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
// UTN FRGP TSP
// BS
// mail: david_bs@live.com
// web: Etalking.Com.Ar
// 2012
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <stdio.h>

#include <fstream.h>
#include <map>
#include <string>
#include <vector>

using namespace std;

typedef map<int,int> MapIntInt;

struct PrivateData{
MapIntInt findByID;
string findByName;
};

void* my_data;

#define INDEXFIND_BY_ID   (((PrivateData*)my_data)->findByID)
#define INDEXFIND_BY_NAME (((PrivateData*)my_data)->findByName)

struct Info
{
char szName[36];
int iId;
};

vector<Info> infoList;

void Constructor()
{
my_data = new PrivateData;
}

void Destructor()
{
   delete (PrivateData*)my_data;
}



void Completa(int id, const char* name){

Info newElemento;

strcpy( newElemento.szName, name );
newElemento.iId = id;

// find: retorna un iterator
MapIntInt::iterator foundpos = (((PrivateData*)my_data)->findByID).find( newElemento.iId );

typedef MapIntInt::value_type Entry;

if(foundpos==((((PrivateData*)my_data)->findByID).end())) // al final (luego del último elemento)
{
int index = infoList.size();
infoList.push_back(newElemento);
(((PrivateData*)my_data)->findByID).insert(Entry(newElemento.iId,index)); // inserta elemento nuevo
(((PrivateData*)my_data)->findByName).assign(newElemento.szName);
}
else //repite
{
int index = foundpos->second; // un par tiene un segundo elemento..
infoList[index]=newElemento;
}
}


Con esta función accedemos a los nombres almacenados en el vector

const char* getNamebyId(int id)
{
MapIntInt::iterator foundpos = (((PrivateData*)my_data)->findByID).find( id );
if(foundpos==((((PrivateData*)my_data)->findByID).end())) { return "ninguna"; }
int index = foundpos->second;
return infoList[index].szName;
}



int main(){

Constructor();
Completa(0, "AK");
Completa(0, "SCOUT");
Completa(1, "AP");
Completa(2, "DESERT");

Completa(1, "M4");
Completa(1, "M4");
Completa(1, "M4");

cout << "La id 0 contiene: " << getNamebyId(0) << endl;
cout << "La id 1 contiene: " << getNamebyId(1) << endl;
cout << "La id 2 contiene: " << getNamebyId(2) << endl;


cin.get();
Destructor();
return 0;
}

#5
Hola, quiero publicar en este foro de C/C++ mi hook para Counter-Strike que había empezado a desarrollar hace tiempo atrás (2007-2008).

En realidad yo empecé a trabajar sobre un proyecto existente que empezó mucho antes (2004-2005) y se llamaba "El camino del huracán" o "Camino del tornado".
Este proyecto era de unos chinos programadores de cheats (007, TJC911, y otros nombres numéricos que se ponen los chinos XD ).
Los chinos, de la misma forma, se había basado en proyectos existentes hasta el momento (Kyros, NK, OGC).
Entonces empecé a desarrollar por mi cuenta el nuevo "Huracán" y el proyecto se divide en 3 líneas. La línea 1 incluye las primeras versiones full, la línea 2 incluye la versión Final y otras versiones más modernas. La línea 3 incluye algunos cambios con respecto a las anteriores líneas.

Mi proyecto estubo en mantenimiento desde el 2007 al 2011, y luego publiqué todos los proyectos para que cualquiera pueda verlos.
Se trata de un multihack para Counter-Strike , y la intención de publicar el código fuente es sólo para fines educativos , como lo fue para mí.

Es decir la idea es verlo desde el punto de vista de la programación, y no de hackear los juegos online , inclusive mi código en sí no sirve para hackear en servidores con sistema anticheat, por lo tanto se trata de algo 100% con fines educacionales.

Estos (huracanes) fueron los primeros hacks que salieron con waypoints, osea con rutas para navegar el mapa.

El tema es que se puede aprender mucho de estos códigos, entre otras cosas:

- Inyección DLL
- Hooking
- OpenGL (cosas básicas)
- Clases
- STL
- mucho más ...

Descargas
Línea I
Línea II
Línea III

Los proyectos fueron creados para Visual C++ 6.0 y también para VC++ 7.1

fotito
http://img339.imageshack.us/img339/8397/dedust20002tj.png

p.s no me digan chitero, no juego al CS :/

#6
Hola, había observado en el foro que un usuario había preguntado sobre como hacer algo así, y otros usuarios le dieron ciertas ideas..
Entonces decidí tratar de hacerlo ya que me había parecido algo complicado, y logré buenos resultados. pero estoy seguro que faltan validaciones y muchos otros casos para que el programa interprete y pueda realizar la conversión.

Entonces voy a postear el programa funcionando para algunos casos, pero como ya dije no puede estar completo ya que si ingresan una cadena de un número literal grande entonces no va a interpretarla.

El objetivo es mostrar la idea, y por supuesto si alguien quiere postear su propia idea o mejorar mi código, bienvenido

Dejo el project en VS6.0 para descargarlo

A continuación describo un poco el code,

Estas son las estructuras de datos (matrices char o vector de string) en donde guardo ciertas cadenas con nombres particulares.. me refiero a nombres de números o nombres los cuales pueden combinarse y significar un número.


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// UTN FRGP TSP
// 2012
// BS
// david_bs@live.com
// Etalking.Com.Ar
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <stdio.h>

char otros[100][30] = {

"cero",
"X",
"X",
"X",
"X",
"X",
"X",
"X",
"X",
"X",
"X",
"once",
"doce",
"trece",
"catorce",
"quince",
"dieciseis",
"diecisiete",
"dieciocho",
"diecinueve",
"X",
"veintiuno",
"veintidos",
"veintitres",
"veinticuatro",
"veinticinco",
"veintiseis",
"veintisiete",
"veintiocho",
"veintinueve",
"X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X",
"X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X",
"X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X","X",
"X","X","X","X","X","X","X"
};

char especiales[][30] = {

"veintiun",
"ciento",
"millon"
"billon"
"millones",
"billones"
};

char cadenas1[][30] = {

"uno",
"un",
"diez",
"cien",
"mil",
};

char cadenas2[][30] = {

"dos",
"veinte",
"doscientos",
};

char cadenas3[][30] = {

"tres",
"treinta",
"trescientos",
};

char cadenas4[][30] = {

"cuatro",
"cuarenta",
"cuatrocientos",
};

char cadenas5[][30] = {

"cinco",
"cincuenta",
"quinientos",
};

char cadenas6[][30] = {

"seis",
"sesenta",
"seiscientos",
};

char cadenas7[][30] = {

"siete",
"sententa",
"setecientos",
};

char cadenas8[][30] = {

"ocho",
"ochenta",
"ochocientos",
};

char cadenas9[][30] = {

"nueve",
"noventa",
"novecientos",
};


Luego una función auxiliar que no viene al caso explicar..

unsigned int DivisionesDeVector(unsigned int* vec, unsigned int veclen){

unsigned int c=0;
for(unsigned int i=0; i<veclen; i++){

if(vec[i]>0) c++;
}
return c;
}



Esta función si es importante porque recibe la cadena ingresada por partes, y las va interpretando.. parece que tiene muchos fores pero son pequeños XD

unsigned int Equivalencia(const char* str){

unsigned int len = strlen(str);
char str_test[30];
memset(str_test,0,sizeof(str_test));
strcpy(str_test,str);

if(!strcmpi(str, "veintiun")){

return 21;
}

if(!strcmpi(str, "ciento")){

return 100;
}

if(!strcmpi(str, "millon")){
return 1000000;
}

if(!strcmpi(str, "billon")){
return -1;
}

if(!strcmpi(str, "millones")){
return 1000000;
}

if(!strcmpi(str, "billones")){
return -1;
}

{
for(unsigned int i=0; i<100;i++)
{
if(otros[i][0]!='X')
if(!strcmpi(str_test, otros[i])){
return i;
}
}
}

{
for(unsigned int i=0; i<5;i++)
{
if(!strcmpi(str_test, cadenas1[i])){
if(i==0) return 1;
if(i==1) return 1;
if(i==2) return 10;
if(i==3) return 100;
if(i==4) return 1000;
}
}
}

{
for(unsigned int i=0; i<3;i++)
{
if(!strcmpi(str_test, cadenas2[i])){
if(i==0) return 2;
if(i==1) return 20;
if(i==2) return 200;
}
}
}

{
for(unsigned int i=0; i<3;i++)
{
if(!strcmpi(str_test, cadenas3[i])){
if(i==0) return 3;
if(i==1) return 30;
if(i==2) return 300;
}
}
}

{
for(unsigned int i=0; i<3;i++)
{
if(!strcmpi(str_test, cadenas4[i])){
if(i==0) return 4;
if(i==1) return 40;
if(i==2) return 400;
}
}
}

{
for(unsigned int i=0; i<3;i++)
{
if(!strcmpi(str_test, cadenas5[i])){
if(i==0) return 5;
if(i==1) return 50;
if(i==2) return 500;
}
}
}

{
for(unsigned int i=0; i<3;i++)
{
if(!strcmpi(str_test, cadenas6[i])){
if(i==0) return 6;
if(i==1) return 60;
if(i==2) return 600;
}
}
}

{
for(unsigned int i=0; i<3;i++)
{
if(!strcmpi(str_test, cadenas7[i])){
if(i==0) return 7;
if(i==1) return 70;
if(i==2) return 700;
}
}
}

{
for(unsigned int i=0; i<3;i++)
{
if(!strcmpi(str_test, cadenas8[i])){
if(i==0) return 8;
if(i==1) return 80;
if(i==2) return 800;
}
}
}

{
for(unsigned int i=0; i<3;i++)
{
if(!strcmpi(str_test, cadenas9[i])){
if(i==0) return 9;
if(i==1) return 90;
if(i==2) return 900;
}
}
}

return -1;
}


El main es largo y lo voy a hacer por partes en otro momento, pero por ahora está así y supongo que se puede apreciar así.

Lo que tiene el main es que se divide en ciertas partes, la primera es la cadena que se va a ingresar para ser procesada, la segunda es el procesamiento por partes de la cadena; y la tercera es como se realizan ciertas operaciones matemáticas para lograr el resultado final.
Las operaciones se hacen con los valores acumulados en un vector auxiliar.

Como ya les dije, no hagan pruebas con números literales de mas de 7 divisiones porque el programa no va a hacer nada al respecto.

Por ejemplo, esta cadena:

const char* cadenax = "ciento sesenta y dos mil trescientos treinta y seis\0";


el programa la reconoce como de 7 divisiones, pero no traten con cadenas de más divisiones porque no se maneja esa situación.



int main(){

// const char* cadenax = "ocho\0";
// const char* cadenax = "ocho mil seiscientos veintitres\0";
// const char* cadenax = "novecientos mil\0";
// const char* cadenax = "mil trescientos\0";
// const char* cadenax = "dos mil treinta y cinco\0";
// const char* cadenax = "cinco mil treinta y dos\0";
// const char* cadenax = "treinta y tres\0";
// const char* cadenax = "cinco mil\0";
// const char* cadenax = "veinte mil\0";
// const char* cadenax = "treinta y tres mil\0";
// const char* cadenax = "veintitres mil\0";
// const char* cadenax = "cuarenta y cinco mil quinientos\0";
// const char* cadenax = "veinticuatro mil quinientos\0";
// const char* cadenax = "veinticuatro mil quinientos veintiocho\0";
// const char* cadenax = "veinticuatro mil quinientos cuarenta y ocho\0";
// const char* cadenax = "veinticuatro mil quinientos ocho\0";
// const char* cadenax = "veinticuatro mil cien\0";
// const char* cadenax = "mil cuatrocientos cinco\0";
// const char* cadenax = "dos mil cinco\0";
// const char* cadenax = "dos mil cuarenta\0";
// const char* cadenax = "dos mil veintitres\0";
// const char* cadenax = "dos mil treinta y cinco\0";
// const char* cadenax = "cuarenta y cinco mil treinta y tres\0";
// const char* cadenax = "uno\0";
// const char* cadenax = "doscientos mil treinta y uno\0";
// const char* cadenax = "doscientos mil veintiuno\0";
// const char* cadenax = "doscientos mil uno\0";
// const char* cadenax = "ciento veinte mil\0";
// const char* cadenax = "ciento veinte mil dos\0";
// const char* cadenax = "ciento veinte mil trescientos seis\0";
// const char* cadenax = "ciento veinte mil trescientos veintisiete\0";
// const char* cadenax = "ciento veintiun mil dos\0";
// const char* cadenax = "ciento veinte mil trescientos treinta y seis\0";
// const char* cadenax = "ciento sesenta y un mil trescientos treinta y seis\0";
// const char* cadenax = "ciento sesenta y dos mil trescientos treinta y seis\0";
// const char* cadenax = "cero\0";
// const char* cadenax = "diez y nueve\0";
const char* cadenax = "diecinueve\0";

unsigned int len = strlen(cadenax);
unsigned int pos =0;
unsigned int vec_resultado[20]={0};
char str[256];
memset(str,0,sizeof(str));
for(unsigned int i=0; i<len;i++){

memset(str,0,sizeof(str));
if(cadenax[i] == ' '){

if(cadenax[i-1] == 'y') continue;

unsigned int x=1;
unsigned int j=i-1;
while(cadenax[j] != ' ' && j>0) {x++;j--;}
if(cadenax[j]==' ') {x--;j++;}
for(unsigned int l=0;l<x;l++){
str[l]=cadenax[j];
j++;
}
vec_resultado[pos++]= Equivalencia(str);
}

else if(i==(len-1)){

unsigned int x=1;
unsigned int j=i-1;
while(cadenax[j] != ' ' && j>0) {x++;j--;}
if(cadenax[j]==' ') {j++;}
else x++;
for(unsigned int l=0;l<x;l++){
str[l]=cadenax[j];
j++;
}
vec_resultado[pos++]= Equivalencia(str);
}
}

int resultado=0;
printf("Contenido del vector auxiliar: \n");
for(unsigned int k=0; (k<20&&vec_resultado[k]>0); k++) printf("%d\n",vec_resultado[k]);
int divisiones = DivisionesDeVector(vec_resultado,20);
// printf("divisiones: %d\n",divisiones);
// system("pause");

switch(divisiones){

case 1:{

resultado = vec_resultado[0];

  }break;
case 2:{

if(vec_resultado[1]>=1000)
resultado = vec_resultado[0]*vec_resultado[1];
else
resultado = vec_resultado[0]+vec_resultado[1];

  }break;
case 3:{

if(vec_resultado[0]>=1000){
resultado = vec_resultado[0]+vec_resultado[1];
resultado += vec_resultado[2];
} else
if(vec_resultado[1]>=1000){
resultado = vec_resultado[0]*vec_resultado[1];
resultado += vec_resultado[2];
} else
if(vec_resultado[2]>=1000){
resultado = vec_resultado[0]+vec_resultado[1];
resultado *= vec_resultado[2];
} else {
resultado = vec_resultado[0]*vec_resultado[1];
resultado += vec_resultado[2];
}

  }break;
case 4:{

if(vec_resultado[0]>=1000){

/* ????? */

} else
if(vec_resultado[1]>=1000){

resultado = vec_resultado[0]*vec_resultado[1];
resultado += vec_resultado[2];
resultado += vec_resultado[3];

} else
if(vec_resultado[2]>=1000){

resultado = vec_resultado[0]+vec_resultado[1];
resultado *= vec_resultado[2];
resultado += vec_resultado[3];

} else {

}

  }break;
case 5:{

if(vec_resultado[0]>=1000){

/* ????? */

} else
if(vec_resultado[1]>=1000){

resultado = vec_resultado[0]*vec_resultado[1];
resultado += vec_resultado[2];
resultado += vec_resultado[3]+vec_resultado[4];

} else
if(vec_resultado[2]>=1000){

resultado = vec_resultado[0]+vec_resultado[1];
resultado *= vec_resultado[2];
resultado += vec_resultado[3]+vec_resultado[4];

} else {

/* ????? */
}

  }break;
case 6:{

if(vec_resultado[0]>=1000){

/* ????? */

} else
if(vec_resultado[1]>=1000){

resultado = vec_resultado[0]*vec_resultado[1];
resultado += vec_resultado[2];
resultado += vec_resultado[3]+vec_resultado[4]+vec_resultado[5];

} else
if(vec_resultado[2]>=1000){

resultado = vec_resultado[0]+vec_resultado[1];
resultado *= vec_resultado[2];
resultado += vec_resultado[3]+vec_resultado[4]+vec_resultado[5];

} else {

/* ????? */
}

  }break;

case 7:{

if(vec_resultado[0]>=1000){

/* ????? */

} else
if(vec_resultado[1]>=1000){

resultado = vec_resultado[0]*vec_resultado[1];
resultado += vec_resultado[2];
resultado += vec_resultado[3]+vec_resultado[4]+vec_resultado[5]+vec_resultado[6];

} else
if(vec_resultado[2]>=1000){

resultado = vec_resultado[0]+vec_resultado[1];
resultado *= vec_resultado[2];
resultado += vec_resultado[3]+vec_resultado[4]+vec_resultado[5]+vec_resultado[6];

} else
if(vec_resultado[3]>=1000){

resultado = vec_resultado[0]+vec_resultado[1];
resultado += vec_resultado[2];
resultado *= vec_resultado[3];
resultado += vec_resultado[4]+vec_resultado[5]+vec_resultado[6];

} else {

/* ????? */
}

  }break;
}

printf("\n");
printf("resultado: %d\n",resultado);

while(getchar()!='\n');
return 0;
}

#7
Programación C/C++ / Argumentos Variables
30 Abril 2012, 19:44 PM
Hola, en este post voy a mostrar como se puede crear una función tipo 'printf' la cual puede recibir una cantidad de argumentos variables..
Para poder hacer eso se usa el archivo header llamado stdarg.h que trae algunas declaraciones y definiciones para este usar ante esta situación.

La idea fue tomada de un código público por lo tanto no es mi código.. pero si me pareció buena la idea de dar un ejemplo así para tenerlo en cuenta.

Dejo el proyectín para descargarlo
Proyecto en MSVC+++ 6.0


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// UTN FRGP TSP
// 2012
// BS
// Etalking.Com.Ar
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <stdio.h>
#include "stdarg.h" // defines ANSI-style macros for variable argument functions

void PrintString(const char* fmt, ... )
{
va_list va_alist;
char buf[256];
va_start (va_alist, fmt);
_vsnprintf (buf, sizeof(buf), fmt, va_alist);
va_end (va_alist);

printf(buf);
}

int main()
{
char* cadena1 = "\nSola.. Vino a.. mi Ficcion..\0";
char* cadena2 = "\nSin Dudar.. Acompaniarme..\0";
char* cadena_a = "\nCerca.. de su.. Atraccion..\0";
char* cadena_b = "\nTropiezo.. con mis Manos..\0";
int a = 2012;

PrintString("%s%s\n", cadena1,cadena2);

PrintString("\n");

PrintString("%s%s\n", cadena_a,cadena_b);

PrintString("\n");

PrintString("%d\n", a);

PrintString("\n");

PrintString("Presione ENTER para Salir");

while(getchar() != '\n');
return 0;
}


S2


#8
Programación C/C++ / Recursividad
19 Abril 2012, 05:47 AM
Hola, hice un programita tonto que utiliza una función recursiva, solamente para mostrar algunos detalles..

El programa se trata de tener un texto que debe ser superior a los 168 caracteres, ya sea en un array o para ser ingresado, luego el texto debe ser manejado por un puntero char* y debe ser examinado por una función recursiva.

con un sólo llamado a la función recursiva en el main, se debe poder obtener ciertos datos del texto.

1) cantidad de letras
2) cantidad de vocales
3) cantidad de consonantes
4) cantidad de espacios

El programa requiere el uso de aritmética de punteros como van a ver en el código.

además esta técnica es dependiente de un vector declarado como 'static' para que no cambie su dirección en memoria y pueda ser accesible durante todo el programa.

dejo el código a continuación..

Este sería el texto contenido en un array

char texto[200] = {


'a','s','d','x','x','x','x','x','x','x',
'x','a','s','d','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x',' ','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x',0};


Esta es la función recursiva. devuelve un puntero a vector int de 4.
El número 4 hace referencia a los 4 resultados que debemos obtener del texto.

int* arreglo_final_re(char* str, char letra){

static int vec[4]={0};
int estado=0;
if(*str!=NULL){
if(*str==letra) estado=1;
if((*str=='a')||(*str=='e')||(*str=='i')||(*str=='o')||(*str=='u')) estado=2;
if((*str!='a')&&(*str!='e')&&(*str!='i')&&(*str!='o')&&(*str!='u')) estado=3;
if(*str==' ') estado=4;
str++;
for(unsigned int i=1; i<=estado;i++){
if(estado==3&&i==2)continue;
if(estado==4&&(i==2||i==3))continue;
vec[i-1]++;
}

//arreglo_final_re(str,letra);//esto dejaria en la pila varios ret+address los cuales deben popearse luego..
return arreglo_final_re(str,letra);
}

printf("----------------------------------------\n");
printf("cantidad letras: %d\n",vec[0]);
printf("cantidad vocales: %d\n",vec[1]);
printf("cantidad consonantes: %d\n",vec[2]);
printf("cantidad blancos: %d\n",vec[3]);
printf("----------------------------------------\n");
printf("----------------------------------------\n");
printf("Direccion del vector static: %x\n",vec);
printf("----------------------------------------\n");

return &vec[0];

}


Este sería el punto de entrada del programa

int main(){

char* t = texto;
printf("Texto: %s\n",t);
printf("----------------------------------------\n");

int* p =arreglo_final_re(t,'x');
printf("----------------------------------------\n");
printf("Direccion rescatada desde el Main: %x\n",p);
printf("----------------------------------------\n");
printf("Letras: %d\n",*(p+0));
printf("Vocales: %d\n",*(p+1));
printf("Consonantes: %d\n",*(p+2));
printf("Blancos: %d\n",*(p+3));
printf("----------------------------------------\n");

system("pause");
return 0;
}



dejo el proyecto en MSVC++ 6.0 por si lo desean descargar

Proyecto




#9
Hola, estaba probando mis funciones atol e ltoa personalizadas, y las puse a prueba con un programa win32 con GUI que es un convertidor básico de decimal a binario y viceversa. Voy a dejar el código del proyecto en MSVC++ 6.0 que incluye el .h con las funciones que dije.

Proyecto

y dejo el winmain.cpp a la vista para notar los cambios con mi anterior publicación para winapi32 GUI

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//
// UTN FRGP
// 2012
// David Riedel
// 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>
#include <stdio.h>
//gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib

#include "ansii_conversions.h"
#include "convertir.h"

/////////////////////////
// Globales

HWND EditControl1;
//HWND EditControl2;
//HWND EditControl3;
HWND ListControl1;
HWND ListControl2;
HWND StaticControl1;
HWND CheckBoxControl1;
HWND CheckBoxControl2;

const int ID_EDIT1=1, ID_LIST1=2, ID_CHECK1=3, ID_CHECK2=4;
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 1 número");

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;

unsigned long editstyle =WS_CHILD|WS_VISIBLE|WS_BORDER|WS_TABSTOP;
unsigned long liststyle =WS_CHILD|WS_VISIBLE|WS_BORDER|WS_TABSTOP| LBS_NOTIFY;

int offs = 30;
int X=20;
int Y=10;
int W=200;
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+63,
H,
hWin,
(HMENU)ID_EDIT1,
NULL,
NULL);

ListControl1 = CreateWindow( TEXT("listbox"),
                        NULL,
liststyle,
X,
Y+20+(offs*1),
W+63,
H-5,
hWin,
(HMENU)ID_LIST1,
NULL,
NULL);

CheckBoxControl1 = CreateWindow( TEXT("button"),
                        "BinToDec",
WS_VISIBLE | WS_CHILD  | BS_CHECKBOX |BS_AUTOCHECKBOX,
X+160,90,84,20,
hWin,
(HMENU)ID_CHECK1,
NULL,
NULL);

CreateWindow( TEXT("button"),
         TEXT("Convertir"),
 EstiloHijo1,
 X,90,80,H,
 hWin,
 (HMENU) ID_OK,
 NULL,
 NULL);

CreateWindow( TEXT("button"),
         TEXT("Salir"),
 EstiloHijo1,
 X+100,90,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);

SetFocus(EditControl1);
}
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 ) );
BOOL checked = IsDlgButtonChecked(hWin, ID_CHECK1);
int l=strlen(chBuffer1);
if( (checked&&!EsBin(chBuffer1))  ||  (!checked&&!EsDec(chBuffer1))) {
MessageBox(0,"Errores de ingreso!","Convertidor",0);
return FALSE;
}
if(l<1){
MessageBox(0,"Ingrese algo!","Convertidor",0);
return FALSE;
}
long l_res_pre;
l_res_pre = mi_atoi(chBuffer1);
long l_res;
if(!checked) l_res = Bin(l_res_pre,2,10);//dec a bin
else l_res = Bin(l_res_pre,10,2);//bin a dec
char* ch_res = mi_ltoa(l_res,ch_res);
SendDlgItemMessage(hWin, ID_LIST1, LB_RESETCONTENT, 0, 0);
int nNum=0;
char* buf1 = (char*)GlobalAlloc(GPTR,strlen(ch_res)+1);
strcpy(buf1, ch_res);
free(ch_res);
int index1 = SendDlgItemMessage(hWin, ID_LIST1, LB_ADDSTRING, 0, (LPARAM)buf1);
SendDlgItemMessage(hWin, ID_LIST1, LB_SETITEMDATA, (WPARAM)index1, (LPARAM)nNum);
GlobalFree((HANDLE)buf1);
}
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 mb=0;
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE h0, LPSTR lpCmdLine, int nCmdShow){

HWND hWin;
WNDCLASS wc = {0};

RegistrarClaseVentana(&wc);

int ancho=300;
int alto=156;
int dim[2];
getCentradoGlobal(dim, ancho, alto);

unsigned long Estilo1 = WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;

hWin = CreateWindow( wc.lpszClassName,
                "Convertidor a Binario",
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) {
if(!mb) {
 MessageBox(hWin, "By BS","Convertidor a Binario",MB_OK);
 mb=1;
}
if (!IsDialogMessage(hWin, &msg)) {
 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;
}

//===


Prueben el convertidor XD aver si anda bien. La meta es hacerlo un convertidor de otros sistemas también, por ejemplo hexadecimal y octal. pero como se trata de algo didáctico para mi, me da lo mismo

por cierto la función conversora es esta, creo que en google aparece enseguida..

unsigned long Bin(unsigned long n1,int base1,int base2)
{
unsigned long alg,mult=1,n2=0;
while(n1 > 0) {
alg = n1 % base1;
n1 /= base1;
n2 += (alg*mult);
mult *= base2;
}
return n2;
}


Salu2
#10
MODIFICADO:


ATOI
Código (cpp) [Seleccionar]

/********************************************************************************************************

// By 85
// boyscout_arg@hotmail.com
// etalking.com.ar
// David Riedel
// 2013

*********************************************************************************************************/

#pragma warning (disable:4305)
#pragma warning (disable:4309)
#pragma warning (disable:4244)
#pragma warning (disable:4018)
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>

/////

// Sin necesidad de llamadas innecesarias a funciones de CTYPE, MATH, STRING, etc
// Sin necesidad de Tablas, solo un array con los números enteros que tampoco es necesario
// pero no hace la gran diferencia ;-D

//////////////////////////////////////////////////

//Se requiere pasar una cadena terminada en CERO!.
//Si no se le pasa una cadena terminada en CERO, la función va a buscar el
//primer 0 que encuentre y puede terminar en una sección de memoria contigua
//que no pertenece a la cadena pasada como parámetro.
int mi_atoi(const char* str)//Respetar el tipo de parámetro (Sólo cadenas)
{
int len, ocurrencias =0, sig=0;
for(len=0; str[len]; len++);
for(int a=0; a<len;a++) if((str[a]>=48&&str[a]<=57)) ocurrencias++;
if(ocurrencias==0) return 0;
if((sig=str[0]=='+')||(sig=str[0]=='-')) ocurrencias+=1;
if(ocurrencias<len) return 0;//Casos "11f" son 0
if(len==1) return str[0]-'0';
int ac=0, v1, cifras = len,m = 1;
for(int x=0;x<((cifras-1)-sig);x++) m*=10;
for(int i=sig;i<cifras;i++){//Factoriza y acumula
v1=str[i]-'0';
v1*=m;
ac=(v1==0?ac+0:ac+v1);
m/=10;
}
if(str[0]=='-') ac*=-1;
return ac;
}

////////////////////

int main(){

// char str = 'B';
// int entero = mi_atoi(&str);

// char* str = "asdasd\0";
// int entero = mi_atoi(str);

// char* str = "8a3\0";
// int entero = mi_atoi(str);

// char* str = "83312321\0";
// int entero = mi_atoi(str);

// char* str = "000000099\0";
// int entero = mi_atoi(str);

// char* str = "9\0";
// int entero = mi_atoi(str);

// char* str = "20\0";
// int entero = mi_atoi(str);

// char* str = "500\0";
// int entero = mi_atoi(str);

// char* str = "+500\0";
// int entero = mi_atoi(str);

// char* str = "0500\0";
// int entero = mi_atoi(str);

// char* str = "0\0";
// int entero = mi_atoi(str);

// char* str = "10f\0";
// int entero = mi_atoi(str);

// char* str = "01ff\0";
// int entero = mi_atoi(str);

// char* str = "0f\0";
// int entero = mi_atoi(str);

// char* str = "+12\0";
// int entero = mi_atoi(str);

// char* str = "+12\0";
// int entero = mi_atoi(str);

// char* str = "03232\0";
// int entero = mi_atoi(str);

// printf("%d", entero);


printf("%d\n",mi_atoi("-110"));
printf("%d\n",mi_atoi("-10"));
printf("%d\n",mi_atoi("0"));
printf("%d\n",mi_atoi("1"));
printf("%d\n",mi_atoi("-1"));
printf("%d\n",mi_atoi("-11"));
printf("%d\n",mi_atoi("-2"));
printf("%d\n",mi_atoi("-200"));
printf("%d\n",mi_atoi("-220"));
printf("%d\n",mi_atoi("+0"));
printf("%d\n",mi_atoi("-0"));
printf("%d\n",mi_atoi("+1"));
printf("%d\n",mi_atoi("+33"));
printf("%d\n",mi_atoi("-330"));
printf("%d\n",mi_atoi("-3000"));
// printf("%d\n",mi_atoi("-1"));
// printf("%d\n",mi_atoi("-200"));
// printf("%d\n",mi_atoi("-220"));
printf("%d\n",mi_atoi("+12"));

printf("\n");
system("pause");
return 0;
}


ITOA
Código (cpp) [Seleccionar]

/********************************************************************************************************

// By 85
// boyscout_arg@hotmail.com
// etalking.com.ar
// David Riedel
// 2013

*********************************************************************************************************/

#pragma warning (disable:4305)
#pragma warning (disable:4309)
#pragma warning (disable:4244)
#pragma warning (disable:4018)
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>

/////

// Sin necesidad de llamadas innecesarias a funciones de CTYPE, MATH, STRING, etc
// Sin necesidad de Tablas, sólo un array con los números enteros que tampoco es necesario
// pero no hace la gran diferencia ;-D

//////////////////////////////////////////////////

char* mi_itoa(int num, char* str)
{
int sig = -1;
if(num<0){
num*=-1;
if(num<10){
str[0]='-'; str[1]='0'+num; str[2]=0; return str;
} else {
sig=1;
}
}
else if(num==0){
str[0]='0'; str[1]=0; return str;
} else {
if(num<10){
str[0]='0'+num; str[1]=0; return str;
} else {
sig=0;
}
}
if(sig!=-1){
int copia= num, m = 1, cifras = 1;
for(;copia>=10;copia/=10) cifras++;
for(int x=0;x<(cifras-1);x++) m*=10;
float v1=num;
int v2=0, v3=num;
if(sig) str[0]='-';
for(int i=0; i<cifras; i++){//Descompone en factores
v1/=m;
v2=(int)v1*m;
v3-=v2;
m/=10;
str[i+sig]=48+(int)v1;
v1=v3;
}
str[i+sig]=0;//Si str está a 0 no es necesario..
}
return str;
}

///////////////////

int main(){


char str[256];

// mi_itoa(321312,str);
// printf(str);

// itoa(02321,str,10);
// printf(str);

// mi_itoa(02321,str);
// printf(str);

// mi_itoa(-12321,str);
// printf(str);

// itoa(-012321,str,10);
// printf(str);

// mi_itoa(-012321,str,10);
// printf(str);

// mi_itoa(555,str);
// printf(str);

// mi_itoa(0,str);
// printf(str);

// mi_itoa(1,str);
// printf(str);

// mi_itoa(500,str);
// printf(str);

printf(mi_itoa(+321312,str));printf("\n");
printf(mi_itoa(-321312,str));printf("\n");
printf(mi_itoa(321312,str));printf("\n");
printf(mi_itoa(+0,str));printf("\n");
printf(mi_itoa(0,str));printf("\n");
printf(mi_itoa(-0,str));printf("\n");
printf(mi_itoa(+1,str));printf("\n");
printf(mi_itoa(1,str));printf("\n");
printf(mi_itoa(-1,str));printf("\n");
printf(mi_itoa(10,str));printf("\n");
printf(mi_itoa(+10,str));printf("\n");
printf(mi_itoa(-10,str));printf("\n");
printf(mi_itoa(-110,str));printf("\n");
printf(mi_itoa(-100,str));printf("\n");

printf(mi_itoa(-5000,str));printf("\n");
printf(mi_itoa(-55555,str));printf("\n");
printf(mi_itoa(550,str));printf("\n");
printf(mi_itoa(500,str));printf("\n");
printf(mi_itoa(+330,str));printf("\n");

printf(mi_itoa(-000,str));printf("\n");
printf(mi_itoa(+000,str));printf("\n");
// printf(mi_itoa(+00009,str));printf("\n");
printf(mi_itoa(+109,str));printf("\n");
printf(mi_itoa(-109,str));printf("\n");
// printf(mi_itoa(-09,str));printf("\n");
// printf(mi_itoa(+09,str));printf("\n");
printf(mi_itoa(-999,str));printf("\n");
// printf(mi_itoa(-00000999,str));printf("\n");

printf("\n");
system("pause");
return 0;
}

/////


#11

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 C/C++ / Operadores de bits
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.

Citar
&        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.html

Só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 */
   

OR | 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 */


XOR ^ 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 */




Complemento de uno ( es unario (require un operando))
======================================

NOT ~ tiene el efecto de invertir bits.

unsigned int Valor=4;          /*   4 = 0000 0100 */
Valor = ~ Valor;               /* 251 = 1111 1011 */




Cambio de bits
============

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

Citar
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
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);



Punto de entrada del programa

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


Proyecto MSVC++ 6.0

Que sigan bien ;-D
#14
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;
}



Proyecto MSVC++ 6.0
#15

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;
}


Proyecto en MSVC++ 6.0

#16

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;
}


Proyecto
http://www.mediafire.com/?r42y1f6l6yoeju9

#17
Un proyecto de un programa básico con interfáz gráfica de Windows. Está hecho con MSVC++ 6.0

proyecto
http://www.mediafire.com/?yd4vpb42j4p1pi6

winmain.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;
}


#18
Programación C/C++ / notación polaca inversa
31 Marzo 2012, 19:26 PM
un programita hecho en c, procesa una ecuación usando RPN.

debería funcionar en linux.

http://www.mediafire.com/?6d3vrtgzy22vly7




#19

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 C/C++ / processar matrices
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

#21
En este código muestro como leer una matríz global de tipo char por medio de una función de tipo char**. una matriz y un array de cadenas son cosas diferentes pero pueden arreglarse para usarse como si fueran lo mismo.

El código básicamente trae dos formas de hacer esto, en la primera hay dos funciones, una que carga elementos en la matríz y la otra hace un arreglo para poder leerla luego en el 'main'

No tiene mucho sentido usar una matríz global pero para hacer una demostración sirve. yo estaba tratando de usar algo como esto para una matríz de char que es miembro de una clase...

En el main así como está puede leerse sólo el primer elemento, se puede modificar para leer todos automáticamente, pero eso no es parte del tema

El título tampoco parece ser la mejor explicación de esto igualmente..


//---------------------------------------------

char MATRIX[6][6];//global

//---------------------------------------------------

char** CargarItems1(){

for(int i=0; i<6;i++){

strcpy(MATRIX[i], "12345");
}

return (char**)&MATRIX[0][0];
}

char* LeerItems1(int pos_vec){

DWORD* vecofvectors = (DWORD*)CargarItems1();
return *(char**)vecofvectors+(pos_vec*6);
}

//-----------------------------------

DWORD* CargarItems2(){

for(int i=0; i<6;i++){

strcpy(MATRIX[i], "12345");
}
return (DWORD*)&MATRIX[0][0];
}

char* LeerItems2(int pos_vec){

DWORD* vecofvectors = CargarItems2();
       return (char*)vecofvectors+(pos_vec*6);
}

//---------------------------------------------------------

int main()
{
        int pos=0; // de 0 a 5
        char* vec_de_matrix = LeerItems(pos);
        //char* vec_de_matrix = LeerItems2(pos);

        MessageBox(0,vec_de_matrix,"ASD",0);

system("pause");
return 0;
}


Saludos