Hvad mon...

Og kan man evt. lave noget tilsvarende med new ?

unsigned char bufferz[2100];

allokerer et array af 2100 char uden at initalisere det.

SomeStruct *Pointer = (SomeStruct *)bufferz;

allokerer en pointer til SomeStruct og initialiserer den til
at pege på char arrayet.

Når man så laver:
  Pointer->felt1 = 1;
  Pointer->felt2 = 2;
  Pointer->felt3 = 3;

Så initialiserer man det Pointer peger på nemlig char arrayet.

Ja, man kan også lave:

char* bufferz = new char[2100];
SomeStruct *Pointer = (SomeStruct *)bufferz;

Jow, men jeg tænkte på, om man kunne erstatte SomeStruct *Pointer = (SomeStruct *)bufferz; med new et-eller-andet ?

new bruger du kun når du skal allokerer ny plads, medmindre at du ønsker at lave en kopi af nogle data!
Ved dit eksempel type caster du dig frem til at ændre din char* pointer til at være af typen SomeStruct* derfor opstår der ikke nye data.

Hvis vi nu ser helt bort fra bufferz, kan man så ikke bruge new til at gøre det samme som man gør med Pointer = (SomeStruct *)bufferz ? Jeg ved godt at der ikke bliver allokeret hukommelse her. noget i retning af Pointer = new SomeStruct[2100] eller er det ikke det samme ?

Nej - det er noget helt andet.

Der allokerer man 2100 nye SomeStruct.

SomeStruct *Pointer = new SomeStruct[2100];
Gør "næsten" det samme, den ene opretter bare på heapen og den anden på stacken.
Derfor er du nød til hvis du har brugt new, at slette pladsen igen:
delete Pointer;

Den anden slettes automatisk, når den løber ud af scope.

twm>

Det mener du ikke.

SomeStruct *Pointer = (SomeStruct *)bufferz;

Opretter aldrig noget som helst (jo en pointer men det ikke pointen)
og det den pointer peger på kan både ligge i heap eller på stak
(afhængig af hvor bufferz er erklæret).

Og:
  new SomeStruct[2100]
allokerer ikke 2100 bytes men 2100*sizeof(SomeStruct) bytes.

Hvad så med Pointer = new SomeStruct[2100/sizeof(SomeStruct)] ??

Hvis sizeof(SomeStruct) går op i 2100, så vil den allokere 2100 bytes.

Men altså det den konstruktion ofte bruges til er noget helt andet.

Man har typisk en klump data læst op i et char array.

Inde i den klump data er der så nogle data-strukturer og
når man skal have fat i dem, så laver man det her nummer:

char bigbuf[100000];
SomeStruct1* p1 = (SomeStruct1*)bigbuf;
SomeStruct2* p2 = (SomeStruct2*)(bigbuf+p1->record_length);
etc.

Hvis den feks fyldte 10 byte ville den allokere plads til 210 somestruct og ikke bytes!
;)

Okay, fint nok

Så er der altså ikke noget alternativ til Pointer = (SomeStruct *)bufferz ?

Ikke umiddelbart.

Det er muligt at du kan ændre noget i den overordnede logik.

Hvor du i.s.f. at læse ind i et char array og så ligge en struct
ind over det bagefter kan læse direkte ind i en struct.

Men det er den overordnede struktur i dit program.

Okay, jeg takker.