[C] ruimte reserveren voor struct met pointer

[decoy]

Ik gebruik het volgende struct:

struct CBUF {
unsigned char count;
unsigned char size;
unsigned char ibx;
unsigned char obx;
unsigned char *buf;
}


Een globale variablele:
struct CBUF * TX_cir_buf;


In de initialisatie routine zit ik met de vraag hoe ik op de juiste manier ruimte reserveer voor de buffer

struct CBUF *buffer_create (unsigned char buf_size)
{
struct CBUF *tmp;

tmp->size = buf_size;
tmp->count = 0;
tmp->idx = 0;
tmp->odx = 0;

De vraag !!!
Reserveer ik nu zo de juiste hoeveelheid geheugen:
tmp = (struct CBUF * ) malloc (sizeof (struct CBUF));
tmp->buf = (unsigned char * ) malloc (buf_size);

OF
tmp = (struct CBUF * ) malloc (sizeof (struct CBUF) + buf_size);
tmp->buf = (unsigned char * ) malloc (buf_size);



return tmp;
}


(voor de vorm de main erbij)
void main (void)
{
TX_circ_buf = buffer_create(100);

while (1)
{
; //een heleboel
}
}

[Verwijderd]

Sourcecode ziet er stukken beter uit als je die tussen [ code ] [ / code ] tags zet (zonder spaties).

[Olaf van der Spek]

Volgens mij moet je de eerste oplossing gebruiken, anders reserveer je voor buf twee keer ruimte.

[Verwijderd]

Nog een kleine opmerking: het is belangrijk dat je die struct eerst malloc't, en daarna pas de velden waarden gaat geven.

[The - DDD]

En het is HET buffer.

Ik zeg ook de eerste.

code:

   tmp = (struct CBUF * ) malloc (sizeof (struct CBUF));
   tmp->buf = (unsigned char * ) malloc (buf_size);

OF

code:

   tmp = (struct CBUF * ) malloc (sizeof (struct CBUF) + buf_size);
   tmp->buf = (unsigned char * ) malloc (buf_size);

Je reserveert twee keer geheugen. 1 keer voor de structure en 1 keer voor de structure waar tmp->buf naar moet verwijzen. De geheugen allocaties van die twee buffers heeft niks met elkaar te maken.

CBUF bevat een pointer naar een bepaald iets (kan ik nu even niet zien in mijn edit schermpje). De ruimte voor deze pointer wordt voor je gealloceerd door malloc (sizeof...

Imers die pointer is onderdeel van de structure die je alloceerd. Vervolgens ga je nog deze pointer, die dus al in je gehuegen staat laten wijzen naar een stuk geheugen wat je daarna alloceerd.

Ik krijg het idee dat je een hele lange rij met van die structures gaat maken.

ALs je wilt kan wel in 1 keer alle benodigde ruimte alloceren. En dan vervolgens zelf de juiste pointer waarden uitrekenen.

code:

pointerToStructWithPointer = (void) malloc ( sizeof(structWithPointer) + sizeof(structWithoutPointer) );
pointerToStructWithoutPointer = (void) ( pointerToStructWithPointer + sizeof(structWithoutPointer) );

Scheelt je weer een geheugen allocatie, iets wat altijd lang duurt. Maar dit valt onder de stap code optimalisatie.

Stel dat je van tevoren weet dat je een boom van structuren hebt van een bepaald aantal. Dan kun je natuurlijk prima dit geheugen in 1 keer alloceren. Je moet er vervolgens alleen wel wat rekenwerk achteraan doen. Maar dat is nog altijd sneller dan alsmaar malloc aanroepen.

!Edit!
Pas hiermee wel op met het vrijgeven van je geheugen. DIt kan alleen via een pointer naar het begin van het gealloceerde geheugen.

Tevens geeft een free al het geheugen in het complete buffer vrij. Dus alle data (structures en primitieven) worden tegelijk vrij gegeven en zodoende kan het zijn dat je een hele hoop pointers op NULL moet zetten. En je weet een loze pointer zet die altijd op 0. SCheelt je een hoop gelazer mocht je wel stom genoeg zijn om het ding aan te spreken.
!~Edit!

Is het trouwens zo dat je alloceren met 1 of 2 c's schrijft. Ik twijfel er altijd over

[Verwijderd]

Op dinsdag 01 januari 2002 19:32 schreef The - DDD het volgende:
En het is HET buffer.

Ik citeer Van Dale :

buf·fer (de ~ (m.))

1 elk van de paarsgewijs aan de kopeinden van locomotieven en wagons aangebrachte stootkussens
2 tijdelijke bewaarplaats voor tekens in het intern geheugen van een computer

Edit:

Alloc(c)eren staat niet er niet in, 'allocatie' wel.

[The - DDD]

Oeps..

De buffer komt toch raar op me over...

[.oisyn]

Op woensdag 02 januari 2002 02:58 schreef The - DDD het volgende:
Oeps..

De buffer komt toch raar op me over...

misschien ben je in de war met HET buffet (vreetzak! )

.edit:

Imers die pointer is onderdeel...

Immers,

code:

pointerToStructWithPointer = (void) malloc ( sizeof(structWithPointer)
    + sizeof(structWithoutPointer) );
pointerToStructWithoutPointer = (void) ( pointerToStructWithPointer
    + sizeof(structWithoutPointer) );

Maak daar maar (void * ) van ipv (void) ... overigens hoeft dat nog niet eens, aangezien je in C gewoon kunt converten van void * naar bijvoorbeeld char *
Dat rekenen gaat daar echt niet goed, aangezien je met elementen rekent en niet met bytes (dus structPtr + 4 is eigenlijk hetzelfde als structPtr[4]). En als het een void * is (kan ik hier uit je verhaal niet opmaken), dan klopt het ook niet aangezien void geen grootte heeft (maar meestal resulteert dat in een warning dat de compiler de grootte van void niet weet, en dat ie daarom aanneemt dat het 1 is, en anders dus gewoon een error)

Daarom werkt dit beter:

code:

tmp = malloc (sizeof (*tmp) + bufsize);
temp->buf = (char *)tmp + bufsize;

Maar ja, als die buf dan toch altijd gelijk achter de structure komt, kun je beter je struct anders declareren:

code:

struct CBUF
{
    ...
    char buf[1];
};

Dan hoef je alleen maar een struct te alloceren met een extra buffer size, en dan kun je buf gewoon gebruiken voor de chararray (zonder dat je dus een pointer gebruikt)
Overigens moet je van het aantal bytes dat je alloceert 1 aftrekken, aangezien je anders dan die ene byte van de buffer die al in de struct zit dubbel alloceert.

dus:

code:

temp = malloc (sizeof (*tmp) + bufsize - 1));

en dan ben je al klaar

[MSalters]

Op woensdag 02 januari 2002 03:01 schreef OiSyN het volgende:
...
Daarom werkt dit beter:

code:

tmp = malloc (sizeof (*tmp) + bufsize);
temp->buf = (char *)tmp + bufsize;

Maar ja, als die buf dan toch altijd gelijk achter de structure komt, kun je beter je struct anders declareren:

code:

struct CBUF
{
    ...
    char buf[1];
};

Dan hoef je alleen maar een struct te alloceren met een extra buffer size, en dan kun je buf gewoon gebruiken voor de chararray (zonder dat je dus een pointer gebruikt)
Overigens moet je van het aantal bytes dat je alloceert 1 aftrekken, aangezien je anders dan die ene byte van de buffer die al in de struct zit dubbel alloceert.

dus:

code:

temp = malloc (sizeof (*tmp) + bufsize - 1));

en dan ben je al klaar

Da's een hack in C90. Wel een handige, dus in C99 is zoiets legaal gemaakt. Alleen dacht ik dat je daar dan geen [1] maar [bufsize] moest schrijven, dan weet de compiler dat je er geen arrays van moet maken etc.

( Ik denk dat van de gangbare compilers alleen GCC 3.0 al C99 compatible is. MSVC++ gaat't niet eens proberen, Borland weet ik niet )

[The - DDD]

Haakjes ik ben er nog steeds geen ster in...

[.oisyn]

[hier stond onzin]

.edit: aargh verkeerd gelezen

[Olaf van der Spek]

Op woensdag 02 januari 2002 09:36 schreef MSalters het volgende:
Da's een hack in C90. Wel een handige, dus in C99 is zoiets legaal gemaakt. Alleen dacht ik dat je daar dan geen [1] maar [bufsize] moest schrijven, dan weet de compiler dat je er geen arrays van moet maken etc.

Hoezo is het een hack dan?
En [bufsize] lijkt me erg sterk, de var bufsize is niet bekend tijdens de struct declaratie.

[farlane]

Op woensdag 02 januari 2002 03:01 schreef OiSyN het volgende:
Daarom werkt dit beter:

code:

tmp = malloc (sizeof (*tmp) + bufsize);
temp->buf = (char *)tmp + bufsize;

Is dat wel goed?

code:

tmp = malloc (sizeof (*tmp) + bufsize);
temp->buf = (char *)tmp + sizeof (*tmp)- sizeof(char *);

[Olaf van der Spek]

Nee, nu wijst buf niet naar de buffer, maar naar buf zelf.

[RickN]

Op woensdag 02 januari 2002 03:01 schreef OiSyN het volgende:

[..]

Daarom werkt dit beter:

code:

tmp = malloc (sizeof (*tmp) + bufsize);
temp->buf = (char *)tmp + bufsize;

[..]

Ik denk ook dat dit niet goed is hoor. buf staat toch achteraan in de struct?? Dan moet je toch van achterin het geheugenblok bufsize TERUG tellen, niet van het begin bufsize VERDER tellen zoals nu gebeurt.

Volgens mij moet het zoiets zijn:

code:

[edit]Bij nader inzien moet het gewoon zijn wat Farlane zegt.[/edit]

[MSalters]

Op donderdag 03 januari 2002 07:44 schreef OlafvdSpek het volgende:

[..]

Hoezo is het een hack dan?
En [bufsize] lijkt me erg sterk, de var bufsize is niet bekend tijdens de struct declaratie.

Technisch schrijf je in C90 buiten de array. Da's niet helemaal lekker.
En dat bufsize niet bekend is is nou juist de bedoeling; dan wordt't een VLA (Variable Length Array). Maar ik moet bekennen dat de fijnere details me ontgaan , 'k heb nog geen compiler om mee te testen.

[.oisyn]

Op donderdag 03 januari 2002 08:54 schreef farlane het volgende:

[..]

Is dat wel goed?

code:

tmp = malloc (sizeof (*tmp) + bufsize);
temp->buf = (char *)tmp + sizeof (*tmp)- sizeof(char *);

idd je hebt gelijk (hoewel, niet helemaal )
die sizeof (char * ) hoef je er niet af te trekken (waarom doe je dat eigenlijk )

dus het wordt

code:

tmp = malloc (sizeof (*tmp) + bufsize);
tmp->buf = (char *)tmp + sizeof (*tmp);

.edit: hmmm ik heb al een idee waarom die je sizeof (char * ) eraf trekt... dat is zeker die unsigned char * buf? Die moet je er juist NIET aftrekken, aangezien de buffer NA die char * komt (anders overschrijf je buf met de buffer zelf, dus heb je geen pointer naar de buffer meer)

[drZymo]

ik heb het niet allemaal gelezen. Maar ken je het commando 'new' ?

Als je een pointer naar een struct hebt dan doe je dit voor de initialisatie:

code:

struct DA_STRUCT * blaat;
blaat = new DA_STRUCT;
blaat->buf = (char*)malloc(1234);

free(blaat);

Lijkt mij makelijker dan allemaal blaten met mallocs enzo.

[.oisyn]

Op donderdag 03 januari 2002 11:50 schreef drZymo het volgende:
ik heb het niet allemaal gelezen. Maar ken je het commando 'new' ?

new is C++, we zijn hier in C bezig

[drm]

Op donderdag 03 januari 2002 11:50 schreef drZymo het volgende:
ik heb het niet allemaal gelezen. Maar ken je het commando 'new' ?

Als je een pointer naar een struct hebt dan doe je dit voor de initialisatie:

code:

struct DA_STRUCT * blaat;
blaat = new DA_STRUCT;
blaat->buf = (char*)malloc(1234);

free(blaat);

Lijkt mij makelijker dan allemaal blaten met mallocs enzo.

*kuch*

Topic: [C] ruimte reserveren voor struct met pointer

[drZymo]

w00ps

[drZymo]

Op donderdag 03 januari 2002 10:17 schreef OiSyN het volgende:

[..]


idd je hebt gelijk (hoewel, niet helemaal )
die sizeof (char * ) hoef je er niet af te trekken (waarom doe je dat eigenlijk )

dus het wordt

code:

tmp = malloc (sizeof (*tmp) + bufsize);
tmp->buf = (char *)tmp + sizeof (*tmp);

.edit: hmmm ik heb al een idee waarom die je sizeof (char * ) eraf trekt... dat is zeker die unsigned char * buf? Die moet je er juist NIET aftrekken, aangezien de buffer NA die char * komt (anders overschrijf je buf met de buffer zelf, dus heb je geen pointer naar de buffer meer)

Ok dan mischien een wat behulpzamere reply

Een sizeof(*tmp) geeft de size van een pointer en niet van de struct. Als je dus die struct wilt hebben.
Zou mischien dit beter werken:

code:

struct CBUF * TX_cir_buf;
TX_cir_buf = (struct CBUF*)malloc(sizeof(struct CBUF));
TX_cir_buf->blaat = 0;
en rest van init blaat;
TX_cir_buf->buf = (char*)malloc(1234);
.
.
//heel belangrijk ;)
free(TX_cir_buf->buf);
free(TX_cir_buf);

Is dit beter?

[.oisyn]

nee

als ik de size van de pointer wilde weten deed ik wel

code:

sizeof (tmp);

hier doe ik

code:

sizeof (*tmp)

wat dus gewoon de struct zelf is

zie het zo: je declareert een variabele int * a
a is nu van het type int *
*a is van het type int

dus sizeof (a) == sizeof (int * ) en sizeof (*a) == sizeof (int)

[drZymo]

jajaja ok;
Info over pointers hoef je mij niet te geven, dat snap ik wel. Koffie daarentegen, dat kan je me wel geven.

Maaru ja dan nog vind ik het dom om eerst een heel blok geheugen te alloceren en dan die buffer naar een stuk daarvan te laten wijzen. Beetje omslachtig. 2 keer geheugen alloceren maakt niet zo veel uit. Is een stuk makelijker. Het enige grote nadeel is dat de struct en het blok geheugen voor de buf niet in hetzelfde geheugen blok liggen, maar verspreid. En dus kan je niet in een keer een memcpy doen ofzo. Maar aangezien ik niet denk dat dit zal gebeuren lijkt mij dit een beetje omslachtig.

En waarom moet het in C btw? C++ is veel simpeler in dit opzichte

[.oisyn]

omslachtig? Het alloceren van meerdere buffers is juist omslachtig. Bovendien is het niet efficient en zorgt het voor fragmentatie in je geheugen. Een belangrijke tip voor als je efficiente programma's wil schrijven die dynamisch geheugen alloceren is dat je malloc () zo min mogelijk moet aanroepen.

Het is hier idd omslachtig, niet omdat je 1 keer geheugen alloceert, maar omdat je nog een extra pointer gebruikt die in principe altijd wijst naar het stukje wat na die pointer komt. Dus kun je beter een char-array van 1 element in je struct declareren, dan gaat de rest vanzelf en hoeft het ook niet via een pointer

[johnwoo]

Wat ik me nu afvraag he, waarom moet het dynamisch gealloceerd worden in de eerste plaats? Je gebruikt een globale variabele (in jouw geval pointer) en een functie om die te initialiseren.
Waarom declareer je niet struct CBUF TX_cir_buf; in plaats van struct CBUF* TX_cir_buf; ?? De compiler zorgt dan zelf voor de allocatie en het opruimen van je structje... En als je n keer de pointer nodig hebt dan gebruik je &TX_cir_buf. Lijkt me een stuk eenvoudiger...

[Olaf van der Spek]

Deleted

[Olaf van der Spek]

Op donderdag 03 januari 2002 12:33 schreef OiSyN het volgende:
omslachtig? Het alloceren van meerdere buffers is juist omslachtig. Bovendien is het niet efficient en zorgt het voor fragmentatie in je geheugen. Een belangrijke tip voor als je efficiente programma's wil schrijven die dynamisch geheugen alloceren is dat je malloc () zo min mogelijk moet aanroepen.

Ik zou het meerdere keren alloceren van geheugen niet als omslachtig omschrijven, eerder als niet zo efficient in dit geval. Maar er zijn genoeg situaties te bedenken waarin je wel twee keer moet alloceren. Bijvoorbeeld als de 'array' in C++ uit classes met constructor bestaat. Of als de buffer later pas gealloceerd wordt.

[decoy]

FF voor die gene die zich afvragen wat ik er nu mee ga doen

Ik ben bezig met een applicatie op een microcontroller (een koffie automaat) en gebruik twee seriele poorten om te communiceren met de buitenwereld. Voor deze poorten heb ik in sommige gevallen geen buffer nodig en soms weer wel. Ligt aan het extenre device dat er aanhangt.

Nu heb ik bedacht een buffer te definieren om standaard te gebruiken voor elke toepassing met buffer, dus ook de seriele poorten. Voor deze buffers heb ik een aantal standaard routines gemaakt om te bewerken en kanik elk buffer op elke willekeurig moment bewerken door er de pointer naar de struct aan mee te geven.

Dus... het antwoord is duidelijk, versie 1 is het snelste werk en aan versie 2 valt na verbetering een redelijke code optimalisatie te verkrijgen.

De reden dat ik dynamisch will alloceren is dat ik diverse buffers gebruik van verschillende groottes en zo min mogelijk code wil gebruiken.
De buffers declareer ik als pointers om ruimte te sparen, dus als ik gewoon CBUF TX_circ_buf gebruik kost het me altijd een hele struct aan ruimte terwijl het met met een CBUF *TX_circ_buf slechts de pointer kost. Er zijn namelijk momenten dat ik voor andere doelen redelijk wat geheugen verbruik en ik heb "maar" 4k.
C++ is mischien éénvoudiger (???!) in dit geval maar mijn compiler is ANSI C.

Topic lijkt me nu een stuk duidelijker dus barst maar weer los

[drZymo]

Op donderdag 03 januari 2002 15:03 schreef decoy het volgende:
FF voor die gene die zich afvragen wat ik er nu mee ga doen

Ik ben bezig met een applicatie op een microcontroller (een koffie automaat) en gebruik twee seriele poorten om te communiceren met de buitenwereld. Voor deze poorten heb ik in sommige gevallen geen buffer nodig en soms weer wel. Ligt aan het extenre device dat er aanhangt.

Nu heb ik bedacht een buffer te definieren om standaard te gebruiken voor elke toepassing met buffer, dus ook de seriele poorten. Voor deze buffers heb ik een aantal standaard routines gemaakt om te bewerken en kanik elk buffer op elke willekeurig moment bewerken door er de pointer naar de struct aan mee te geven.

Dus... het antwoord is duidelijk, versie 1 is het snelste werk en aan versie 2 valt na verbetering een redelijke code optimalisatie te verkrijgen.

De reden dat ik dynamisch will alloceren is dat ik diverse buffers gebruik van verschillende groottes en zo min mogelijk code wil gebruiken.
De buffers declareer ik als pointers om ruimte te sparen, dus als ik gewoon CBUF TX_circ_buf gebruik kost het me altijd een hele struct aan ruimte terwijl het met met een CBUF *TX_circ_buf slechts de pointer kost. Er zijn namelijk momenten dat ik voor andere doelen redelijk wat geheugen verbruik en ik heb "maar" 4k.
C++ is mischien éénvoudiger (???!) in dit geval maar mijn compiler is ANSI C.

Topic lijkt me nu een stuk duidelijker dus barst maar weer los

ok explains a lot

[farlane]

Op donderdag 03 januari 2002 10:17 schreef OiSyN het volgende:

.edit: hmmm ik heb al een idee waarom die je sizeof (char * ) eraf trekt... dat is zeker die unsigned char * buf? Die moet je er juist NIET aftrekken, aangezien de buffer NA die char * komt (anders overschrijf je buf met de buffer zelf, dus heb je geen pointer naar de buffer meer)

Dat was idd de reden en idd het was ook een foute gedachte van me.