Mensajes

DumpMemory.... creo que lo hizo MadAntraX... revisa en recopilacion de enlaces interesantes ( Los temas pegados ) hay debera estar.

Dulces Lunas!¡.

Ingenieria inversa... antes de programar deberas aplicar esto para ver como calcular la dirrecion de la sección que deseas leer.

Prueba con un editor Hexadecimal; Hoy en dia cualquier editor hexadecimal desente te permite leer la memoria de un proceso X... y bueno abria que ver si el bloque a leer es estatica o dinamica, si es lo segundo vas a tener que analizar mas a detalle, si es lo primero lo tendras muy facil.

Edito:

Cuando regrese reviso mi disco duro para ver si aun tengo la version Modificada del Cheat Engine ( No lo detecta ningun juego xP ).
*Intenta cambiarle el Title a la ventana del cheat Engine... seguro los juegos usan FindWindow para ver si esta abierto este programa...

Dulces Lunas!¡.

mmmm usa sendmessage con las constantes:

EM_GETLINECOUNT
EM_LINELENGTH

Con eso sera mas que suficiente.

Revisa la MSDN para saber que debes pasar en lparam y wparam...

http://www.recursosvisualbasic.com.ar/htm/trucos-codigofuente-visual-basic/40.htm

Dulces Lunas!¡.

http://es.wikipedia.org/wiki/Algoritmo_Knuth-Morris-Pratt
http://en.wikipedia.org/wiki/Knuth–Morris–Pratt_algorithm
http://www.ics.uci.edu/~eppstein/161/kmp/
http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/kmpen.htm

Google No muerde... el algoritmo es multilenguaje xD.

Dulces Lunas!¡.

[objetivo]

Por ejemplo en la biblia de C++ (el libro "The C++ Programing Language") BS recomienda, entre otras cosas, el uso de fuentes proporcionales (y para alinear el texto eso implica el uso de tabuladores en lugar de espacios).
Un cuestionamiento objetivo en contra del uso de nombres como "__pp_back" es el siguiente.

1) Al utilizar nombres de encabezados terminados con ".h" como "<stdio.h>" el nombre de espacios utilizado es el global.

2) En C (y eso incluye las facilidades de su biblioteca estándar) los nombres con un guion bajo inicial están reservados.

Si bien el riesgo de un conflicto de nombres es bajo seria mejor evitarlo ya sea utilizando los nombres "políticamente correctos" como "<cstdio>" o bien evitando los nombres en la forma ya mencionada.

* Uso tabulador, no espacios...
* Ok no usare "_" para declarar variables al menos que lo requiera... ( mi idea no era "__Nombre" donde "__" indicara que son punteros mas bien "_pp_TipoNombre"...  _pp_szNombres ).
* Lo de la segunda variable y lo que presedia, ya me habia dado cuanta, pero solo me interesaba ese error, que ya esta solucionado aun asi te lo agradezco.
* Me quedo con la nomeclatura de 1 sola letra para indicar los prefijos de la variable( inclusive combinaciones como las que ha hecho Karman me gusto el prefijo "v" para tipos que puedan tomar distintos tipos de variable, inclusive me soluciono un ideal que tenia respecto a las combinaciones de los mismos ).
* NULL = (void*)0...
* Con estos dos ultimos Post muy completos me han quitado la sensacion de abrir un 2do Hilo de discucion.

P.D.: El tema ya se desvirtuo mucho, aun que ya aprendi una cosa mas!¡.

Dulces Lunas!¡.

Excelente UC.

P.D.: ya vote por ti, la idea fue genial.

Dulces Lunas!¡.

A lo que nos referimos con tu código es al uso de __ para nombrar una variable, el uso de tabulaciones para pasar los parámetros a una función, a juntar los operadores con las variables (no lo soporto xD), etc..

Si bueno los _ como ya dije los usare para punteros de esa manera no los mesclare con el prefijo que designa al tipo, esto si no lo cmabiare, lo de las tabulaciones loq ue yaho yo es tener una linea imaginaria que me permita ordenar las asignaciones y no me genere personalmente peresa visual.

Código (cpp) [Seleccionar] Expandir



asdasd = asd;
asds=asd;
asdsadasdsad=sd
asdsd=sad;
asds=a;
d=s;



lo que hago es ordenarlo de esta manera

Código (cpp) [Seleccionar] Expandir



asdasd          = asd;
asds            = asd;
asdsadasdsad    = sd
asdsd           = sad;
asds            = a;
d               = s;



lo hago solo por la peresa viisual que me genera al ver tanto codigo juntado, lo del memcpy fue un error... ya que lo en C lo hago de esta manera.

Código (cpp) [Seleccionar] Expandir



memcpy(
       __new_ptr ,
       __pp_back ,
       _szt_now*sizeof(void*)
       );



Pero como estoy haciendo pruebas y aun no comento nada lo dejo lineal para saber donde le faltan comentarios ( Muy breves pero explicitos ).

P.D.: Al final deje esta funcion de largo y use realloc() y malloc() para esto, dejando a new y delete para las clases.

Dulces Lunas!¡.

No me gusta declarar variables sin tener prefijos que NO me indiquen que tipo de variables son... es decir me guio en la nomeclatura hungara que de hecho estan hay por algo, es decir, mantenimiento de codigo a corto, media y largo plazo.

Digamoslo de esta manera:

Tienes 40 declaraciones de variables en un proceso X y varias lineas en tu proceso, si les pongo solo nombres sin que digan mucho ( tipo y/o clase ), y se lo doy a otro programador, este ultimo para que modificara solo 3 lineas, el pobre tendria que irse hasta donde estan declaradas las varibales para saber de que tipo son, y tambien para saber si se estan tratando variables tipo <Puntero>, <Puntero a Puntero> o en un caso mas raro saber si son <Punteros a Punteros a Puntero>, seria algo muy tedioso esto la vdd.

temp, Current, etc y si se desea hacer un cast entre tipos distintos, pues tendria el programador que estar transladandose a zonas que no tendria que transladarse a cada instante.

__pp_ <.. Puntero a puntero algunos solo hacen un    pNombreVariable...  yo le pongo los "_" solo para separar esta nomeclatura ( aun que estoy pensando solo realizar esto para los punteros de cualquier tipo... )

_tipo_nombre     otros ->  tipoNombre     ( Como dije estoy pensando en quitar los _ y dejarselo solo a los punteros... )

un ejemplo de lo que digo:

Código (cpp) [Seleccionar] Expandir



    if (_szt_now==_szt_new )
        return __pp_vector;

    if ( _szt_new>0 ) {
        __new_ptr       = new void*[_szt_new];
        if ( _szt_now>0 && __new_ptr!=NULL && __pp_back!=NULL  )
            if ( _szt_now>_szt_new )
                memcpy          ( __new_ptr , __pp_back , _szt_new*sizeof(void*) );
            else
                memcpy          ( __new_ptr , __pp_back , _szt_now*sizeof(void*) );
    } else
        __new_ptr       = NULL;

    if ( __pp_back!=NULL )
        delete[]        __pp_back;

    return __new_ptr;



y tu codigo:

Código (cpp) [Seleccionar] Expandir



if (currentSize == newSize) 
return buff;

if (newSize > 0)
{
temp = new void*[newSize];
if (currentSize > 0 && temp != NULL && currentBuff != NULL)
if (currentSize > newSize)
memcpy(temp, currentBuff, newSize * sizeof(void*));
else
memcpy(temp, currentBuff, currentSize * sizeof(void*));
}
else
temp = NULL;

if (buff != NULL)
delete[] buff;

return temp;



Ahora dime de que tipo son cada variable... solo lo sabrias si analizas el codigo pero eso conlleva tiempo... en mi caso si sabes que significan cada prefijo sabes que tipo son sin mayor problema.

otro ejemplo seria detectar errores entre comparaciones de Enteros con signo y enteros sin signo y asi detectar con tan solo ver las variables donde radica el error.

Ej:

Código (cpp) [Seleccionar] Expandir



//Suponiendo que las variables estan perdidas en alguna parte del codigo... pero las variables tienen prefijos...
dwVar  = -1;   // _dw_Var <--- yo lo haria asi pero creo que si quitare los "_"...
//Tendriamos que verificar que dwvar no sea menor a 0 ya que udwvar no acepta numeros negativos... aun que tiene sus equivalencias.
udwvar = dwvar;  //  Se tendria que hacer un casting...   ( -1 == -2147483648 )



si no tuviera prefijos...

Código (cpp) [Seleccionar] Expandir



//Suponiendo que las variables estan perdidas en alguna parte del codigo... pero las variables tienen prefijos...
// De que tipo es?... vamos a tener que buscar las desgraciadas variables... y esperemos que esten en donde se deberian declarar, si no tendremos que buscar en todo el codigo ¬¬".
Numero1  = -1;
Numero2 = Numero1; //<--- Si aqui genera un error, y no sabemos porque, seguro haremos un casting... pero las variables pueden albergar la misma cantidad? es decir pesa lo mismo en memoria? o tenemos que cambiar el tipo de la variable para que soporte Numero2 a Numero1 y no se puedan bits/bytes(segun sea el caso)?.



Los codigo de los sitemas Operativos y/o programas variados tienen nomeclaturas similares y no manejan en muchos casos el tipo de declaraciones que aqui Todos han mencionado (Con excepciones claro). seguramente cada empresa de software maneja y/o define una nomeclatura "X" aun que otras pueden usar la nomeclatura recomendada y que mas se usa.

Como has dicho Programar es un arte y debe ser de facil interpretacion sea cual sea el caso...

Nota: A mi nomeclatura solo le he agregado "_" para separar nombre de tipos, y no morir en el intento, aun que no es la misma nomeclatura que se usa en las estructuras y demas debido a los "_" se comprende.

Dulces Lunas!¡.

En que sentido es tediosa? me gustaria saber.

Dulces Lunas!¡.

Ecole se ve bueno, esperemos que la siguiente version sea mas en un estilo grafico, es decir que en lugar de que sea con etiquetas sea ya "On the Fly" la previsualizacion... no se si me entiendas si no abre el WordPad y veras lo que digo ( hay la negrita se ve mas se le pone etiquetas ), y ya con un simple boton Copy&Paste se copee el codigo para solo pegarlo en el foro.

Dulces Luans!¡.