[C(++)] voor dummies - Deel 3

quote:

Op dinsdag 26 juli 2011 12:55 schreef netolk het volgende:

[..]

het forceren met :: heb ik geprobeerd maar zegt ie dood leuk dat ik hem in :: moet declareren...
Wat dus niet kan omdat ie in een apart .cpp bestand staat.

Waarom kun je 'm niet declareren omdat 'ie in een appart bestand staat?

Je kan toch prima:
boven de klasse-definitie (of mooier: in een header file, die je include) zetten?

Trouwens: een losse set-functie is niet altijd wenselijk (de waarden zijn niet voor niets private natuurlijk); met 'friend' functies kun je nauwkeuriger controlleren waar/hoe waarden gezet gaan worden.

Nog mooier zou zijn als je bijv. een 'handleEvent' functie ofzo als member functie aanmaakt, die een enkele key-event afhandelt. De Threader_Key functie kan die memberfunctie dan in een loop aanroepen. Zo hou je controle over je private member variable binnen de klasse, zonder de variabele voor 'algemeen gebruik' open te zetten

[ Bericht 21% gewijzigd door Ai_KaRaMBa op 26-07-2011 13:27:29 ]

Wat is het verschil tussen type variable_naam en type variable_naam = new type?
Bv struct hoi; en struct hoi = new struct;

Bij de tweede alloceer je meteen geheugen. Bij de eerst niet.

Daarnaast kun je niets toekennen aan en opvragen van data in je struct in het eerste geval, en zul je op een later tijdstip alsnog een new moeten doen.

Onder C# krijg je dan een 'object reference not set to an instance of an object' exceptie, ik weet niet of die in C ook zo heet...

quote:

Op vrijdag 21 oktober 2011 21:51 schreef FastFox91 het volgende:
Wat is het verschil tussen type variable_naam en type variable_naam = new type?
Bv struct hoi; en struct hoi = new struct;

new returnt een pointer, waarbij er op de heap geheugen wordt aangemaakt. In het eerste geval staat de struct op de stack.

Bedankt voor de antwoorden, hier kan ik mee verder.

quote:

Bij de tweede alloceer je meteen geheugen. Bij de eerst niet.

Bij beide declaraties wordt geheugen gealloceerd, bij de eerste aanroep gebeurt dit op de stack, bij de tweede aanroep in de common pool, waarbij new dus een pointer teruggeeft naar dit geheugen.

quote:

Daarnaast kun je niets toekennen aan en opvragen van data in je struct in het eerste geval, en zul je op een later tijdstip alsnog een new moeten doen.

Ik snap niet wat hiermee bedoeld wordt, maar uiteraard kan je de struct gewoon gebruiken en is het niet noodzakelijk om later nog een new-aanroep te doen.

quote:

new returnt een pointer, waarbij er op de heap geheugen wordt aangemaakt. In het eerste geval staat de struct op de stack.

Kort, krachig en grotendeels juist. Alleen het gebruik van het woord heap begrijp ik niet: in de common pool is geen sprake van een datastructuur?

Gebruik 'new' alleen als je zeker weet dat je het nodig hebt. Zoniet: weglaten.

quote:

In the C++ programming language, as well as in many C++-based languages, new is a language construct that dynamically allocates memory on the heap and initialises the memory using the constructor. Except for a form called the "placement new", new attempts to allocate enough memory on the heap for the new data. If successful, it initialises the memory and returns the address to the newly allocated and initialised memory. However if new cannot allocate memory on the heap it will throw an exception of type std::bad_alloc. This removes the need to explicitly check the result of an allocation. A call to delete, which calls the destructor and returns the memory allocated by new back to the heap, must be made for every call to new to avoid a memory leak.

Goh, iemand heeft Wikipedia gevonden.

quote:

Op zondag 23 oktober 2011 00:35 schreef Catbert het volgende:
Goh, iemand heeft Wikipedia gevonden.

Klopt, om duidelijk te maken dat de heap gebruikt wordt.

quote:

Op donderdag 10 november 2011 00:26 schreef netolk het volgende:
Kan iemand mij uitleggen waarom dit programma een (onbekende) error geeft waardoor windows het programma sluit??

het gaat om dit stukje
[ code verwijderd ]

Hier loopt het programma vast maar als ik 2 vd 3 1000 naar 100 zet werkt het wel gewoon...
Ik, heb werkgeheugen om de 1,86 GB te bewaren, ik snap niet waarom dit niet werkt

alvast bedankt voor de hulp

Een pointer neemt doorgaans op een 32-bitssystem 4 bytes in en op een 64-bitssysteem 8 bytes. We kunnen dus concluderen dat het veel meer dan 1,86 GB inneemt. Om dit te adresseren heb je meer dan 4 GB en dus een 64-bitssysteem nodig. Dan kom je toch al gauw uit op 16 * 1000³ bytes en dat is ongeveer 14,9 GB.

Vraagje

ik heb een variabele b dat een unsigned long array is. Nu heb ik het volgende stukje code:

Nu wil ik dit graag veranderen naar


Nu runt dit wel maar echter krijg ik dan een foute berekening, omdat ik geloof de laatste stement *(b) += 2 fout is. Kan iemand me ook vertellen waarom die fout is, ik geloof dat dat "*a" een adres is van b maar wat is "a" dan?

quote:

Op donderdag 10 november 2011 00:44 schreef netolk het volgende:
Ahh, vandaar ik snapte het al niet dacht dat pointers 1 byte waren Xd maar nu ik dit zo lees is het idd logisch dat ze 8 bytes zijn

Als een pointer 1 byte was, en dus 256 mogelijke waarden had, dan had je maar 256 bytes kunnen adresseren he...

quote:

Op woensdag 16 november 2011 02:46 schreef Dale. het volgende:
Vraagje

ik heb een variabele b dat een unsigned long array is. Nu heb ik het volgende stukje code:
[ code verwijderd ]

Nu wil ik dit graag veranderen naar
[ code verwijderd ]

Nu runt dit wel maar echter krijg ik dan een foute berekening, omdat ik geloof de laatste stement *(b) += 2 fout is. Kan iemand me ook vertellen waarom die fout is, ik geloof dat dat "*a" een adres is van b maar wat is "a" dan?

a is een pointer, wordt dus gerepresenteerd door een adres. Het statement a += 2 schuift de pointer dus twee plekken op. *a is datgene waar de pointer naar verwijst, ofwel de inhoud van het adres; idem dito voor *b. a en b verwijzen naar hetzelfde adres in jouw code.

*(b+i) is hetzelfde als b[i]. *b is dus hetzelfde als b[0] en ook hetzelfde als *a, wat niet a is.

quote:

Op woensdag 16 november 2011 11:04 schreef thabit het volgende:

[..]

a is een pointer, wordt dus gerepresenteerd door een adres. Het statement a += 2 schuift de pointer dus twee plekken op. *a is datgene waar de pointer naar verwijst, ofwel de inhoud van het adres; idem dito voor *b. a en b verwijzen naar hetzelfde adres in jouw code.

*(b+i) is hetzelfde als b[i]. *b is dus hetzelfde als b[0] en ook hetzelfde als *a, wat niet a is.

Ok dus als ik het goed begrijp moet de laatste regel niet

*(b) += 2 worden maar gewoon b += 2?

quote:

Op woensdag 16 november 2011 12:07 schreef Dale. het volgende:

[..]

Ok dus als ik het goed begrijp moet de laatste regel niet

*(b) += 2 worden maar gewoon b += 2?

Ik geloof niet dat je zoiets zomaar kan doen met arrays (tenzij ze een functie-argument zijn, want dan zijn het gewoon pointers).

quote:

Op woensdag 16 november 2011 19:57 schreef netolk het volgende:

[..]

Array's zijn toch stiekem gewoon altijd pointers???

In principe wel, maar er zijn wat subtiele verschillen.

quote:

Op woensdag 16 november 2011 02:46 schreef Dale. het volgende:
Nu runt dit wel maar echter krijg ik dan een foute berekening, omdat ik geloof de laatste stement *(b) += 2 fout is. Kan iemand me ook vertellen waarom die fout is, ik geloof dat dat "*a" een adres is van b maar wat is "a" dan?

Nee, *a is geen adres van b: a is het adres van b. *a is de eerste waarde uit b.

Wat probeer je te doen? Zoals tha_bit al zei, zijn jouw a[1] = iets en *(b + 1) = iets gelijk aan elkaar, omdat a het adres van de array b bevat en de operator[] onder water hetzelfde doet als jij in je tweede voorbeeld. (Trouwens, een leuk detail dat hieruit volgt is dat b[2] identiek is aan 2[b]; dit mag in C(++) ook zo worden gebruikt. Probeer maar...)

De tweede regels zijn niet gelijk aan elkaar. De code a += 2 schuift de pointer a twee adressen op (afhankelijk van de lengte van de array kan dit dus problemen opleveren). De code *b += 2 verhoogt de waarde van b[0] met 2.

Zoals tha_bit ook al zei, kan je niet b += 2 schrijven, omdat het adres waar b naar wijst niet veranderd mag worden.

Een array kan je zien als een const pointer (technisch is het een geheugenadres: de compiler vervangt de arraynaam direct door een adres en maakt dus geen variabele aan). De waarde van b mag dus niet veranderd worden, maar die van *b wel (want een arraynaam 'is' een constante pointer, geen pointer naar een constante). De uitzondering hierop zijn arrays als functie-argumenten (zoals argv[]): dit zijn altijd pointers. (Dit komt doordat de compiler gedwongen wordt het geheugenadres wel een naam te geven als deze aan een functie wordt doorgegeven.)

quote:

Ok dus als ik het goed begrijp moet de laatste regel niet

*(b) += 2 worden maar gewoon b += 2?

Dit mag dus niet. Nogmaals: wat wil je bereiken? Als je met een pointer over de array wilt itereren, heb je expliciet een pointer nodig omdat je b niet mag wijzigen.

Ok thanks en ja dat laatste wou ik dus

Ander vraagje... is het mogelijk om deze expressie korter op te schrijven?

(x >> 16) & 0xff ?

Is het mogelijk dit om te schrijven naar een expressie met maar 1 actie? Geloof 't niet he?

Wat is x?

quote:

Op donderdag 17 november 2011 10:22 schreef thabit het volgende:
Wat is x?

een integer.