Mensajes

Si estas en windows, puedes usar las rutinas de timer de la winapi.
http://msdn.microsoft.com/en-us/library/windows/desktop/ms644901(v=vs.85).aspx

Sería cuestion de usar SetTimer con un refresco de 60.000 microsegundos. (60 segundos)

Saludos.

Hola, la ID que mencionas me imagino que sería una especie de HARDWARE ID de tu ordenador. Es decir, usando los numeros de serie por ejemplo de placa base, disco rigido, adaptador de red, etc... generan una clave usando algun algoritmo que identifica tu pc. Es decir esa ID es practicamente única para tu equipo.

Una vez que le pasas esa ID, ellos te generaron la CLAVE. El software teniendo esas dos cosas puede saber si esta registrado para usarse en ese equipo.
Se hace de esta manera normalmente para que no se pueda usar la misma CLAVE  en varios dispositivos. Es decir, la activacion sería valida para solamente el dispositivo con el que la registraste.

No creo que ellos te pasen los datos de como hacen para generar la HARDWARE ID y CLAVE ya que con eso protegen su software para que lo pagues y solo lo uses vos en tu pc.
Saludos.

Gracias por la aclaracion. Definitivamente estaba "flipando" xD

Teoricamente deberias de poder presentar un reclamo a algun Ente Regulador de Telefonia... si es que hay alguno?

En Argentina por ejemplo Telefonía fija tiene un ente regulador manejado por el Estado. Pero no  se si telefonia movil si.

Saludos.

En el caso de discos rigidos normales, recuerdo haber leído en este mismo foro en algun lado que particionandolos se les cortaba la vida útil un poco ya que la particion hace que ciertos sectores sean mas usados que otros.

Es así? O estoy recordando fruta?

Tienes un monton de return 0 condicionales, pero y el return por defecto?

Código [Seleccionar] Expandir


libera(lab,tamh,tamv,&lista);
   varokey = OK;
   if(varokey = OK){
return 0;
   }
}


deberia de ser

Código [Seleccionar] Expandir


libera(lab,tamh,tamv,&lista);
   varokey = OK;
   if(varokey = OK){
return 0;
   }
return 0;
} //<----- la última llave


De lo contrario el programa retornara con basura que esté en eax... eché por arriba un vistazo al codigo, y creo que el compilador te debería de tirar un error "main must return INT" porque tienes los return condicionales, pero el valor por defecto? Mas que nada por si ninguna de las condiciones se cumplen; ademas que si llego la ultima "}" evidentemente todo fue OK, y ahi va el return 0

las funciones retornan el valor en eax.

Si colocas:

Código [Seleccionar] Expandir


...codigo obfuscado
mov al, valor
... codigo obfuscado
retn


Cuando alguien depure tu programa va a tener:

Código [Seleccionar] Expandir


codigo
call tu_procedimiento ; con codigo obfuscado
<---- al tendrá el valor de retorno
codigo


No importa lo que pongas en la obfuscacion, el valor de retorno estará en eax.
Tendrás mas "suerte" usando variable global o pasando el parametro por referencia.

Saludos.

Pero si lo convierto a void* el puntero a funcion tendria un argumento un puntero a void. Y lo que en realidad creo que necesito es tratar de pasarle como parametro una cantidad de parametros desconocida de tipo desconocido.

Código (cpp) [Seleccionar] Expandir


#include <vector>
#include <string>
#include <iostream>


typedef void(*callback_proc_)(void);
class CMenu;


class MenuItem{
    public:
        MenuItem(const char* cap, callback_proc_ proc):caption_(cap),proc_(proc){}
        ~MenuItem(){
            submenu_.clear();
        }
        friend class CMenu;
    private:
        callback_proc_ proc_;
        std::string caption_;
        std::vector<MenuItem> submenu_;
};

class CMenu{
public:
    inline void AddMenu(const char* cap, callback_proc_ proc);
    inline void AddSubMenu(const char* cap, callback_proc_ proc, int parent);
    inline void PrintMenu();
    inline void DoMenu();
    CMenu();
    ~CMenu();
   
private:   
     std::vector<MenuItem> menu_;
};

CMenu::CMenu(){
    menu_.push_back(MenuItem("SALIR", NULL));

}

CMenu::~CMenu(){
    for(int i = 1; i < menu_.size(); ++i){
        menu_[i].submenu_.clear();
    }
    menu_.clear();
}

inline void CMenu::AddMenu(const char* cap, callback_proc_ proc){
    menu_.push_back(MenuItem(cap, proc));
     
}
inline void CMenu::AddSubMenu(const char* cap, callback_proc_ proc, int parent){
    if(parent > menu_.size())
        throw("Indice del menu mayor que lista del menu");
    else
        menu_[parent].submenu_.push_back(MenuItem(cap, proc));
}

inline void CMenu::PrintMenu(){
    for(int i = 1; i < menu_.size(); ++i){
        std::cout << i << ": " << menu_[i].caption_ << "\n";
        for(int j = 0; j < menu_[i].submenu_.size(); ++j){
            std::cout << "   " << i * 10 + j + 1 << ": " <<  menu_[i].submenu_[j].caption_ << "\n";
        }
    }   
    std::cout << 0 << ": " << menu_[0].caption_<< "\n";
}

inline void CMenu::DoMenu(){
    int option = 0;
    int mainsize = menu_.size()-1;
    int msize = mainsize * 10 + menu_[mainsize].submenu_.size()+1;
    do{
        while ((std::cout << "Eliga una Opcion: ") && (!(std::cin >> option) || option < 0 || option > menu_.size()*10)) {
            std::cout << "Opcion Invalida! ";
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        }
       
        int imenu = option / 10;
        int isubm = option % 10;
        if(option < 10 && option > 0 && option < menu_.size()){
            if(menu_[option].proc_)
                menu_[option].proc_();
        } else if(option >=11 && isubm != 0 && imenu < menu_.size()){
            if(isubm <= menu_[imenu].submenu_.size())
                if(menu_[imenu].submenu_[isubm-1].proc_)
                    menu_[imenu].submenu_[isubm-1].proc_();
        } else {
            std::cout << "Opcion Invalida \n";
        }
    }while(option != 0);
   
 


teniendo  void proc(void) podria ahora hacer
Menu.AddMenu(proc);

Pero lo que estoy tratando de hacer es algo como esto:

Código [Seleccionar] Expandir


int proc1(int x, int y);
char* proc2(const char * strCh);
Menu.AddMenu(proc1); //tipo incompatible
Menu.AddMenu(proc2);

Ba, en realidad estoy pensando que tengo que guardar el tipo y la cantidad de argumentos algo asi como hace printf?

Holas estimados ,
estaba jugando un poco con c++ para crear una clase que manejara menus de consola.
Hasta ahora tengo algo funcionando como esto:

Código (cpp) [Seleccionar] Expandir


void proc1(void){
    std::cout << "proc1" << std::endl;
}
void proc1a(void){
    std::cout << "proc1a" << std::endl;
}
void proc1b(void){
    std::cout << "proc1b" << std::endl;
}
void proc2(void){
    std::cout << "proc 2" << std::endl;
}

void proc3a(void){
    std::cout << "proc 3a" << std::endl;
}
void proc3b(void){
    std::cout << "proc 3b" << std::endl;
}
void proc3c(void){
    std::cout << "proc 3c" << std::endl;
}


   
int main(int argc, char* argv[]){
    CMenu menu;
    menu.AddMenu("OPCION 1", proc1);
    menu.AddSubMenu("OPCION1A", proc1a, 1); //submenu de la opcion 1
    menu.AddSubMenu("OPCION1B", proc1b, 1);
    menu.AddMenu("OPCION 2", proc2);
    menu.AddMenu("OPCION 3", NULL); //opcion 3 separador, no tendria funcion
    menu.AddSubMenu("OPCION3A",  proc3a, 3); //submenu de la opcion 3
    menu.AddSubMenu("OPCION3B", proc3b, 3);
    menu.AddSubMenu("OPCION3C", proc3c, 3);
    menu.PrintMenu();
    menu.DoMenu();
    return 0;
}


El resultado es algo asi:

1: OPCION 1
   11: OPCION1A
   12: OPCION1B
2: OPCION 2
3: OPCION 3
   31: OPCION3A
   32: OPCION3B
   33: OPCION3C
0: SALIR
Eliga una Opcion:

Por ejemplo si se elige la opcion 11, se llamará a proc1a(), y esto se repite hasta que se elija salir.

El problema es, el puntero a funcion como parametro lo tengo defenido asi:

Código (cpp) [Seleccionar] Expandir


typedef void(*callback_proc_)(void);
inline void CMenu::AddMenu(const char* cap, callback_proc_ proc){


Con esta estructura, estoy forzando que el procedimiento que esta asociado al item del menu es "void name(void)"

Como se podría hacer para poder pasar como parametro a AddMenu() una funcion con numero y tipo de parametros desconocido?

Saludos Y gracias

El tema en los ensambladores es que las actualizaciones salen para agregar las instrucciones de hardware nuevo, por ejemplo  sse3,sse4; reparar algunos bugs. Pero funcionalidades nuevas, muy rara vez. Es un ensamblador, no un compilador.

Se que hay una muy buena documentacion y ejemplos para masm32-64. Y como es orientado a windows no vas a tener problemas alli. (es de microsoft)

Yo particularmente prefiero fasm:
http://flatassembler.net/docs.php

Principalmente por la idea de:
SSSO: Same Source Same Output. Es decir, a diferencia del masm que puedes pasarle parametros al ensamblador para que genere codigo diferente. En fasm se hace dentro del mismo codigo fuente. Por eso que el mismo codigo fuente no requiere del programador pasarle parametros extra.

Y tambien en modo en que maneja direcciones de memoria y valores. (direccion de memoria, valor)
[variable] ---> valor
variable ----> direccion de memoria

A diferencia de masm que es:
variable---> valor
offset variable---> direccion de memoria.

Pero para gustos hay colores.

Saludos.