.exe Dateigröße

[turboPASCAL]

@Counter909,

(Simple Erklärung zu UPX & Co)

Also UPX ist eine schlechte Idee. Dieses Tool komprimiert die Datei nur also eine Art
selbst entpackendes Archiv für Exe-Datein.
Wenn solch eine komprimierte Exec gestartet wird entpack sich diese im Hauptspeicher.
Dazu kommt noch mal die Grösse der Exec. D.h. mit UPX lädt man sich das Programm
zwei mal in den Speicher. Das Tool macht also nur bei kleinen Dateien und oder
zu Transportzwecken für USB-Stick oder Internet Sinn wenn man es nicht in ein
Zip.- Rar.- oder anderes Archiv packen kann oder darf.

Die Grösse der Exec's:

Die normale VCL - Standard Delphi Anwendungen enthält Units und Libarys die dem Programmierer
das programmieren erleichtern. So braucht sich dieser nicht explizit zB. um das Erstellen
einer Form (eines Fensters) oder eines Buttons sowie "Fehlerabfangroutinen" zu kümmern.
Eine solche erzeugte Datei ist nun rund 500 KByte gross.

Will man das nun vermeiden kann man auch ohne die VCL programmieren. ( Stichwort nonVCL )
Der Nachteil ist das der Programmierer sich nun um alles selbst kümmern muss (zB. um das Erstellen des
Fensters, Buttons o.ä.). Der Vorteil eine kleine Exec.-Datei. Die Grösse der Datei ist dafür minimal.
Ein kleines Programm kann so zB. bei rund 20 KBytes liegen.

Beispiele.:
Standard - VLC Anwendung mit einem Fenster:

Delphi-Quellcode:

// - 1 ---------------------------------------------------------------------

program Project1;

uses
  Forms,
  Unit1 in 'Unit1.pas' {Form1};

{$R *.res}

begin
  Application.Initialize;
  Application.CreateForm(TForm1, Form1);
  Application.Run;
end.

// - 2 ---------------------------------------------------------------------

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

end.

Die Grösse der Exec.-Datei beträgt nun schon ~ 400 kBytes.

Standard - nonVLC Anwendung mit einem Fenster:

Delphi-Quellcode:

program Project1;

(* {$R 'resource.res' 'resource.rc'} *)

uses
  Windows, Messages;

const
  wndClassName = 'mWndClass';
  wndAppTitle  = 'nonVCL';
  WndWidth     = 320;
  WndHeight    = 240;

var
  hWndApp: Cardinal;

function WndProc(_hWnd: HWND; _Msg: UINT; _wParam: wParam; _lParam: LParam):
  lresult; stdcall;
var
  x, y : integer;
begin
  Result := 0;

  case _Msg of
    WM_CREATE:
      begin
        // Fenster zentrieren
        x := GetSystemMetrics(SM_CXSCREEN);
        y := GetSystemMetrics(SM_CYSCREEN);
        MoveWindow(_hWnd, (x div 2) - (WndWidth div 2),
          (y div 2) - (WndHeight div 2), WndWidth, WndHeight, TRUE);
      end;
    WM_DESTROY:
      PostQuitMessage(0);
  else
    Result := DefWindowProc(_hWnd, _Msg, _wParam, _lParam);
  end;
end;

var
  WndClass: TWndClass;
  msg: TMsg;

BEGIN
  with WndClass do
  begin
    // cbSize        := SizeOf(TWndClassEx);
    Style         := CS_HREDRAW or CS_VREDRAW;
    lpfnWndProc   := @WndProc;
    cbClsExtra    := 0;
    cbWndExtra    := 0;
    hbrBackground := COLOR_APPWORKSPACE;
    lpszMenuName  := nil;
    lpszClassName := wndClassName;
    // hIconSm       := 0;
    hInstance     := hInstance;
    hIcon         := LoadIcon(hInstance, MAKEINTRESOURCE(100));
    hCursor       := LoadCursor(0, IDC_ARROW);
  end;

  // Fenster registrieren
  RegisterClass(WndClass);

  // Fenster erzeugen
  hWndApp := CreateWindow(
      wndClassName,
      WndAppTitle,
      WS_OVERLAPPEDWINDOW,
      INTEGER(CW_USEDEFAULT),
      INTEGER(CW_USEDEFAULT),
      WndWidth,
      WndHeight,
      0,
      0,
      hInstance,
      nil);

  // Fenster anzeigen
  UpdateWindow(hWndApp);
  ShowWindow(hWndApp, SW_SHOW);

  // Nachrichtenschleife
  while GetMessage(msg,0,0,0) do
  begin
    TranslateMessage(msg);
    DispatchMessage(msg);
  end;

  UnRegisterClass(WndClassName, HInstance);

  ExitCode := msg.wParam;
END.

Die Grösse der Exec.-Datei beträgt nun nur ~12 Bytes.


Ist es nicht Notwendig ein Fenster zu erzeugen kann man sich auch mit einer Art
Misch aus beiden Programiervarianten behelfen:

Delphi-Quellcode:

program Project1;

uses
  Windows, SysUtils;

function Addiere(ValueA, ValueB: integer): integer;
begin
  Result := ValueA + ValueB;
end;

procedure Machwas;
begin
  MessageBox(0, PCHAR(IntToStr(Addiere(100, 23))), 'Hallo:', MB_OK);
end;

BEGIN
  Machwas;
  MessageBox(0, PCHAR(TimeToStr(now)), 'Die Uhrzeit ist:', MB_OK);
END.

Die Grösse der Exec.-Datei beträgt nun ca. 45 kBytes.


// Edit: Doppelmoppel entfernt.