C++: Verständnis: Merken sich Zeiger ihre Größe?
lima-city → Forum → Programmiersprachen → C/C++ und D
abbildung
array
baum
betriebssystem
bit
blocken
byte
code
compiler
idee
merken
pointer
problem
quelle
speichern
tabelle
unterschied
vergeben
wissen
zeiger
-
ich progamiere eigentlich eher C#, und da braucht man keine Zeiger. Vor kurzem habe ich mein C++ Buch wiedergefunden aus Interesse mal reingelesen und war erstaunt darüber, dass der C++-Compiler einem ziemlich viel erlaubt. Daraufhin habe ich so lange in meinem Arbeitsspeicher "rumgepointet", bis ich dann anfing Arrays und Zeiger als das selbe zu betrachten(sie sind nicht ganz genau das selbe, oder?), und bis ich endgültig sicher war, dass sich Zeiger und Arrays ihren Speicherbereich nicht merken - nur den Anfangspunkt. Jetz gehe ich davon aus, dass es nicht stimmt - ein Zeiger kann seinen Bereich löschen:
int* pZeiger=new int[10]; //zuweisungen, etc delete [] pZeiger;
also muss er sich
1. den Typ der Variablen, und somit seine Größe merken (war mit bewusst)
2. die Anzahl der reservierten Objekte (tut er das???
zweites Beispiel:
int main(int argc, char**argv) { cout<<"Argument1"<<argv[1]<<endl; return 0; }
das steht so in meinem Buch drinn.
Es muss bedeuten, dass sich der dereferenzierte Zeiger-Zeiger auf char (also ein einfacher Zeiger auf char) seine Größe merken kann, da cout nur ihn ausgibt, und nicht mit dem Arbeitsspeicher dannach weitermacht. Es gibt ja die strlen-Methode. Wie funktioniert dann diese? Liest sie irgendwie die Länge des Arrays? Gibt es eine allgemeine Möglichkeit, zu erfahren, wieviel Speicher in einem Array reserviert ist? In C# geht sowas ja sehr einfach, aber wie ist das jetzt hier?
Wäre sehr Dankbar, wenn mr das jemand erklärt. -
Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!
lima-city: Gratis werbefreier Webspace für deine eigene Homepage
-
ansi-code schrieb:
ich progamiere eigentlich eher C#, und da braucht man keine Zeiger. Vor kurzem habe ich mein C++ Buch wiedergefunden aus Interesse mal reingelesen und war erstaunt darüber, dass der C++-Compiler einem ziemlich viel erlaubt. Daraufhin habe ich so lange in meinem Arbeitsspeicher "rumgepointet", bis ich dann anfing Arrays und Zeiger als das selbe zu betrachten(sie sind nicht ganz genau das selbe, oder?), und bis ich endgültig sicher war, dass sich Zeiger und Arrays ihren Speicherbereich nicht merken - nur den Anfangspunkt. Jetz gehe ich davon aus, dass es nicht stimmt - ein Zeiger kann seinen Bereich löschen:
int* pZeiger=new int[10]; //zuweisungen, etc delete [] pZeiger;
also muss er sich
1. den Typ der Variablen, und somit seine Größe merken (war mit bewusst)
2. die Anzahl der reservierten Objekte (tut er das???
Ich würd sagen, nein, tut er prinzipiell nicht. Die Anweisungen werden zur Compilezeit ersetzt durch "Reserviere 10 int" und "lösche 10 int an der und der Stelle", aber es gibt keine Möglichkeit, zur Laufzeit festzustellen, wie viele Objekte erstellt wurden.
int main(int argc, char**argv) { cout<<"Argument1"<<argv[1]<<endl; return 0; }
das steht so in meinem Buch drinn.
Es muss bedeuten, dass sich der dereferenzierte Zeiger-Zeiger auf char (also ein einfacher Zeiger auf char) seine Größe merken kann, da cout nur ihn ausgibt, und nicht mit dem Arbeitsspeicher dannach weitermacht. Es gibt ja die strlen-Methode. Wie funktioniert dann diese? Liest sie irgendwie die Länge des Arrays?
Du hast einen Zeiger auf einen char*, also einen Zeiger auf einen Zeiger. Der Sinn ist, dass Strings bei C++ so gespeichert werden: Zunächst alle Bytes des Strings nacheinenader und dann ein Nullbyte. Der char*-Zeiger zeigt dannn auf den Anfang des Strings und cout gibt solange ein Byte nach dem anderen von der Stelle, auf die argv[1] (ein char-Zeiger) zeigt aus, bis es auf ein Nullbyte trifft. strlen zählt entsprechend von der Stelle, auf die argv[1] zeigt bis zum ersten Nullbyte und gibt die Zahl zurück.
Gibt es eine allgemeine Möglichkeit, zu erfahren, wieviel Speicher in einem Array reserviert ist? In C# geht sowas ja sehr einfach, aber wie ist das jetzt hier?
Es dürfte eine Möglichkeit geben, da die Länge des Arrays ja konstant ist und der Compiler sozusagen einfach zur Compilezeit jedes vorkommen von "Arraylen" ersetzen könnte. Würsste aber nicht, wie das geht.
Zur Laufzeit dürfte es jedenfalls keine Möglichkeiten geben. -
Seit wann merkt sich ein Pointer überhaupt seine Größe? Der ist doch nur die Adresse zu einer Variable und mehr nicht.
-
schade..., na ja, trotzdem Vielen Dank für die Erklärung! Jetzt hab ich´s verstanden. Ja, das mit dem Nullzeichen kam in meinem Buch auch vor, hab nur nicht drangedacht.
Moment: eines ist noch nicht geklärt: woher weiß er vieviel er löschen, bzw. freigeben muss? Nimmt er einfach die Zahl von der Deklaration nochmal her, oder wie geht das?
Beitrag zuletzt geändert: 4.3.2009 18:56:13 von ansi-code -
Moment: eines ist noch nicht geklärt: woher weiß er vieviel er löschen, bzw. freigeben muss? Nimmt er einfach die Zahl von der Deklaration nochmal her, oder wie geht das?
Hm, ich glaub ich muss mich echt korrigieren. Beim allokieren mit "new" wird tatsächlich der Speicher zur Laufzeit reserviert, d.h. der Compiler "weiss" streng genommen nicht, wie viel allokiert werden soll. Von daher ist das, was du meintest
int* pZeiger=new int[10]; //zuweisungen, etc delete [] pZeiger;
tatsächlich seltsam und schwer zu sagen, woher er weiss, was er da machen soll...
Also, ich finde die Frage interessant, ich glaub wenn darauf niemand ne Antwort hat schau ich mir irgednwann mal den Assemblercode an und schau, wie er das genau macht :D -
Also ich bin mir auch nicht ganz sicher, aber meines Wissens läuft die Speicherallokierung für das Programm selber ohne viel eigenen Aufwand. Das Programm sagt einfach zur Speicherverwaltung(*), dass es X Bytes braucht und die Specherverwaltung sucht dann einen X Bytes großen Block heraus und gibt nen Pointer an den Anfang des Blocks zurück.
Wenn man dann free() aufruft, geht man wieder zur Speicherverwaltung und damit ist die Sache für unser Programm erledigt. Die Speicherverwaltung muss dann selber herausfinden, in welchen Teilblock der Pointer zeigt.
(*) Die Speicherverwaltung ist eine eigenständige Einheit und nicht Teil unseres Programms
Beitrag zuletzt geändert: 4.3.2009 21:51:01 von bladehunter -
Zwischen Arrays und Pointern gibt es in C++ keine Unterschiede.
new und delete ist auch nicht viel anders als malloc() und free(). D. h. die Laufzeitbibliothek und das Betriebssystem merken sich wo und welcher Speicher allokiert wurde (das muss irgendwo gespeichert werden, denn wenn ein Programm nicht ordnungsgemäß beendet wird, soll ja trotzdem der Speicher freigegeben werden). -
caiexus schrieb:
Zwischen Arrays und Pointern gibt es in C++ keine Unterschiede.
new und delete ist auch nicht viel anders als malloc() und free(). D. h. die Laufzeitbibliothek und das Betriebssystem merken sich wo und welcher Speicher allokiert wurde (das muss irgendwo gespeichert werden, denn wenn ein Programm nicht ordnungsgemäß beendet wird, soll ja trotzdem der Speicher freigegeben werden).
Das würde aber ja auch bedeuten, dass sich das Betriebssystem nicht nur merkt, welcher Speicher allgemein reserviert ist, sondern auch in irgendeiner Form die Variablennamen oder so speichert und dass das Programm dann tatsächlich nicht sagt "Gebe diese und jene Speichereinheit frei" sondern "gebe den von dieser Variablen benutzen Speicher frei". -
Das würde aber ja auch bedeuten, dass sich das Betriebssystem nicht nur merkt, welcher Speicher allgemein reserviert ist, sondern auch in irgendeiner Form die Variablennamen oder so speichert und dass das Programm dann tatsächlich nicht sagt "Gebe diese und jene Speichereinheit frei" sondern "gebe den von dieser Variablen benutzen Speicher frei".
Also, sobald ein Programm gestartet werden soll, bekommt es erstmal einen durchgängigen Speicherbereich im RAM zugeteilt. In diesen Speicherbereich wird dann
-der Maschinencode des Programms
-die globalen und statischen Variablen
gespeichert.
Der Bereich nach den statischen Variablen ist der Beginn vom Heap. Das Ende des zugewiesenen Speicherbereichs bildet den Stack (dazwischen ist nicht genutzter Speicher). Auf dem Stack werden dann die "normalen", globalen Variablen abgelegt (zur näheren Erläuterung zum Stack hier schauen: http://de.wikipedia.org/wiki/Stapelspeicher )
Wobei sowohl der Heap und der Stack keine feste Größe haben und am Anfang leer sind. Sie wachsen dann im Laufe der Zeit, wenn Variablen angelegt werden.(*)
Auf dem Stack landen die lokalen Variablen. Der Stack ist eine sehr übersichtliche Datenstruktur, wo neue Variablen immer sofort einen Speicherbereich zugewiesen werden können, da nicht mehr verwendete, lokale Variablen bequem von dem oberen Ende des Stacks gelöscht werden können. Anders (aber vereinfacht) gesagt: Der Stack ist sortiert.
Der Heap hingegen ist ein unsortierter Speicherbereich, aus dem an beliebiger Stelle Daten ablegt werden könnten(**). Jedoch hat man natürlich nicht unendlich viel Platz und daher muss man sich immer ein freies Speichersegment raussuchen, dass groß genug ist. Der Heap ist im Gegensatz zum Stack also nicht sortiert und man braucht etwas, dass den Heap deshalb verwalten kann: Unsere Speicherverwaltung.
Beendet sich jetzt ein Programm, so weiß die Speicherverwaltung, welchen durchgängigen Speicherbereichdas Programm nutzen konnte und gibt diesen wieder frei für das nächste Programm.
(*) Heap und Stack wachsen auf einander zu. Es ist also denkbar, dass sie sich den Speicherplatz gegenseitig streitig machen.
(**) Die Konsequenz davon ist, dass der Heap fragmentiert. -
Was aber noch nicht erklärt, warum ein Array, das auf dem Stack angelegt wird, mit delete[] gelöscht werden kann. Wo wird die Länge des Arrays gespeichert?
-
caiexus schrieb:
Was aber noch nicht erklärt, warum ein Array, das auf dem Stack angelegt wird, mit delete[] gelöscht werden kann. Wo wird die Länge des Arrays gespeichert?
afaik liegt per new reservierter Speicher auf dem Heap. Die Fragestellung bleibt aber nubeeindruck davon.
@bladehunter: Joa, alles schon bekannt, ist aber nicht, wa sich meinte. Mir ist klar, dass das Betriebssystem am Ende des Programmes einfach alles freigibt, was vom Programm eingenommen war, das ist dann ja auch kein Problem.
Die Frage ist: Eine Anweisung wie "int* pointer = new int[23]", was macht die genau? Weist die eine vom Programm unabhängige Betriebssystemgebundene Speicherverwaltung dazu an, 23 ints zu reservieren und einen Pointer darauf zurückzugeben, oder reserviert sie 23 ints und gibt einen Zeiger darauf zurück. Letzteres halte ich für unwahrscheinlich, weil das Programm dann Logik implementieren müsste, um sich zu merken, welcher Teil des Programm-Heaps bereits verwendet wird und welcher nicht und zumindest der Assemblercode den ich mir bisher angeschaut habe von einfachen Programmen ist dazu denk ich zu einfach.
Ersteres wirft die Frage auf, wenn dann "delete [] pointer" aufgerufen wird, woher weiss die Speicherverwaltung dann, wieviele ints freigegeben werde müssen? Das ist generell uninteressant für den Programmierer, aber mich zumindest interessiert es trotzdem ;)
Was ich mir tatsächlich vorstellen kann ist, dass die Speicherverwaltung speichert "als die Speicheraddresse 123456 reserviert wurd, wurden gleichzeitig 23 ints hintereinander reserviert", dass sie also eine Tabelle hat für alle "new int[n]"-Anweisungen, die der Speicheraddresse jeweils die Anzahl reservierter Einheiten zuordnet. Bei der "delete []" Anweisung wird dann die freizugebende Addresse in dieser Tabelle nachgeschlagen und die entsprechende Anzahl an Bytes freigegeben.
Zumindest ist das eine Möglichkeit, die ich mir vorstellen könnte, um sowas zu implementieren. Es bedeutet auch, dass die Anweisung "new int[1]" grundverschieden ist von "new int", was den Speicherbedraf und die Performance angeht... -
merovius schrieb:
Die Frage ist: Eine Anweisung wie "int* pointer = new int[23]", was macht die genau?
Weist die eine vom Programm unabhängige Betriebssystemgebundene Speicherverwaltung dazu an, 23 ints zu reservieren und einen Pointer darauf zurückzugeben,
oder
reserviert sie 23 ints und gibt einen Zeiger darauf zurück.
Mir ist nicht ganz klar, wo jetzt der Unterschied in den beiden Fällen ist. Ich beschreibe daher meine Interpretation:
Die Anweisung "int* pointer = new int[23]" legt letzendlich 2(!) Variablen an. Eine Variable auf dem Stack und ein Speicherblock bzw. Array auf dem Heap. Die Variable auf dem Stack ist der Pointer, der auf den Speicherblock im Heap zeigt.
Letzteres halte ich für unwahrscheinlich, weil das Programm dann Logik implementieren müsste, um sich zu merken, welcher Teil des Programm-Heaps bereits verwendet wird und welcher nicht und zumindest der Assemblercode den ich mir bisher angeschaut habe von einfachen Programmen ist dazu denk ich zu einfach.
Richtig. Die Speicherverwaltung hat also 2 Aufgaben:
1. Die primäre Zuweisung eines großen Speicherblocks, wo dann das Programm und seine Variablen hineingeladen werden können
2. die Verwaltung des Heaps des Programms (welcher ein Teilstück des in 1 zugewiesenen Speicherbereichs ist)
Ersteres wirft die Frage auf, wenn dann "delete [] pointer" aufgerufen wird, woher weiss die Speicherverwaltung dann, wieviele ints freigegeben werde müssen?
Das weiß sie, weil sie es wissen muss.
Die Speicherverwaltung muss sich ja auch merken, welche Abschnitte sie bereits vergeben hat, damit sie diese nicht noch einmal bei malloc() oder new vergibt. Dieses Wissen kann sie auch verwenden, um die Speicherblöcke, die man mit free() und delete angibt, wieder freizugeben. Sollte man mit dem Pointer nicht mehr auf den Anfang des Speicherblocks zeigen, muss die Speicherverwaltung halt (je nach Implemtierung der Speicherverwaltung) den Pointer trotzdem irgendwie den entsprechenden Block zuordnen.
Das ist generell uninteressant für den Programmierer, aber mich zumindest interessiert es trotzdem ;)
Merkt man. Sonst würdest du auch kein Assembler lernen^^
Irgendwelche Tutorials die du wärmstens empfehlen kannst?
Was ich mir tatsächlich vorstellen kann ist, dass die Speicherverwaltung speichert "als die Speicheraddresse 123456 reserviert wurd, wurden gleichzeitig 23 ints hintereinander reserviert", dass sie also eine Tabelle hat für alle "new int[n]"-Anweisungen, die der Speicheraddresse jeweils die Anzahl reservierter Einheiten zuordnet. Bei der "delete []" Anweisung wird dann die freizugebende Addresse in dieser Tabelle nachgeschlagen und die entsprechende Anzahl an Bytes freigegeben.
OK, wie ich sehe, bist du selber darauf gekommen.
Zumindest ist das eine Möglichkeit, die ich mir vorstellen könnte, um sowas zu implementieren. Es bedeutet auch, dass die Anweisung "new int[1]" grundverschieden ist von "new int", was den Speicherbedraf und die Performance angeht...
Also ich habe gerade mal ein Beispielprogramm geschrieben:
int * foo = new int;
Und mir das ganze im Debugger angeschaut. Wie es aussieht, ist der Zeiger "foo *" an einer deutlich höheren Stelle im Speicherbereich, als das int-Objekt, das erzeugt wurde. Daher schlussfolgere ich, dass, jedes Objekt (also, alles, was grundsätzlich mit new angelegt wird) auf dem Heap landet. Entsprechend ist es daher schon einmal egal, ob mit oder ohne eckige Klammer. -
afaik liegt per new reservierter Speicher auf dem Heap. Die Fragestellung bleibt aber nubeeindruck davon.
Leider kann man es den Speicheraddressen nicht ansehen, die sind egal ob ich es mit malloc oder new mache ganz nahe beisammen.Die Frage ist: Eine Anweisung wie "int* pointer = new int[23]", was macht die genau?
das ist einfach zu beantworten: das ist ein static array. Es ist Standardverhalten, dass er sich merkt, wie groß das ist (die Größe ist ja bereits vor der Kompilierung bekannt).
Trotzdem sollte so etwas:
natürlich nicht funktionieren. Das sind irgendwelche nicht standardmäßigen Compiler-Features.#include <iostream.h> int main(int argc, char *argv[]) { int n; cin >> n; int b[n]; cout << sizeof(b); system("PAUSE"); -
Es ist Standardverhalten, dass er sich merkt, wie groß das ist (die Größe ist ja bereits vor der Kompilierung bekannt).
Trotzdem sollte so etwas:
natürlich nicht funktionieren. Das sind irgendwelche nicht standardmäßigen Compiler-Features.#include <iostream.h> int main(int argc, char *argv[]) { int n; cin >> n; int b[n]; cout << sizeof(b); system("PAUSE");
Leider ist Alice Scheisse, deswegen kann ich keinen Link geben (Alice behauptet die Seite existiert nicht), aber das C++-Language-Tutorial auf www.cpluspluc.com behauptet da anderes, die bringen nämlich ziemlich genau das Beispiel, soweit ich mich entsinne. Ansonsten hätten wir ja die Diskussion nicht ;) -
was behaupten die denn...?
also wenn ich den gcc mit -pedantic aufrufe verweigert er die Kompilierung mit der Meldung "ISO C++ forbids variable-size array `b' "
scheint also nicht dem Standard zu entsprechen.Ansonsten hätten wir ja die Diskussion nicht ;)
ja, sorry, hat zwar lange gedauert, aber ich bin wenigstens der erste, der versteht, was dein Problem ist
Beitrag zuletzt geändert: 5.3.2009 22:38:26 von caiexus -
caiexus schrieb:
was behaupten die denn...?
also wenn ich den gcc mit -pedantic aufrufe verweigert er die Kompilierung mit der Meldung "ISO C++ forbids variable-size array `b' "
scheint also nicht dem Standard zu entsprechen.
http://www.cplusplus.com/doc/tutorial/dynamic.html -
da wird aber doch ein new verwendet
#include <iostream.h> int main(int argc, char *argv[]) { int n; cin >> n; int * a = new int[n]; int b[n]; cout << sizeof(b) << "\n"; cout << sizeof(a); system("PAUSE"); }
Eingabe: 10
Ausgabe:
40
4
Beitrag zuletzt geändert: 5.3.2009 22:44:49 von caiexus -
caiexus schrieb:
da wird aber doch ein new verwendet
#include <iostream.h> int main(int argc, char *argv[]) { int n; cin >> n; int * a = new int[n]; int b[n]; cout << sizeof(b) << "\n"; cout << sizeof(a); system("PAUSE"); }
Eingabe: 10
Ausgabe:
40
4
Oops, klar, hab mir deinen Source offenbar nicht genau genug angeschaut. Also, um es noch mal klar auszudrücken: Mein Problem ist halt das hier:
#include <iostream> using namespace std; int main() { int n = 0; cin >> n; int* pointer = new int[n]; delete [] pointer; }
Darauf bezieht sich die Frage, der Compiler kann da nicht wissen, wie groß das Array ist, wo wird also zur Laufzeit die Größe des reservierten Speichers gespeichert, damit es korrekt von delete [] gelöscht werden kann?
Mir ist nicht ganz klar, wo jetzt der Unterschied in den beiden Fällen ist.
Ganz einfach, bei dem einen reserviert das Programm den Speicher und merkt sich, welcher Speicher bereits reserviert ist und welcher nicht, bei der anderen übernimmt das eine externe Speicherverwaltung. Der Unterschied ist, wo die Programmlogik zur Reservierung des "Programm-Heaps" liegt.
Das weiß sie, weil sie es wissen muss.
Die Speicherverwaltung muss sich ja auch merken, welche Abschnitte sie bereits vergeben hat, damit sie diese nicht noch einmal bei malloc() oder new vergibt. Dieses Wissen kann sie auch verwenden, um die Speicherblöcke, die man mit free() und delete angibt, wieder freizugeben. Sollte man mit dem Pointer nicht mehr auf den Anfang des Speicherblocks zeigen, muss die Speicherverwaltung halt (je nach Implemtierung der Speicherverwaltung) den Pointer trotzdem irgendwie den entsprechenden Block zuordnen.
Die Speicherung der "Freiheit" von Speicher lässt sich auch mit einer einfachen binären Abbildung implementieren, sprich, es existiert ein Speicherbereich in dem jedem Speicherblock eine 0 oder eine 1 zugewiesen ist, ob er vergeben ist oder nicht. Aus so einer Abbildung lässt sich allerdings nicht rekonstruieren, welche dieser Blöcke gemeinsam allokiert wurden udn welche nicht, ergo, welche Blöcke gemeinsam freigegeben werden müssen und welche nicht.
Merkt man. Sonst würdest du auch kein Assembler lernen^^
Irgendwelche Tutorials die du wärmstens empfehlen kannst?
Sorry, nicht wirklich, bisher waren alle Tutorials eher mittelmäßig, erst durch das Lesen vieler verschiedener Tutorials mit verschiedenen Zielen verschafft einem den Überblick, wie der ganze Kram funktioniert.
Entsprechend ist es daher schon einmal egal, ob mit oder ohne eckige Klammer.
Wie gesagt, der Unterschied liegt in obigem Problem mit der binären Abbildung im Gegensatz zu dem, was ich beschrieben habe, was quasi eine zusätzliche Tabelle erfordert, die speziell beschreibt, weilche Blöcke zusammen hängen. -
Wie du merkst habe ich Ferien
Darauf bezieht sich die Frage, der Compiler kann da nicht wissen, wie groß das Array ist, wo wird also zur Laufzeit die Größe des reservierten Speichers gespeichert, damit es korrekt von delete [] gelöscht werden kann?
Ich denke, das wird genauso vom Betriebssystem gespeichert???
Warum ist das ein Problem für dich? Wenn man mit new einen Array anlegt, weiß er ja wie viel Speicher er anfordern muss n*sizeof(...) . Das Betriebssystem merkt sich einzig und allein von wo bis wo der Speicherblock geht, delete [] gibt die Anweisung ans Betriebssystem, den Block wieder freizugeben. -
Wie du merkst habe ich Ferien
Willkommen im Club! Ich bin Clubpräsident! ^^
Ich denke, das wird genauso vom Betriebssystem gespeichert???
Warum ist das ein Problem für dich? Wenn man mit new einen Array anlegt, weiß er ja wie viel Speicher er anfordern muss n*sizeof(...) . Das Betriebssystem merkt sich einzig und allein von wo bis wo der Speicherblock geht, delete [] gibt die Anweisung ans Betriebssystem, den Block wieder freizugeben.
Solang es also wirklich so eine Tabelle gibt, wie ich sagte, dann bin ich auch zufrieden. Die Idee ist mir ehrlich gesagt auch erst gekommen, als ich sie aufgeschrieben hab. Dennoch erscheint mir das ineffizient... Ich mein, für die reine Tabelle "belegt oder nicht" geht ja schon plusminus ein Achtel des Speichers drauf (wenn man davon ausgeht, dass pro Byte ein Bit verwendet wird). Dazu dann noch die Tabelle für zusammenhängende Speicherblöcke, die auch recht teuer werden dürfte (bis zu 8 Byte pro zusammenhängenden Block)...
Naja, wenn irgendwer ne Quelle hätte, wo einmal genau beschrieben ist, wie moderne Betriebssysteme das regeln, wäre ich dankbar, sonst bin ich aber auch erstmal zufrieden ^^ -
Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!
lima-city: Gratis werbefreier Webspace für deine eigene Homepage
