델파이 실행프로그램이 그리 크지가 않습니다..(제가 느끼기에는)

혹시 다른 원인이 있지 않을까 생각 됩니다...

제가 코딩을 하면서 실행화일의 크기에 대해서 느낀 부분을
몇자 적습니다..


1. 이미지

    이미지를 포함하게 되면 이미지사이즈까지 포함되어  

   프로그램사이즈가 커지게 됩니다..

   따라서 이미지는 그냥 화일상태로 둔 상태에서 화일을
  
   실행시 호출하는 방식으로 바꾸면 사이즈가 줄어 듭니다.

   아니면 리소스 화일로 만들어서 사용하는 방법도 있습니다.

2.Bulid with runtime  Packages 체크

    project Option중에 Packages탭에서  Bulid with runtime  Packages 를

   체크후  컴파일하게 되면 실행화일에서 컴퍼넌트 코드 부분이

   빠지게 되므로 실행화일의 크기가 작아집니다..

Use CASE.. statments rather than IF..ELSE.. clauses.
                         In every .PAS-file that will be linked in your project, place the following line to the top of your code:

                                 {$D-,L-,O+,Q-,R-,Y-,S-}
                                

                         Also add this line to your project source (.DPR).
                         {$D-} will prevent placing Debug info to your code.
                         {$L-} will prevent placing local symbols to your code.
                         {$O+} will optimize your code, remove unnecessary variables etc.
                         {$Q-} removes code for Integer overflow-checking.
                         {$R-} removes code for range checking of strings, arrays etc.
                         {$S-} removes code for stack-checking. USE ONLY AFTER HEAVY TESTING !
                         {$Y-} will prevent placing smybol information to your code.
                         After doing this, recompile the whole project - your .EXE-size should magically have been reduced by
                         10-20 %..
                         If you link in graphics, they don't need to have more than 16 or 256 colors.
                         If the goal is really and only .EXE size, load your graphics by code ("manually") instead of embedding
                         them already during design time in each and every form which uses them. A detailled description of this tip
                         can be found on this page after clicking here.
                         If you include resource-files, they should only content the resources you really need - and nothing more.
                         If you use Delphi 1, finally run W8LOSS.EXE on your .EXE file (not required for 32bit-Apps).
                         Delphi 2 produces larger .EXE sizes than Delphi 1 - 32 bit code demands its tribute..
                         Delphi 3 produces larger .EXE sizes than Delphi 2 - main reason: market pressure leads to more
                         "fundamental" support of "bells and whistles" - quality and usefulness/efficiency/productivity doesn't seem
                         to be a real criteria in M$-times...
                         Delphi 4 produces larger .EXE sizes than Delphi 3 - main reason: market pressure leads to more
                         "fundamental" support of "bells and whistles" - (..to be continued like above)
                         check the "Show Hints" and "Show Warnings" options on the Project|Options|Compiler page, then rebuild
                         your project. It will show you every variable and proc/func that isn't being used. You might be able to trim
                         a little there, too.
                         Clean your USES.. clauses for all unneeded units!
                         The so-called "SmartLinking" doesn't always remove all unused code. In a large project you could
                         possibly spare 100k in the EXE by that.
                         Place Bitmaps/Glyphs/etc. in DLL's instead of in *.RES/*.DCR files !
                         If you place fx some large bitmaps in a .RES, these will compiled into the EXE. Remove the
                         .RES-declarations, instead place them in a new project like this:

                             LIBRARY My_Extern_RESes;
                                 USES EmptyUnit;
                             {$R MyRes1.RES}
                             {$R MyRes2.RES}
                             ...
                             INITIALIZATION
                             END.
                                

                         The unit AEmptyUnit is a completely empty unit. You have to use a unit like this because any other unit will
                         place unnecessary code in the final DLL. When you want to use an image (and typically, you only want to
                         load it once), you can do it like this :

                             MyHandle := LoadLibrary('My_Extern_RESes.DLL');
                             TButton1.Glyph.Handle := LoadBitmap(MyHandle,'My_Glyph');
                                

                         Placing Glyphs, Bitmaps, String-const's etc. in DLL's can really reduce a projects EXE-size. (Tip came from
                         David Konrad)
                         Basis rule: the more forms and units you add, the larger your exe becomes. When you had one huge form,
                         you only had one form class - even when you had 500+ things on it! This creates only one runtime type
                         information for that class. Now, when you split this into 17 units, each class in that unit requires its own
                         RTTI. Now, this runtime information can get large, collectively, with a lot of redundant information
                         compared to when you only had one huge class. Also, if each of the 17 units had its own form, your end
                         product must contain resource information for all 17 of those forms even though most of that information
                         may be redundant. One reason why this happens is because the Delphi compiler doesn't optimize
                         resources - but I don't know of any compiler that does. So, if you had two separate forms which are
                         identical in look, you'll have 2 copies of the resource in your .EXE.
                         This leaves some work for the programmer to be creative in maximizing resource reuseability. (Tip came from
                         Young Chung)
                         Delphi 3 and 4 allows you to use packages (runtime libraries) which can be easily enabled in your Project
                         options. Especially if you have to update your application often, this could be interesting for you: the
                         runtime libraries just have to be deployed once (there is even a chance that important Delphi packages like
                         vcl30.dpl or vcl40.bpl already exist on your user's computer) and to update your (then shrinked) executable
                         whenever an update is required (please consult the helpfile for further details).
                         If your EXE file has to be super-small and you can go without Delphi's powerful IDE and design features,
                         you can also program without including the VCL (visual component library) in your USES clause. Here is a
                         small EXE program which compiles to about 30 kb (by Frank Peelo):

                         Program HelloWin;
                         { Standard Windows API application written in Object Pascal. }
                         Uses
                           Windows,
                           messages,
                           MMSystem;
                         Const
                           AppName : pChar = 'HelloWin';

                         Function WindowProc(Window:HWnd; AMessage, WParam, LParam:LongInt):
                                 LongInt; StdCall; Export;
                         { The message handler for the new window }
                         Var
                           h : hdc;
                           ps: tPaintStruct;
                           r : tRect;
                         Begin
                           Result := 0;
                           Case AMessage of
                           WM_Create:Begin
                                                 PlaySound('C:WINDOWSMEDIAMusica Windows Start.wav', 0,
                                                 Snd_FileName or Snd_Async);
                                                 Exit;
                                                 End;
                           WM_Paint: Begin
                                                 h := BeginPaint(Window, Ps);
                                                 GetClientRect(Window, r);
                                                 DrawText(h, 'Hello Winblows!', -1, r,
                                                 DT_SingleLine or DT_Center or DT_VCenter);
                                                 EndPaint(Window, ps);
                                                 Exit;
                                                 End;
                           WM_Destroy:Begin
                                                 PostQuitMessage(0);
                                                 Exit;
                                                 End;
                           End;
                           Result := DefWindowProc(Window, AMessage, WParam, LParam);
                         End;
                         { Register the window class }
                         Function WinRegister:Boolean;
                         Var
                           WindowClass: TWndClass;
                         Begin
                           WindowClass.Style := cs_HRedraw or cs_VRedraw;
                           WindowClass.lpfnWndProc := @WindowProc;
                           WindowClass.cbClsExtra := 0;
                           WindowClass.cbWndExtra := 0;
                           WindowClass.hInstance := HInstance;
                           WindowClass.hIcon := LoadIcon(0, idi_Application);
                           WindowClass.hCursor := LoadCursor(0, idc_Arrow);
                           WindowClass.hbrBackground := HBrush(GetStockObject(White_Brush));
                           WindowClass.lpszMenuName := NIL;
                           WindowClass.lpszClassName := AppName;
                           Result := RegisterClass(WindowClass)<>0;
                         End;

                         Function WinCreate:HWnd;
                         Var
                           HWindow:HWnd;
                         Begin
                           hWindow := CreateWindow(AppName,
                                                   'The Hello Program',
                                                   WS_OverlappedWindow,
                                                   CW_UseDefault,CW_UseDefault,
                                                   CW_UseDefault,CW_UseDefault,
                                                   0,0,HInstance,NIL);
                           If hWindow<>0 then Begin
                             ShowWindow(hWindow, CmdShow);
                             UpdateWindow(hWindow);
                           End;
                           Result := hWindow;
                         End;
                         { Main: Set up window, then give it messages until done.}
                         Var
                           AMessage: TMsg;
                           hWindow: HWnd;
                         Begin
                           If not WinRegister then Begin
                             MessageBox(0, 'Register Failed', NIL, mb_Ok);
                             Exit;
                           End;
                           hWindow := WinCreate;
                           If hWindow=0 then begin
                             MessageBox(0, 'Register Failed', NIL, mb_Ok);
                             Exit;
                           End;
                           While GetMessage(AMessage, 0, 0, 0) do begin
                             TranslateMessage(AMessage);
                             DispatchMessage(AMessage);
                           End;
                           Halt(AMessage.WParam);
                         End.

                         There also exists a VCL replacement project named XCL linked from my "Delphi Tools" page which could
                         be of help here, too.
                         If your main goal is distributable size, you could also consider
                              using EXE/DLL packers like Blinker, ASPack, NeoLite etc. for program compression
                              or, even better: use alternative setup programs like our award-winning INF-Tool to create your
                              distribution package. INF-Tool creates today's smallest setup packages available! Since users
                              usually prefer to download smaller programs from the Internet (rather than to 'control' the installed
                              program size after setup), you can focus on functionality and features instead of having to think
                              about where to save a few code lines or if using a helpful VCL component "really pays".
                         (links to all mentioned programs can be found on my Delphi Tools page.)

우선은 프로그램을 만드실때여.. 필요 없는건 uses 에서 빼주시구여...

프로그램을 기능들을 dll로 따로 만들어서 관리 하시는 방법이 있구여

그리고 마지막으로 upx같은걸루 실행파일을 압축하는 방법이 있습니당

그럼 이만. 휘릭..

코리아팀 퐈이링~~~~