Pointer auf Pointer von Array mit Werten des Types BYTE

e*mc*

Hallo alle miteinander,

folgendes Problem ich will einer Funktion einen Pointer übergeben und diesen Pointer wird in der Funktion ein Pointer auf ein Dynamische erzeugtes Array vom Typ BYTE übergeben. Nun ist die Frage, wie initialisiere ich die Pointer und wie sieht die übergabe aus? Ist das überhaupt möglich oder sollte man das anders machen.
Hier mein Lösungsansatz.

int func(BYTE ???)
{
  // hier wird der Pointer vom Dynamisch erzeugten Array übergeben.
  // 
  return 0;
} 

// Aufrufende Funktion
...
BYTE (**ppa)[]; // Pointer auf Pointer auf Array von BYTE Werten
// wie muß ich ppa initialisieren
func(???);

// Zugriff auf die BYTES im Array
...

Danke im voraus.

Mal langsam - deine Funktion erzeugt ein Array von BYTE-Werten und will sie nach außen übergeben, richtig?

int func(BYTE*& target, int count)
{
  target=new BYTE[count];
  return 0;
}

int main()
{
  BYTE* arr;
  func(arr,100);
  ...
}

(btw, dein 'ppa', wie du es deklariert hast, ist ein Array (unbestimmter Größe) von BYTE**-Werten - das sollte nicht einmal am Compiler vorbeikommen)

e*mc*

Hallo,

danke für deine Antwort, das ist das was ich gesucht habe.
Habe aber noch eine Frage.
Ich möchte gerne die Größe des Erzeugten Arrays bestimmen, leider funktioniert das nicht so wie ich das möchte.

int nValue = (sizeof(byBuffer) / sizeof(byBuffer[0])); // ist 4

Müßte ja, wenn man deinen Code nimmt, 100 sein.
Oder bekommt man nur die Anzahl Bytes, die ein Pointer hat?

LordJaxom

Garnicht. Sobald der Compiler nur noch von einem Pointer (oder dimensionslosem Array) weiss ist das Ding 4 Byte groß (32-bit), ein Pointer halt.

Sizeof zur Längenbestimmung geht nur wenn der Compiler zugriff auf die Dimensionen hat.

BYTE array[100];
BYTE *pointer = array;

sizeof(array) / sizeof(BYTE) // 100
sizeof(pointer) / sizeof(BYTE) // 4

KPC

Mit sizeof bekommst du immer nur die Größe des Datentyps, in deinem Fall die eines Byte * und der ist wie du schon gesagt hast 4 Byte groß! Du musst dir also bei der Speicheranforderung mit new selber merken wieviele Elemente du erzeugt hast!

Du könntest dich aber auch komplett von der manuellen Speicherverwaltung trennen und stattdessen mit STL-Containern arbeiten - die kümmern sich selber darum, genügend Platz bereitzustellen, und sie können dir sogar sagen, wieviel Platz sie aktuell belegt haben.

Bashar

CStoll (off) schrieb:

(btw, dein 'ppa', wie du es deklariert hast, ist ein Array (unbestimmter Größe) von BYTE**-Werten

Nein, es erzeugt einen Pointer auf einen Pointer auf ein BYTE-Array unbestimmter Größe. Dass es nicht am Compiler vorbeikommt, stimmt allerdings

e*mc*

LordJaxom schrieb:

Garnicht. Sobald der Compiler nur noch von einem Pointer (oder dimensionslosem Array) weiss ist das Ding 4 Byte groß (32-bit), ein Pointer halt.

Sizeof zur Längenbestimmung geht nur wenn der Compiler zugriff auf die Dimensionen hat.
BYTE array[100];
BYTE *pointer = array;

sizeof(array) / sizeof(BYTE) // 100
sizeof(pointer) / sizeof(BYTE) // 4

Dann würde ja

sizeof(*pointer) / sizeof(BYTE) // 100

ergeben, oder etwa nicht?!

Bashar

e=mc² schrieb:

Dann würde ja
sizeof(*pointer) / sizeof(BYTE) // 100
ergeben, oder etwa nicht?!

*pointer hat den Typ BYTE, also ist obiger Ausdruck 1.

e=mc² schrieb:

Dann würde ja
sizeof(*pointer) / sizeof(BYTE) // 100
ergeben, oder etwa nicht?!

Nein, das ergibt 1 (*pointer ist das erste BYTE in deinem Array).