void* oder unsigned int* ?

[Dirty Oerti]

Tag

Nochwas (bin heute wissbegierig):

Ich hab Speicherbereiche, die ich immer wieder an versch. Funktionen übergeben muss.
Übergebe ich die Adresse besser in einem void* oder in einem unsigned int* ?

[cloidnerux]

Hängt doch davon ab was sie beinhalten.
Aber ich neheme an es ist für deinen Kernel.
Ich glaube void* ist standart und void* ist besser, nicht zuletzt wegen der kürzeren schreibweise

[fat-lobyte]

Ich hab Speicherbereiche, die ich immer wieder an versch. Funktionen übergeben muss.
Übergebe ich die Adresse besser in einem void* oder in einem unsigned int* ?

Also unsigned int* für reinen Speicher wäre unlogisch. Wohl eher unsigned char*, da kannst du byteweise durchiterieren. Aber...

Hängt doch davon ab was sie beinhalten.

Genau.

Deswegen Frage ich, wieso muss es void* oder unsigned int* sein? Wieso kann es nicht DerDatentypDenDuBrauchst* sein?
Die Geschichte mit den void* Zeigern ist ziemlich gefährlich, und eine der Hauptgründe wieso C als nicht "typsicher genug" gilt.

[Dirty Oerti]

Deswegen Frage ich, wieso muss es void* oder unsigned int* sein? Wieso kann es nicht DerDatentypDenDuBrauchst* sein?

Es ist (wie cloidnerux schon erkannt hat) für meinen Kernel.
Das Problem ist:
Ich weiß nicht, welchen Datentyp ich brauche.
Wie würdest du 4KB (bzw variabel) große Speicherbereiche ansprechen.

Die Entscheidung brauche ich für eine Funktion, die den entsprechenden Speicher null setzt.

Also: Die Funktion bekommt eine Adresse. Und dazu noch einen Wert (der angibt, wie oft sie schreiben soll). Und dann beschreibt die Funktion den Speicherbereich in gewissen Schritten:

memset8 -> ein Byte Schritte (notwendig, um z.B. einen 3 Byte großen Bereich zu beschreiben)
memset16 -> zwei Byte auf einmal schreiben
memset32 -> 4 Byte auf einmal schreiben
(evtl) memset64 -> 8 Byte auf einmal schreiben

Oder soll ich für memset8 char*, für memset16 short* etc nehmen?

Die Geschichte mit den void* Zeigern ist ziemlich gefährlich, und eine der Hauptgründe wieso C als nicht "typsicher genug" gilt.

Erzähl...? *Die Geschichte hören möchte*

[Xin]

Wie würdest du 4KB (bzw variabel) große Speicherbereiche ansprechen.
Die Entscheidung brauche ich für eine Funktion, die den entsprechenden Speicher null setzt.

Also: Die Funktion bekommt eine Adresse. Und dazu noch einen Wert (der angibt, wie oft sie schreiben soll). Und dann beschreibt die Funktion den Speicherbereich in gewissen Schritten:

memset8 -> ein Byte Schritte (notwendig, um z.B. einen 3 Byte großen Bereich zu beschreiben)
memset16 -> zwei Byte auf einmal schreiben
memset32 -> 4 Byte auf einmal schreiben
(evtl) memset64 -> 8 Byte auf einmal schreiben

Oder soll ich für memset8 char*, für memset16 short* etc nehmen?

Nimm ein Menory-Handle, dass Du intern als Union verbrätst.

Die Geschichte mit den void* Zeigern ist ziemlich gefährlich, und eine der Hauptgründe wieso C als nicht "typsicher genug" gilt.

Erzähl...? *Die Geschichte hören möchte*

Du schreibst ein OS... Typsicherheit ist was für Anwendungen... bei einem OS ist es wichtig, aber das OS darf sich darüber hinwegsetzen. Von daher kannst Du eh nach belieben casten.

[Dirty Oerti]

Nimm ein Menory-Handle, dass Du intern als Union verbrätst.

Hm, verstehe nicht so ganz, was du meinst.

Code: Alles auswählen

union address {
  unsigned int* INT;
  unsigned char* CHAR;
  unsigned short* SHORT;
};

Oder wie?
Dabei fällt mir auf: Unions fehlen in unserem Tutorial noch...

Du schreibst ein OS... Typsicherheit ist was für Anwendungen... bei einem OS ist es wichtig, aber das OS darf sich darüber hinwegsetzen. Von daher kannst Du eh nach belieben casten.

Ja... ich versuche das ganz nur möglichst.... "richtig" zu schreiben

[Xin]

Nimm ein Menory-Handle, dass Du intern als Union verbrätst.

Hm, verstehe nicht so ganz, was du meinst.

Code: Alles auswählen

union address {
  unsigned int* INT;
  unsigned char* CHAR;
  unsigned short* SHORT;
};

Oder wie?

Genau. Intern reichst Du eine "address" rum. Damit weißt Du für Dich, dass das eine Adresse auf einen Speicherblock ist, die Du in Deinem OS nach belieben verwalten darfst. Als OS weißt Du ja nicht, was da letztendlich drin ist. Möchtest Du Bytegenau zugreifen kannst Du das, darf es etwas schneller sein, geht das auch.

Mal so grob und ungetestet aus dem Kopf:

Code: Alles auswählen

struct MemBlock
{
  address Address;
  unsigned int Size;
}

void clear( MemBlock memblock )
{
  int size = memblock.Size >> 2;
  while( size-- ) memblock.Address.INT[ size ] = 0;                  // 32 Bit Schritte

  int size = memblock.Size - (memBlock.Size & 3)
  while( size < memBlock.Size ) memblock.Address.CHAR[ size ] = 0;  // Restgröße in 8 Bit Schritten
}

Dabei fällt mir auf: Unions fehlen in unserem Tutorial noch...

Hast Du es schon in die Todo-Liste geschrieben, hier findet es schließlich niemand wieder. ^^
Ich hab's eingetragen.

Du schreibst ein OS... Typsicherheit ist was für Anwendungen... bei einem OS ist es wichtig, aber das OS darf sich darüber hinwegsetzen. Von daher kannst Du eh nach belieben casten.

Ja... ich versuche das ganz nur möglichst.... "richtig" zu schreiben

Kann ich mir schon vorstellen.

Info am Rande: Ich versuche mich Sonntag an GIT.

[Dirty Oerti]

Hm...
das sieht gut aus
(eine intelligente "clear" Funktion hatte ich mir für die neue Version des Kernels auch schon überlegt, diese ist aber schneller)

Eine Frage:

Ich hab mein union address (wie oben gepostet).
Dem weiße ich nun eine Adresse zu.
Nun nehme ich den Byte-Wert, und gehe damit einen Schritt weiter.
Was steht jetzt im INT-Wert?

Code: Alles auswählen

address AD;
AD.INT = (unsigned int*) POSITION;
AD.CHAR++;

Wie sieht's jetzt mit AD.INT aus?
Wo zeigt das hin?


Mal eine Frage am Rande... kann ich mit unsigned char* Pointern die vollen 4GB (auf 32 Bit) ansprechen...?
Eigntl schon...oder?

Info am Rande: Ich versuche mich Sonntag an GIT.

Gut

[Xin]

Ich hab mein union address (wie oben gepostet).
Dem weiße ich nun eine Adresse zu.
Nun nehme ich den Byte-Wert, und gehe damit einen Schritt weiter.
Was steht jetzt im INT-Wert?

Der zeigt nun ein Byte weiter. Es sind ja alles nur Zeiger.
Ein char Zeiger wird mit ++ um 1 Byte verschoben, ein int Zeiger um 4 Byte.
Eben immer

Code: Alles auswählen

Zeiger += sizeof( Zeiger )

Je nach Prozessor könntest Du damit Alignment-Schwierigkeiten bekommen, was aber heutzutage eher unwahrscheinlich ist.
Da Du ein x86-OS schreibst... solltest Du keine Probleme erwarten.