Ich habe schon so einiges programmiert und ich denke auch einiges an Grundkenntnissen zu besitzen, möchte aber gerne "kurz" einmal die für die Programmierung wichtigen Zusammenhänge der Computerkomponenten notieren.
und es hat in diesem Forum bestimmt viele schlaue Köpfe sitzen, welche mir hierzu bei den Fragen und Ergänzungen zur Seite stehen, damit andere Einsteiger die Zusammenhänge einfacher und besser verstehen:
------------------------------------------------------------------------
Teil 1: Was geht ab... wenn ich ein Programm kompiliere? &
Teil 2: Was geht ab... wenn ich ein Programm starte?
------------------------------------------------------------------------
Teil 1: Was geht ab... wenn ich ein Programm kompiliere?
------------------------------------------------------------------------
Nun, die Voraussetzungen zum Kompilieren sind ("Man nehme..."):
Hardware:
- einen funktionierenden PC ;.)
------------------------------------------------------------------------
Software:
- Eine Entwicklungsumgebung zB die
BDS!!! um Code zu verwalten:
- Sourcecode (händisch programmiert) wie im Beispielcode:
Delphi-Quellcode:
procedure TForm1.Button1Click(Sender: TObject);
var
sValue1, sValue2: String;
iValue1, iValue2: Integer;
iSumValue: Integer;
begin
sValue1 := Edit1.Text;
sValue2 := Edit2.Text;
iValue1 := StrToInt( sValue1 );
iValue2 := StrToInt( sValue2 );
iSumValue := iValue1 + iValue2;
showmessage( inttostr( iSumValue ) );
end;
- und/oder von der Entwicklungsumgebung generiert zB: Unit1.dfm
(diese hat einfach zwei Edits und einen Button)
Delphi-Quellcode:
object Form1: TForm1
Left = 0
Top = 0
Caption = 'Form1'
ClientHeight = 133
ClientWidth = 167
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'Tahoma'
Font.Style = []
OldCreateOrder = False
PixelsPerInch = 96
TextHeight = 13
object Button1: TButton
Left = 40
Top = 72
Width = 75
Height = 25
Caption = 'Button1'
TabOrder = 0
OnClick = Button1Click
end
....[gekürzt]....
end
- sowie CodeLibs der Entwicklungsumgebung wie die Units: Forms, SysUtils etc.
welche bei Bedarf (d.h. wenn in uses) Code dem Programm beisteuern.
------------------------------------------------------------------------
so weit so gut...
jetzt wird der Code kompiliert & gelinkt:
Ablauf:
1. ein Kompiler zB: dcc32.exe wandelt den Code in Maschinencode um
und
2. der Linker...
(hmmmmm, in wikipedia ist der Linker erklärt...aber ich verstehs in meinem Beispiel trotzdem nicht)
Wichtige Zusatzinfos:
Für die Parameterisierung des Kompilers im
BDS: siehe Projektoptionen -> Compiler
------------------------------------------------------------------------
und fertig ist die ausführbare Datei!
war das wirklich schon das wichtigste in Kürze?
------------------------------------------------------------------------
Teil 2: Was geht ab... wenn ich ein Programm ausführe?
------------------------------------------------------------------------
das wird bestimmt etwas schwieriger...
Nun, die Voraussetzungen zum Ausführen einer ausführbaren Datei sind:
------------------------------------------------------------------------
Hardware:
- immer noch - ein funktionierender PC ;.)
------------------------------------------------------------------------
Software:
- Betriebssystem (
OS) mit CodeLibs wie kernel.dll etc.
Ablauf:
1. Ich starte meine Datei
2. Das
OS lädt die ganze Datei in den Arbeitsspeicher...
(Frage: hmm stimmt das? abgesehen von zusätzlich dynamisch geladenen DLL's)
3. Das Programm wird an einem fix definierten Ausführungspunkt ausgeführt
(siehe Project1.dpr -> begin)
4. Application.Initalize
-> Alle Units werden initalisiert
(Frage: Wenn eine Unit Code im initalization hat, ansonsten aber gar nicht benötigt wird, ist der Kompiler so schlau diese Unit zu ignorieren?)
5. Application.CreateForm(TForm1, Form1); -> Der für die Form nötige Speicher wird reserviert und
die Form1 wird created
(Frage: bedeutet "create" lediglich dass Speicher reserviert wird?)
6. Application.Run
-> Die Form1 wird angezeigt...
(Frage: einfach weils die erste erstellte Form ist? wie witzig...)
-> und aktiviert
Wichtige Zusatzinfos:
- zum Erstellen und Anzeigen von Komponenten werden Messages zwischen der Applikation und dem
OS hin- und hergeschickt (zB: WM_Create etc.),
deshalb sieht eine Form jeweils passend zum ausgeführten
OS aus
(Frage: welche CodeLib des OS ist hauptsächlich für das Erstellen der Form zuständig?)
- jede Komponente besitzt automatisch ein eindeutiges
Handle
- ... [ bitte um Erweiterung... ]
Event: Der Button auf der Form wird gedrückt
10. Das
OS erhält die Message WM_MouseClick und sendet diese an die Komponente weiter
11. Der Code vom Button1.OnClick (siehe Beispielcode oben) wird ausgeführt:
11.1 var... Es wird Arbeitsspeicher - an einer freien Stelle - für die Variablen reserviert
(Frage: Was ist der Stack...?)
11.2 Den Variablen wird ein Wert zugewiesen
11.3 iSumValue := iValue1 + iValue2;
-> In eine weitere Variable wird die Summe der beiden ersten Variablen zugewiesen
11.4 showmessage (aus der
Unit Dialogs) sendet den Befehl weiter ans
OS und zeigt das Ergebnis an
das wars - einfach gesagt? oder was gibts sonst noch wichtiges? hast du noch einen Input?
PS:
Vllcht weiss jemand ein gutes Buch welches diese Zusammenhänge gut erklären würde?