Plugins en C++

[ProgHead]

Even stap voor stap:

Een pointer heeft kennelijk twee kenmerken d en a, en een pointer kun je formeel zien als een geordend paar (d,a) met d het type van de info die in het geheugen op adres a staat.

Klopt dit?

 

[vink]

Even stap voor stap:

Een pointer heeft kennelijk twee kenmerken d en a, en een pointer kun je formeel zien als een geordend paar (d,a) met d het type van de info die in het geheugen op adres a staat.

Klopt dit?

dan maak je het te ingewikkeld én is niet het korrekt, dunkt me.

ook een van variabele kun je het adres verkrijgen..

int a;

&a zal dan het adres geven van a en niet de waarde of data...

int *p;
int a=10;

p = &a;

dan is p de pointer, het verwijst of wijst naar een geheugenadres, met de grootte hier van integer getal.

er is géen paar.

de asterix betekent dereferencing, waarmee je de waarde krijgt waarnaar p verwijst.

*p

geeft dan hier

10

EDIT ik schrijf hetzelfde als @3ddie maar dan wat ongelukkiger.

hoe je pointers kunt gebruiken, in het eggie, maakt een formele aanpak, zoals je hierboven beschrijft onnodig ingewikkeld.

de formele logika achter pointers lijkt me anders...

of een pointer is simpelweg een meer abstracte vorm van het schrijven of lezen van een waarde naar een geheugenadres. de pointer is een manier om naar het juiste geheugenadres te verwijzen, op een meer abstrakte wijze.

 

[ProgHead]

Ik begrijp zaken pas nadat ze netjes gedefinieerd zijn. Wat anderen ergens mee doen is voor mij niet overtuigend. Ik heb er ook weinig lol in om dingen na te doen. Ideaal gesproken zou alles wat je met pointers kunt doen en welke eigenschappen ze hebben, op basis van de definitie van wat pointers zijn verantwoord moeten kunnen worden. Daarom is het vinden van een degelijke definitie van dingen voor mij in veel gevallen de grootste hobbel in het leerproces.

 

[vink]

Ik begrijp zaken pas nadat ze netjes gedefinieerd zijn. Wat anderen ergens mee doen is voor mij niet overtuigend. Ik heb er ook weinig lol in om dingen na te doen. Ideaal gesproken zou alles wat je met pointers kunt doen en welke eigenschappen ze hebben, op basis van de definitie van wat pointers zijn verantwoord moeten kunnen worden. Daarom is het vinden van een degelijke definitie van dingen voor mij in veel gevallen de grootste hobbel in het leerproces.

ja ik begrijp het, maar misschien zijn zaken in C niet zo netjes gedefinieerd.

je hebt een formele benadering waarvoor ik weer niet de aanleg heb.

hoe anderen het doen; met pointers werken b.v. is waarschijnlijk de 'definitie' van pointers, in het is zeer praktisch in zeker zin.

in formele zin zou ik het niet weten.

ik hoop dat @3ddie een formele benadering kan beschrijven. lijkt me ook wel interessant.

de fundamentele, formele benadering wordt natuurlijk ten eerst door de CPU bepaald, en wel in een zeer abstrakte zin, de x86 set is al abstrakt en wordt al 'vertaald' binnen de CPU.

maar adressering, waarde, registerbewerking, daar heeft C natuurlijk wel zijn grond in.

ik ben benieuwd of er een formeel logische benadering van pointers in C bestaat, niet after the fact, maar voordat C werd uitgeschreven...

hoe kwam men op een pointer, en op &, voor een variabele... om het adres te weten.

waarom werkt men met pointers in C, voor arrays, structuren, objecten etc. (is het antwoord niet: vanwege dat je vanuit C zelf het geheugen kan adresseren, met ja, pointers?).

goed, ik vind het ook interessant waarom je het zo benadert. terwijl de heel praktische wijze, van de syntax begrijpen, voor mij heel goed werkt....

 

[ProgHead]

Een praktische benadering werkt zeker. Ik loop mijn hele leven lang al tegen het probleem aan dat ik het naadje van de kous wil weten en bewijzen wil zien, terwijl dat anderen vaak worst zal zijn. En die anderen komen met hun praktische benadering in het leven ook veel verder dan ik. Mijn hoofd zit nu vol met nutteloze kennis.

 

[vink]

Een praktische benadering werkt zeker. Ik loop mijn hele leven lang al tegen het probleem aan dat ik het naadje van de kous wil weten en bewijzen wil zien, terwijl dat anderen vaak worst zal zijn. En die anderen komen met hun praktische benadering in het leven ook veel verder dan ik. Mijn hoofd zit nu vol met nutteloze kennis.

ik zou het absoluut geen nutteloze kennis willen noemen! ik snap dat naadje van de kous wel... maar bij programmeren prefereer ik de praktische benadering, bij poëzie/schrijven en filosofie prefereer ik het naadje van de kous, en daar nog het naadje van.....

EDIT: is er geen programmeertaal met een heel formele benadering?

bewijzen en programmeertalen.... ik ben benieuwd of zoiets fundamenteels bestaat.

 

[Cornerman]

Het naadje van de kous is je algoritme (of wat dan ook wat je wil bouwen). De programmeertaal is de het verhaal dat je schrijft om het werkend te krijgen. Dus in abstracte theorie zijn dingen mogelijk in een taal, die geen goede toepassing hebben in het schrijven van je verhaal. Het is dan als het ware een brei woorden. Dus ik zou zeggen ga niet te diep zeker niet in C++.

Misschien niet wiskundig of erg juist opgeschreven maar dat is het wel voor mij. Programmeren heeft zoveel stijlen dat je ook binnen talen je eigen stijl kan vinden. Zonder voor alle theoretische ideeen zich in een taal bevinden het naadje van de kous te hoeven weten of maar te kunnen vinden.

 

[ProgHead]

Even wat anders, is een progje in C++ dat onder Linux werkt ook onder Windows te draaien? En zo ja - wat moet je daarvoor dan veranderen?

 

[HJB]

Ik begrijp zaken pas nadat ze netjes gedefinieerd zijn. Wat anderen ergens mee doen is voor mij niet overtuigend. Ik heb er ook weinig lol in om dingen na te doen. Ideaal gesproken zou alles wat je met pointers kunt doen en welke eigenschappen ze hebben, op basis van de definitie van wat pointers zijn verantwoord moeten kunnen worden. Daarom is het vinden van een degelijke definitie van dingen voor mij in veel gevallen de grootste hobbel in het leerproces.

Het verschil is de pointer(het geheugenadres) en de waarde die op dat adres staat.
Dit kan vergeleken met andere talen wat lastig overkomen. Zelf gebruikte ik Pascal voordat ik de overstap naar C maakte.
Pascal heeft een hele strakke syntax waarbij je niet snel fouten maakt. Maar mist daarmee ook de nodige flexibiliteit.
C staat dichter bij de machinecode. De de wijze waarop C met pointers om gaat is veel flexibeler. Pointermanipulatie is heel makkelijk. Zo kun je eenvoudig met grote of kleine blokken geheugen spelen. Maar dat komt met een risico. Je moet goed weten wat je doet. En fouten zoeken kan lastig zijn.
Ik heb naast C ook Assembler geleerd en gebruikt. Dan wordt de syntax ineens een stuk inzichtelijker.

 

[ProgHead]

Kennelijk is dat toch niet het hele verhaal want als een pointer simpelweg een geheugenadres zou zijn dan was een pointer een integer. Het geheugenadres van een plaats in het geheugen is als getal immers onafhankelijk van wat daar op die plaats is opgeborgen. Er is niet zoiets als een integer geheugenadres, een float geheugenadres, etc. Vandaar ook mijn voorstel om een pointer te definiëren als een geordend paar waarin zich zowel een geheugenadres (= een integer) en een type-aanduiding bevinden.

 

[HJB]

Kennelijk is dat toch niet het hele verhaal want als een pointer simpelweg een geheugenadres zou zijn dan was een pointer een integer. Het geheugenadres van een plaats in het geheugen is als getal immers onafhankelijk van wat daar op die plaats is opgeborgen. Er is niet zoiets als een integer geheugenadres, een float geheugenadres, etc. Vandaar ook mijn voorstel om een pointer te definiëren als een geordend paar waarin zich zowel een geheugenadres (= een integer) en een type-aanduiding bevinden.

Dat zou op het type struct gaan lijken. Of je krijgt het type pointer zoals in Pascal waarbij je voor de variabele met een ^ of @ moet aangeven of je deze als pointer gebruikt of dat je de waarde van de variabele wilt aanspreken.

 

[Cornerman]

Een pointer geeft de plek aan en hoe je die plek moet lezen. En in C++ ben je zelf verantwoordelijk voor de geldigheid van die locatie

 

[vink]

betekenis + betekenaar = teken

 

[ProgHead]

Wat gebeurt er als je een pointer aanmaakt naar een geheugenlocatie die niet bestaat? Of naar een bestaande geheugenlocatie waarin zich iets bevindt dat niet van het type is dat door de pointer wordt verlangt?

 

[HJB]

Wat gebeurt er als je een pointer aanmaakt naar een geheugenlocatie die niet bestaat? Of naar een bestaande geheugenlocatie waarin zich iets bevindt dat niet van het type is dat door de pointer wordt verlangt?

In het eerste geval een foutmelding, crash of vreemde resultaten van het programma. In C++ te ondervangen. In C niet.
Je kan dat testen door de volgende code

int *c;
int a;
*c=10;
c++;
a=*c;

Bij mijn test gaf a de waarde 127.

Wanneer je een int pointer naar de loctatie van een float laat wijzen dan zal de waarde van die locatie als int worden geinterpreteerd.
Maar het is een resultaat waar je niets aan hebt. Het programma leest de 4 bytes van de geheugenlocatie (uitgaande van 32 bits integer) en behandelt deze als een int.

Daarom, altijd goed opletten bij het gebruik van pointers in C.

 

[ProgHead]

Eigenlijk zegt een pointer dan niet wat er op een zekere geheugenlocatie staat, maar hoe die wat er staat interpreteert.

 

[3ddie]

@ProgHead je maakt het veel en veel te ingewikkeld man. Pointers zijn niets speciaals. Een pointer is gewoon een variabele en werkt als iedere andere variabele. Ik heb je al uitgelegd dat een pointer inderdaad gewoon een integer is ter grootte van de (virtuele) adresruimte van de CPU. Dus ja: een pointer is eigenlijk een integer.

Maar C en C++ zijn "strongly typed". Dat betekent dat voor de compiler alles een type moet hebben zodat het bepaalde fouten kan detecteren. Om een voorbeeld te noemen: wat zou het resultaat zijn van het optellen van een float en een karakter? En dan bedoel ik niet het karakter converteren naar een float en dan optellen bij de andere float. Nee ik bedoel de float representatie in het geheugen (héé, dat zijn eigenlijk ook gewoon integers) optellen bij een char representatie in het geheugen. Dit is ongedefinieerd. Een float heeft een mantisse, exponent en een sign.

Stel dat we geen typen zouden gebruiken maar variabelen op deze manier declareren:

var a = 'A';
var b = 3.1415;
var c =  a + b ;   // ??? Wat is dit ???

Om te kunnen controleren of a + b iets gedefinieerds oplevert moet C het type weten.

char a = 'A';
float b = 3.1415;
????? c = a + b;  //  Kortom: dit ga je niet recht breien in C zonder conversies te doen!!

Hetzelfde geldt ook voor pointers. Ook daarvoor moet C het type weten. Stel dat we dit konden doen:

char a = 'A';
float b = 3.1415;

integer pa = &a;
integer pb = &b;

?????? c = *pa + *pb;  // Wederom kan C niet bepalen wat het type is van de optelling van de waarden waar pa en pb naar wijzen.
                       // zullen we gewoon maar een bitsgewijze optelling doen? Waarbij we de mantisse, exponent en sign vernaggelen?

DAAROM doen we het zo:

char a = 'A';
float b = 3.1415;

char *pa = &a;
float *pb = &f;
????? c = *a + *b;  // C ziet nu dat je een char bij een float probeert op te tellen --> nette error melding en geen gemankeerde float of char

Dus nogmaals: pointers zijn gewone variabelen net als ieder andere variabele van een ander type. Pointers moeten een type hebben. Ik heb je al uitgelegd dat "pointer" niets is. Een "pointer naar een int" is wel wat of een "pointer naar een float". Dat zijn typen.

Voor het werken met pointers hebben we echter twee speciale operaties nodig. Want pointer variabelen slaan adressen op. Ze zijn dus indirect. Er zit geen direct bruikbare waarde in. De waarde is altijd indirect. In ieder geval hebben we een operatie nodig waarbij we het adres van "iets" (een instantie van een type) kunnen opvragen want een pointer heeft een adres nodig. Dat is de & operatie (reference)

int a = 10;
int *pa;     // declaratie van pa een pointer naar een int
pa = &a;   // pa krijgt als waarde het adres van de integer a. Dit mag want a is een int en pa is een int pointer, dit mag.

Het tweede dat we nodig hebben is voor het oplossen van de indirectie. De variabele pa bevat geen bruikbare waarde maar "wijst" naar een bruikbare waarde. Om die verwijzing te volgen hebben we de derefentie operatie (dereference): *

int a = 10;
int *pa;
pa = &a;
count << "address " << pa << " bevat de integer waarde " << *pa << endl;

That's it. Als je dit niet begrijpt lees dan het hoofdstuk over pointers in dat C-boek dat je hebt. Maar je moet dit echt begrijpen anders ben je compleet verloren in C of C++.

 

[3ddie]

Eigenlijk zegt een pointer dan niet wat er op een zekere geheugenlocatie staat, maar hoe die wat er staat interpreteert.

Luister man: het zijn allemaal enen en nullen... UITERAARD gaat het erover hoe je die enen en nullen interpreteert!!!

Zijn het 8 bits die 1 waarde vertegenwoordigen? Zijn het twee 4 bits waarden? Is het een karakter? Is het een float?

Dat is dus waarom je die typering van een pointer hebt... ik zeg dit nu voor de 4e of 5e keer in dit draadje....

 

[3ddie]

Wat gebeurt er als je een pointer aanmaakt naar een geheugenlocatie die niet bestaat? Of naar een bestaande geheugenlocatie waarin zich iets bevindt dat niet van het type is dat door de pointer wordt verlangt?

Je mag de pointer naar alles laten wijzen wat je wilt. Pas als je de verwijzing volgt krijg je een mogelijk probleem...

int *p;
p = 0x00000000;         // prima
p = 0xffffffff;         // ook prima
cout << *p << endl;     // dit kon wel eens problematisch worden

 

[ProgHead]

@3ddie Je bent hier herhaaldelijk iets aan het uitleggen wat al begrijp. Pointers bevatten zowel een geheugenadres als een type-aanduiding. Klopt! Alleen als ik dat dan expliciet maak in die zin dat pointers eigenlijk geordende paren zijn die twee gegevens bevatten (namelijk een geheugenadres en een type-aanduiding) dan doe ik zogenaamd veels te ingewikkeld en dan heb ik het volgens jou niet begrepen. Het zij zo. Ik weet zelf het beste wat ik al dan niet begrijp, en als anderen dat anders zien is dat hun probleem. Ik zal zelf wel een manier bedenken om die verwarrende syntax van C en C++ rond pointers naar iets begrijpelijks te vertalen.