C (pointers denk ik)

[Jekke]

Ik heb een syntax vraagje over C. Beschouw volgende declaraties in een interface:

typedef ... pthread_mutex_t;

int pthread_mutex_lock(pthread_mutex_t *mutex);

beschouw dan het volgende stuk code:

typedef struct {

pthread_mutex_t mutex;

pthread_cond_t buffer_not_full;

pthread_cond_t buffer_not_empty;

int count, first, last;

int buf[BUFF_SIZE];

} buffer;

int append(int item, buffer *B){

PTHREAD_MUTEX_LOCK(&B->mutex);

...

}

probleem is dat ik niet weet wat "&B->mutex" doet/wil zeggen?

[Xenion]

Die buffer waar je die append functie op aanroept is waarschijnlijk een 'gedeelde recourse'. Dat betekent dat er een kans is dat 2 personen of 2 delen van je programma tegelijk naar die buffer willen schrijven en dat kan tot vreemde resultaten leiden.

Uit wat ik uit jouw code kan afleiden werk je met een lock strategie. Ik vermoed dat die phread-mutex dan een soort van library is die hier mechanismes voor voorziet?

Of ligt je probleem echt bij de pointers?

Over de mutex zelf: deze site legt het wel goed uit en geeft een voorbeeld.

[Jekke]

ja, mijn probleem is dat ik niet weet wat die pijl -> doet en wat dat &-teken doet

[Xenion]

ja, mijn probleem is dat ik niet weet wat die pijl -> doet en wat dat &-teken doet

& geeft het adres terug van een variabele, dat heb je vaak nodig als je met pointers werkt.

Aangezien je de buffer B hier al doorkrijgt als pointer denk ik niet dat je die & nog echt moet schrijven.

Je hebt 2 manieren om aan de members van een bepaalde structuur te komen via een pointer.

Ofwel doe je pointer->member, maar je kan ook (*pointer).member gebruiken.

& lees je als 'adres van' en dan werk je op een pointer (een adres dus)

* lees je als 'waarde van' en dan werk je op een zeker type (int, char, eigen class, ...)

Om het goed te begrijpen moet je eens een hele tutorial over pointers lezen. deze bijvoorbeeld. Als je op een niveau zit waar je met concurrency werkt zal je dit wel begrijpen.

Als je concrete vragen hebt kunnen we je altijd wel verder helpen.

[Jekke]

ok, bedankt, ik begrijp het nu

ik was al vertrouwd met pointers (zonder structuren), en wist al dat & het adres teruggeeft, maar ik weet dus inderdaad niet (meer, heb het ooit geweten) wat & doet als de variabele al een pointer is, iemand die hier nog wat duidelijkheid kan scheppen?

[Xenion]

Ik was fout, die & staat er wel degelijk om een bepaalde reden.

PTHREAD_MUTEX_LOCK verwacht een pointer naar een mutex, jij krijgt je buffer object als pointer binnen, dus je dereferencet het met de -> om aan de mutex te komen, dan zet je er de & voor om het adres te krijgen van die mutex en er dus een pointer van te maken.

Pointers zijn lastige dingen, in essentie is het eenvoudig maar als je met pointers naar pointers enzo begint te werken moet je er je gedachten bijhouden

[Jekke]

Ok ik begrijp het nu terug, bedankt. Ik heb het ooit allemaal perfect geweten hoe het in elkaar zat hoor, ook de relaties met assembler talen, maar het is allemaal heel lang geleden.