Mensajes

claro el error era el mismo nombre de la clase o struct con el del registro o variable. Ahora deberías usar extern con esa variable que decís también.

struct.h
extern int ObjetosTotales;


main.cpp
int ObjetosTotales = 0;


como ves, la asignación de valor no se incluye cuando se usa 'extern'.

el objeto debe ser declarado antes de usar 'extern'.
declaralo en algún archivo .cpp que incluya el acceso a la clase o struct.
después podés usar así:

Código [Seleccionar] Expandir

extern Objeto objeto[5000];

en otros archivos, para referenciar a un objeto existente en otro archivo.

pero en la declaración no se puede hacer esto:

Código [Seleccionar] Expandir

Objeto Objeto[5000];

tiene el mismo nombre que la clase o struct, por eso ponelo así:
Objeto objeto[5000];

dahh le pusiste el mismo nombre que la clase? no se puede eso

Código [Seleccionar] Expandir

Objeto objeto[5000];

ponelo así, ves la minúscula en el nombre?

tenés que declararlo en algún archivo .cpp y luego en algún archivo de inclusión .h lo ponés como extern.
Esto significa que cuando el objeto se use en un archivo.cpp se hace una referencia al objeto que fue declarado en otro archivo .cpp.

dejá la anterior y borrá la otra. No se puede las 2

[extern struct Objeto Objeto[5000];]

Borrá esta línea

#include "header.h"
#include "struct.h"

using namespace std;

extern struct Objeto Objeto[5000];

int Comprobar(){
   if(Objeto[ObjetosTotales].modelo == 69){
      return 1;}

   return 0;
}

Es raro que le hayan dicho que no puede usar arrays, structs, asignación dinámica, punteros, etc
le queda usar 10 variables enteras, o eso que hiciste mr.blood que para listar ya tiene el número dentro del string. Si fuera que son números del 0 al 9.
Ese profesor debe ser cualquiera para requerir estas cosas.. o se trata de un curso de ingreso o algo

Si lo que te dijeron, importante la convención de llamada para determinar como se maneja el RETURN. La cantidad y tipo de los parámetros, eso lo verás si te resulta posible en un desensamblador y para el tipo lo mejor sería que puedas ver la pila (en el depurador) en el momento que es llamada la función, sería la mejor idea. Si ya tenés el prototipo de la función, entonces tan sólo te construís un puntero a función y lo llamás, si es que para vos se arregla tan sólo llamando a esa función.
El código si lo ejecutás en tu DLL, de otra forma podés considerar interceptar alguna función que te interese para que puedas ejecutar tu código.
Son ideas. También puede usar ASM en línea en C.

gracias por tu trabajo , se nota que hubo dedicación. En algún momento se que voy a leer las notas al respecto en tu blog. Sobre la utilidad, vistes esos programas como son Armadillo o más conocido es el Winlicense, que utiliza una vm y tiene opciones como virtualizar instrucciones en el entrypoint y otras opciones más, eso me parece más interesante , como se puede orientar a la seguridad de una aplicación. Seguridad contra lo que llama ingeniería inversa, a eso me refiero

[MODIFICADO]

Estaba mirando este topic
http://foro.elhacker.net/programacion_cc/es_posible_hacer_esto_sin_arreglos-t385430.0.html
y se me ocurrió una idea, ya que había dicho chistosamente que se puede resolver con 10 variables, lo cual es cierto pero nunca se trata de usar tantas variables.

Lo que se me ocurrió es utilizar el mismo problema y utilizar las 10 variables
para resolverlo, pero usando aritmética de punteros.

El tema es que en realidad me propuse no usar variables de tipo puntero sino variables simples que guarden valores, en este caso, variables enteras.

una variable ocupa un espacio y tiene una dirección de memoria, eso lo sabemos todos. también sabemos que una variable almacena un valor.
pero ese valor puede ser una dirección de memoria también, tal como
los punteros.

Por eso en este topic voy a mostrar como hacer que con variables simples podamos tratarlas como punteros, obviamente sin usar variables de tipo puntero.

Esto se me ocurrió llamarlo "Pseudopunteros" porque en realidad no son variables de puntero.

En realidad no hay ninguna necesidad de hacer esto, ya que el lenguaje
nos da las variables de puntero para hacer esto. Pero ya que es posible
me parece correcto dejar en claro como se puede hacer.

Tampoco estoy seguro si el término "pseudopunteros" sea el correcto,
estuve buscando por google acerca de esta expresión pero sólo sale
algo relacionado a objetos.

por ejemplo:
http://www.ehow.com/info_11400371_difference-between-static-method-class-method.html
http://users.auth.gr/users/6/9/076096/public_html/courses/DataStructures/Implementations.html

pero no hablan de ninguna definición formal, por lo tanto me parece bien llamar a estas variables así XD.

El problema se trata de ingresar 10 números, listarlos, y decir cuáles se
repitieron y cuántas veces.

Para eso vamos a usar 10 variables enteras, que se van a almacenar en forma una seguida de la otra. Vamos a tomar en cuenta para este ejemplo que un entero son 4 BYTES. y con eso vamos al código directamente:

MODIFICADO
Como no se puede garantizar que las variables locales se almacenen de forma contigua en memoria o en un orden determinado (especificaciones de C++), y por el hecho de que los tamaños de los tipos de datos y de las direcciones de memoria no son iguales en diferentes sistemas (ej: x64), se hicieron algunas modificaciones en el código de la demostración.
No se tomaron en cuenta todos los tipos de datos tampoco porque para la demostración tampoco era necesario.

main.cpp

Código (cpp) [Seleccionar] Expandir

//
// By 85
// elhacker.net
// etalking.com.ar
// boyscout_arg@hotmail.com
// 2013
//

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

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

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

void Test1();
void Test2();
void Test3();

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

int main(){

system("cls");
printf("Test1:\n");
Test1();
system("pause");

system("cls");
printf("Test2:\n");
Test2();
system("pause");

system("cls");
printf("Test3:\n");
Test3();
system("pause");

return 0;
}

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

pseudopointers1.cpp

Código (cpp) [Seleccionar] Expandir



//
// By 85
// elhacker.net
// etalking.com.ar
// boyscout_arg@hotmail.com
// 2013
//

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

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <typeinfo>

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

// No tenemos garantía de que sean almacenadas contiguamente!
static int entrada1=0;//entrada1+0x0
static int entrada2=0;//entrada1+0x4
static int entrada3=0;//entrada1+0x8
static int entrada4=0;//entrada1+0xC
static int entrada5=0;//entrada1+0x10
static int entrada6=0;//entrada1+0x14
static int entrada7=0;//entrada1+0x18
static int entrada8=0;//entrada1+0x1C
static int entrada9=0;//entrada1+0x20
static int entrada10=0;//entrada1+0x24

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

void Test1(){
/*
////////////////////////////////////
// Basic check (Designed for 10 variables no more)

//int entrada10=0;// Hacerlo cagar XD
printf("Estas direcciones deben estar en forma contigua!\n");
printf("0x%X\n",&entrada1);
printf("0x%X\n",&entrada2);
printf("0x%X\n",&entrada3);
printf("0x%X\n",&entrada4);
printf("0x%X\n",&entrada5);
printf("0x%X\n",&entrada6);
printf("0x%X\n",&entrada7);
printf("0x%X\n",&entrada8);
printf("0x%X\n",&entrada9);
printf("0x%X\n",&entrada10);
int flag_exit=0;
if( ((&entrada2)-((&entrada1)+0x1)) !=0){flag_exit=1; goto error;}
if( ((&entrada3)-((&entrada2)+0x1)) !=0){flag_exit=2; goto error;}
if( ((&entrada4)-((&entrada3)+0x1)) !=0){flag_exit=3; goto error;}
if( ((&entrada5)-((&entrada4)+0x1)) !=0){flag_exit=4; goto error;}
if( ((&entrada6)-((&entrada5)+0x1)) !=0){flag_exit=5; goto error;}
if( ((&entrada7)-((&entrada6)+0x1)) !=0){flag_exit=6; goto error;}
if( ((&entrada8)-((&entrada7)+0x1)) !=0){flag_exit=7; goto error;}
if( ((&entrada9)-((&entrada8)+0x1)) !=0){flag_exit=8; goto error;}
if( ((&entrada10)-((&entrada9)+0x1)) !=0){flag_exit=9; goto error;}
error:
if(flag_exit>0){
printf("It seems they are not stored contiguously. Error %d\n", flag_exit);
system("pause");
return;
}*/

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

#define XPOINTERTYPE unsigned long
#define XVARTYPE int
//if(sizeof(XVARTYPE) != sizeof(entrada1)) return;
unsigned char OFFS = (unsigned char)sizeof(XVARTYPE);// Up to 255
XPOINTERTYPE entradaX=(XPOINTERTYPE)&entrada1;// Una especie de puntero THIS
XPOINTERTYPE inicio_bloque=(XPOINTERTYPE)&entrada1;
XPOINTERTYPE fin_bloque=(XPOINTERTYPE)&entrada10;
int rep = 0;
const int MAX_NUMB =10;
char* format;
if(!strcmp(typeid(XVARTYPE).name(), "int")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "long")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "long int")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "long long")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned long")) format="%X";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned int")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned short")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "float")) format="%f";
else if(!strcmp(typeid(XVARTYPE).name(), "double")) format="%f";
else if(!strcmp(typeid(XVARTYPE).name(), "double long")) format="%f";
else if(!strcmp(typeid(XVARTYPE).name(), "long double")) format="%f";
else return;

for(int i=0;i<MAX_NUMB;i++)
{
printf("Introduzca un número\n");
scanf(format,(XPOINTERTYPE*)entradaX);

rep=0;
XPOINTERTYPE apuntador1=(XPOINTERTYPE)&entradaX;//Doble puntero

for(XPOINTERTYPE j=inicio_bloque;j<(inicio_bloque+(OFFS*i));j+=OFFS)
{
XPOINTERTYPE apuntador2=(XPOINTERTYPE)&j;//Doble puntero

if(**(XVARTYPE**)apuntador1 == **(XVARTYPE**)apuntador2){
rep++;
}
}

if(rep)
{
char* info;
if(!strcmp(typeid(XVARTYPE).name(), "int")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long int")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long long")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned long")) info="%X had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned int")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned short")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "float")) info="%f had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "double")) info="%f had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "double long")) info="%f had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long double")) info="%f had %d repetitions\n";
printf(info,**(XVARTYPE**)apuntador1,rep);
//while(getchar()!='\n');
system("pause");
}

entradaX+=OFFS;
}
entradaX=(XPOINTERTYPE)&entrada1;//Arreglar el pseudopuntero THIS

for(int k=1;k<=MAX_NUMB;k++)
{
printf(format,*(XVARTYPE*)entradaX);

entradaX+=OFFS;
}
printf("\n");
entradaX=(XPOINTERTYPE)&entrada1;//Arreglar el pseudopuntero THIS
}

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


pseudopointers2.cpp

Código (cpp) [Seleccionar] Expandir


//
// By 85
// elhacker.net
// etalking.com.ar
// boyscout_arg@hotmail.com
// 2013
//

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

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <typeinfo>

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

// Vamos a usar un array para asegurarnos de que los 10 enteros
// sean almacenados de forma contigua.
static int entradas[10] = {0};

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

void Test2(){

#define XPOINTERTYPE unsigned long
#define XVARTYPE int
//if(sizeof(XVARTYPE) != sizeof(entradas[0])) return;
unsigned char OFFS = (unsigned char)sizeof(XVARTYPE);// Up to 255
XPOINTERTYPE entradaX=(XPOINTERTYPE)&entradas[0];// Una especie de puntero THIS
XPOINTERTYPE inicio_bloque=(XPOINTERTYPE)&entradas[0];
XPOINTERTYPE fin_bloque=(XPOINTERTYPE)&entradas[9];
int rep = 0;
const int MAX_NUMB =10;
char* format;
if(!strcmp(typeid(XVARTYPE).name(), "int")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "long")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "long int")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "long long")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned long")) format="%X";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned int")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned short")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "float")) format="%f";
else if(!strcmp(typeid(XVARTYPE).name(), "double")) format="%f";
else if(!strcmp(typeid(XVARTYPE).name(), "double long")) format="%f";
else if(!strcmp(typeid(XVARTYPE).name(), "long double")) format="%f";
else return;

for(int i=0;i<MAX_NUMB;i++)
{
printf("Introduzca un número\n");
scanf(format,(XPOINTERTYPE*)entradaX);

rep=0;
XPOINTERTYPE apuntador1=(XPOINTERTYPE)&entradaX;//Doble puntero

for(XPOINTERTYPE j=inicio_bloque;j<(inicio_bloque+(OFFS*i));j+=OFFS)
{
XPOINTERTYPE apuntador2=(XPOINTERTYPE)&j;//Doble puntero

if(**(XVARTYPE**)apuntador1 == **(XVARTYPE**)apuntador2){
rep++;
}
}

if(rep)
{
char* info;
if(!strcmp(typeid(XVARTYPE).name(), "int")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long int")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long long")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned long")) info="%X had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned int")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned short")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "float")) info="%f had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "double")) info="%f had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "double long")) info="%f had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long double")) info="%f had %d repetitions\n";
printf(info,**(XVARTYPE**)apuntador1,rep);
//while(getchar()!='\n');
system("pause");
}

entradaX+=OFFS;
}
entradaX=(XPOINTERTYPE)&entradas[0];//Arreglar el pseudopuntero THIS

for(int k=1;k<=MAX_NUMB;k++)
{
printf(format,*(XVARTYPE*)entradaX);

entradaX+=OFFS;
}
printf("\n");
entradaX=(XPOINTERTYPE)&entradas[0];//Arreglar el pseudopuntero THIS
}

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


pseudopointers3.cpp

Código (cpp) [Seleccionar] Expandir


//
// By 85
// elhacker.net
// etalking.com.ar
// boyscout_arg@hotmail.com
// 2013
//

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

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <typeinfo>

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

// Vamos a usar una estructura para asegurarnos de que los 10 enteros
// sean almacenados de forma contigua.
struct Entradas{
int a,b,c,d,e,f,g,h,i,j;
};

static struct Entradas entradas;

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

void Test3(){

#define XPOINTERTYPE unsigned long
#define XVARTYPE int
//if(sizeof(XVARTYPE) != sizeof(entradas.a)) return;
unsigned char OFFS = (unsigned char)sizeof(XVARTYPE);// Up to 255
XPOINTERTYPE entradaX=(XPOINTERTYPE)&entradas.a;// Una especie de puntero THIS
XPOINTERTYPE inicio_bloque=(XPOINTERTYPE)&entradas.a;
XPOINTERTYPE fin_bloque=(XPOINTERTYPE)&entradas.j;
int rep = 0;
const int MAX_NUMB =10;
char* format;
if(!strcmp(typeid(XVARTYPE).name(), "int")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "long")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "long int")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "long long")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned long")) format="%X";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned int")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned short")) format="%d";
else if(!strcmp(typeid(XVARTYPE).name(), "float")) format="%f";
else if(!strcmp(typeid(XVARTYPE).name(), "double")) format="%f";
else if(!strcmp(typeid(XVARTYPE).name(), "double long")) format="%f";
else if(!strcmp(typeid(XVARTYPE).name(), "long double")) format="%f";
else return;

for(int i=0;i<MAX_NUMB;i++)
{
printf("Introduzca un número\n");
scanf(format,(XPOINTERTYPE*)entradaX);

rep=0;
XPOINTERTYPE apuntador1=(XPOINTERTYPE)&entradaX;//Doble puntero

for(XPOINTERTYPE j=inicio_bloque;j<(inicio_bloque+(OFFS*i));j+=OFFS)
{
XPOINTERTYPE apuntador2=(XPOINTERTYPE)&j;//Doble puntero

if(**(XVARTYPE**)apuntador1 == **(XVARTYPE**)apuntador2){
rep++;
}
}

if(rep)
{
char* info;
if(!strcmp(typeid(XVARTYPE).name(), "int")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long int")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long long")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned long")) info="%X had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned int")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "unsigned short")) info="%d had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "float")) info="%f had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "double")) info="%f had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "double long")) info="%f had %d repetitions\n";
else if(!strcmp(typeid(XVARTYPE).name(), "long double")) info="%f had %d repetitions\n";
printf(info,**(XVARTYPE**)apuntador1,rep);
//while(getchar()!='\n');
system("pause");
}

entradaX+=OFFS;
}
entradaX=(XPOINTERTYPE)&entradas.a;//Arreglar el pseudopuntero THIS

for(int k=1;k<=MAX_NUMB;k++)
{
printf(format,*(XVARTYPE*)entradaX);

entradaX+=OFFS;
}
printf("\n");
entradaX=(XPOINTERTYPE)&entradas.a;//Arreglar el pseudopuntero THIS
}

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


--------------------------------------------------------------------------
EXPLICACIÓN ANTERIOR
--------------------------------
Explico algunas cosas:

Considerando las 10 variables como un bloque de memoria de 10 * 4 BYTES, vamos a guardar la dirección de memoria de comienzo de bloque y la de fin.

Código (cpp) [Seleccionar] Expandir

int inicio_bloque=(int)&entrada1;
int fin_bloque=(int)&entrada10;

Esta variable guarda la dirección de memoria de la primer variable que
guarda el primer número. Esta variable es como un puntero THIS por así
decirlo, porque se desplaza a lo largo del bloque de 10 variables,
es decir va cambiando su valor al de la dirección de cualquier de las
10 variables enteras. Por lo tanto no tengo drama en llamarla "pseudopuntero" THIS XD.

Código (cpp) [Seleccionar] Expandir

int entradaX=(int)&entrada1;

Para ingresar 10 números hacemos 10 ciclos, pero el scanf guarda el dato
en la dirección contenida en la variable entradaX. Noten el 'casting', para
que scanf sepa que se trata de un puntero.

Código (cpp) [Seleccionar] Expandir

for(int i=0;i<MAX_NUMB;i++)
{
printf("Introduzca un numero\n");
scanf("%d",(int*)entradaX);
       ...
}

Citando esta parte, es donde se hace la comparación de cada ingreso contra todos los números ingresados hasta el momento.
Nótese que se utiliza una variable local llamada 'apuntador1' que en realidad hace de doble puntero o puntero a puntero, porque guarda la dirección de otra variable que al mismo tiempo guarda otra dirección de memoria. Por eso para acceder al valor final (un número) se utiliza la notación de doble puntero. En lo que respecta al FOR, como dijimos que son 10 enteros de 4 BYTES cada uno, entonces el FOR cuenta de a 4 BYTES para realizar 10 ciclos.

Código (cpp) [Seleccionar] Expandir

...
int apuntador1=(int)&entradaX;//Doble puntero
for(int j=inicio_bloque;j<(inicio_bloque+(0x4*i));j+=0x4)
{
int apuntador2=(int)&j;//Doble puntero

if(**(int**)apuntador1 == **(int**)apuntador2){
c++;
}
}

...

También se incrementa la variable entradaX o pseudopuntero THIS,
que apunta al último número o al número actual.
Eso se logra incrementándola en el FOR

Código (cpp) [Seleccionar] Expandir

entradaX+=0x4;

El tema es que esta variable se reutiliza, por lo cual se debe arreglar su
dirección para que siempre apunte a la primer variable entera.

Código (cpp) [Seleccionar] Expandir

entradaX=(int)&entrada1;

Inclusive todo esto tiene cierta analogía con el puntero THIS.
Pero quiero aclarar que no es el puntero THIS, es una comparación solamente por eso se le dijo "PSEUDO"

Para listar lo mismo, se le pase a printf el contenido del pseudopuntero.

Código (cpp) [Seleccionar] Expandir

for(int i=1;i<=MAX_NUMB;i++)
{
printf("%d\n",*(int*)entradaX);

entradaX+=0x4;
}

Si por casualidad les parece que mi publicación es una bldez, sepan que entiendo que no estoy descubriendo América, pero está claro que existen las variables de tipo puntero para hacer algo como esto, y no es normal hacerlo con variables comunes, por eso.

CODE:
http://www.mediafire.com/?q3l5yqplduxpfi6

Salu2

[main.cpp]

En base a un código fuente de ejemplo de un programa simple que usa Opengl32, decidí hacer unas pruebas sobre tal código. Unas pruebas con referencia al manejamiento de los colores para Opengl32.
Lo primero que hice fue mirar un manual, y luego revisar el código fuente de OGC que incluye un plugin para administrar los colores.
Si les interesa algo de esto pueden leer este pequeño manual:
http://www.mediafire.com/view/?n4n9zyzo0uda7ci

El programa es el mismo que el de mi anterior tema sobre Opengl32:
http://foro.elhacker.net/programacion_cc/gltest_1_interceptar_opengl32_con_gpa-t384878.0.html

Pero lo modifiqué porque mi intención era manejar los colores y mostrarlos por pantalla a modo de líneas de colores y color de fondo. No me importaba dibujar nada en la pantalla (aparte que tengo la mínima idea de Opengl32 XD). Pero de nuevo, lo que me interesaba era como se manejaban los colores.

Lo que es importante destacar, es que un color se representa con 32 bits, de los cuales 24 bits son para rojo, verde y azul, y los 8 restantes son para
la transparencia. Lean el manual cualquier koza.

Ahora voy a poner el código fuente de lo que hice, se compone de dos partes. La primera sería el programa Opengl32 modificado por mi para que muestre 15 colores de fondo de ventana y unas líneas, el tema es que se pueden cambiar los colores con el teclado (Flecha arriba y abajo).
La segunda parte viene a ser un plugin que hice en base al plugin existente en OGC llamado 'Color manager'. Se trata de 4 funciones específicas que manejan la conversión del formato RGBA. Hablando de esto, veamos algo..

Por ejemplo, el color blanco en formato entero (32 bits) es:

Código [Seleccionar] Expandir

255, 255, 255, 255

los primeros 8 son rojo, luego verde, luego azul y luego transparencia (alpha).

en modo de punto flotante, lo mismo

Código [Seleccionar] Expandir

255.0, 255.0, 255.0, 255.0

lo que pasa que las funciones de Opengl32 reciben los parámetros como de punto flotante, por la precisión del color. Sin mencionar que se toma como que un color va de 0.0 a 1.0.

no conozco todas las funciones Opengl32, sólo estuve usando algunas.

La otra forma de representar el RGBA es en hexadecimal, para el blanco
viene a ser:

Código [Seleccionar] Expandir

0xFFFFFFFF

es lo mismo que decir 255,255,255,255 pero todo junto en una variable.
por ejemplo:

Código [Seleccionar] Expandir

DWORD colorBlanco = 0xFFFFFFFF;

En cambio en modo entero se usa para poder manejar los colores desde una panel por ejemplo, o agregarlos desde un archivo de configuración.

Bueno, el tema es que las funciones que hice hacen todo este intercambio de los formatos.

Aunque la función 4 no pasa de formato a formato sino que establece un valor para la transparencia.

En lo que respecta al código, en mis 4 funciones fuí muy explícito con las variables locales, ya que en cada una fuí específico de dejar en claro cuando se trata del color rojo, cuando del verde y cuando del azul, y lo mismo para la transparencia. Es para que quede claro y no se pase por alto.

main.cpp

Código (cpp) [Seleccionar] Expandir



//
// By 85
// Credits: OGC, opengl.org
// boyscout_etk@hotmail.com
// etalking.com.ar
// 2013
//

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

#pragma comment (lib, "opengl32.lib")
#pragma comment (lib, "GLUT32/glut32.lib")
#include<windows.h>
#include<stdio.h>

#include "GLUT32/glut.h"
#include <gl\gl.h>
#include <gl\glu.h>

#include "rgba_funcs.h"

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

static float scale = 1.4;
static float transx, transy, rotx, roty;

int CURCOLOR =0;//Color actual (Se cambia con el teclado)
int TablaRGBA[15][4] = {//Tabla con 15 colores diferentes en RGBA

{80,150, 30, 110},
{255, 40, 40,200},
{40, 80,255,200},
{250,250, 22, 254},
{0,  0,  0, 128},
{80,150, 30, 110},
{255,255,255,255},
{15, 50,255, 50},//Consola del Hurricane XD
{220,220,220,200},
{0,128,0,200},
{255,255,255,255},
{220,220,220,200},
{100,255,160,200},
{100,255,160,200},
{51,51,204,180},//Menu del Hurricane XD
};

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

void bfunc(void)
{
static int state;
if(state ^= 1)
{
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
}
else
{
glDisable(GL_BLEND);
}
}

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

void init(char* filename)
{
}

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

void TestPluginRGBAfuncs(){// Probando el plugin

int v1[4] = {51,51,204,180};
float v2[4] = {0,0,0,0};
rgbaInt_a_rgbaFloat(v1,v2);
printf("%f %f %f %f\n", v2[0], v2[1], v2[2], v2[3]);
system("pause");

//=================================

int vec1[4] = {51,51,204,180};
DWORD color1 = 0xFFFFFFFF;
color1=rgbaInt_a_rgbaHex(vec1);
printf("0x%X\n", color1);
system("pause");

//=================================

int vecca[4] = {51,51,204,180};
int* vec2 = (int*)&vecca[0];
DWORD color2 = 0x336699FF;
vec2 = rgbaHex_a_rgbaInt(color2);
printf("%d %d %d %d\n", vec2[0], vec2[1], vec2[2], vec2[3]);
system("pause");

//=================================

DWORD color3 = 0xFFFFFF33;
color3 = ComplementoAlpha(color3,85);
printf("0x%X\n", color3);
system("pause");
}

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

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glTranslatef(transx, transy, 0.f);
glRotatef(rotx, 0., 1., 0.);
glRotatef(roty, 1., 0., 0.);
glScalef(scale, scale, 0.);
glLineWidth(5.5);
////////////////////////////////////////////////////
////////////////////////////////////////////////////
float r = float(TablaRGBA[CURCOLOR][0])/255.0;
float g = float(TablaRGBA[CURCOLOR][1])/255.0;
float b = float(TablaRGBA[CURCOLOR][2])/255.0;
float a = float(TablaRGBA[CURCOLOR][3])/255.0;
glClearColor(r,g,b,a);
glColor3f(TablaRGBA[CURCOLOR][0],TablaRGBA[CURCOLOR][1],TablaRGBA[CURCOLOR][2]);
glBegin(GL_LINES);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(15, 0, 0);
glEnd();
glutSwapBuffers();
//glFlush();
}

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

void reshape(int w, int h)
{
glViewport(-50, -50, w+120, h+120);
}

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

void key(unsigned char key, int x, int y)
{
if (key=='\033') exit(0);

bfunc();
glutPostRedisplay();
}

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

void special(int key, int x, int y)
{
 switch (key) {
 case GLUT_KEY_UP:
 {
if(CURCOLOR==14) CURCOLOR=0;
else CURCOLOR++;
 }
   break;
 case GLUT_KEY_DOWN:
 {
if(CURCOLOR==0) CURCOLOR=14;
else CURCOLOR--;
 }
   break;
 default:
   return;
 }
 glutPostRedisplay();
}

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

void tick(void)
{
glutPostRedisplay();
}

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

int main(int argc, char** argv){

SetConsoleTitle("glTest2");
TestPluginRGBAfuncs();

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

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutInitWindowSize(450, 450);
glutCreateWindow("SHOW COLORES");
// glutFullScreen();
init(argv[1]);
glutDisplayFunc(display);
glutKeyboardFunc(key);
glutSpecialFunc(special);
glutReshapeFunc(reshape);
glutIdleFunc(tick);
// SetActiveWindow(FindWindow(0,"SHOW COLORES"));
SetForegroundWindow(FindWindow(0,"SHOW COLORES"));//Para que quede en primer plano ;D
glutMainLoop();
system("pause");
return 0;
}

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




rgba_funcs.cpp

Código (cpp) [Seleccionar] Expandir



//
// By 85
// Credits: OGC, opengl.org
// boyscout_etk@hotmail.com
// etalking.com.ar
// 2013
//

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

#pragma warning(disable: 4244)
typedef unsigned long DWORD;
int idef[4]={255,255,255,255};
float fdef[4]={255.0,255.0,255.0,255.0};

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

//Para Opengl32 (Valores de 0.0 a 1.0)
void rgbaInt_a_rgbaFloat(int iVecRGBA[4]=reinterpret_cast<int*>(idef),
float fVecRGBA[4]=reinterpret_cast<float*>(fdef)){

float red = float(iVecRGBA[0])/255.0;
float green = float(iVecRGBA[1])/255.0;
float blue = float(iVecRGBA[2])/255.0;
float alpha = float(iVecRGBA[3])/255.0;
fVecRGBA[0]=red;
fVecRGBA[1]=green;
fVecRGBA[2]=blue;
fVecRGBA[3]=alpha;
}

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

DWORD rgbaInt_a_rgbaHex(int vecRGBA[4]=reinterpret_cast<int*>(idef)){

int red=vecRGBA[0];
int green=vecRGBA[1];
int blue=vecRGBA[2];
int alpha=vecRGBA[3];
return ((red<<24) + (green<<16) + (blue<<8) + alpha);
}

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

int* rgbaHex_a_rgbaInt(DWORD color= 0xFFFFFFFF){

int red   = (color>>24);
int green = (color>>16)&0xFF;
int blue  = (color>>8)&0xFF;
int alpha = (color)&0xFF;
static int vecRGBA[4];
vecRGBA[0]=red;
vecRGBA[1]=green;
vecRGBA[2]=blue;
vecRGBA[3]=alpha;
return vecRGBA;
}

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

DWORD ComplementoAlpha(DWORD color= 0xFFFFFFFF, int alpha=255){

color &= 0xFFFFFF00;//Quita
color += alpha;//Pone
return color;
}

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



Cuando abren el programa aparecen dos ventanas, la de la consola
va a mostrar el resultado de las pruebas de conversión.
La otra es la ventana de la aplicación Opengl32, muestra un color
de fondo que se puede cambiar con las flechas arriba abajo


Proyecto en MSVCPP6
http://www.mediafire.com/?49xkm41pswptcby

8ye8ye