Op deze website gebruiken we cookies om content en advertenties te personaliseren, om functies voor social media te bieden en om ons websiteverkeer te analyseren. Ook delen we informatie over uw gebruik van onze site met onze partners voor social media, adverteren en analyse. Deze partners kunnen deze gegevens combineren met andere informatie die u aan ze heeft verstrekt of die ze hebben verzameld op basis van uw gebruik van hun services. Meer informatie.

Akkoord

Vraag & Antwoord

Programmeren

[C++] pointers

Anoniem
None
10 antwoorden
  • Ik heb eigenlijk drie vragen:
    - Ik heb een programma gemaakt dat het adres van een variable laat zien. Nu vraag ik me af waarom het adres bij mij altijd hetzelfde is.
    - Hoe kan ik ervoor zorgen dat ik in de code een hexadecimale waarde aan een pointer kan toekennen?
    - kan ik decimale waarden en hexadecimale waarden gewoon bij elkaar optellen/aftrekken enz.?

    bedankt
  • Vraag: Ik heb een programma gemaakt dat het adres van een variable laat zien. Nu vraag ik me af waarom het adres bij mij altijd hetzelfde is.

    Antwoord: Dit komt omdat het besturingssysteem een bepaald stuk geheugen reserveerd voor programma's. Probeer maar eens twee programma's op hetzelfde moment te draaien en je zal zien dat het adres veranderd - Ik neem nu even aan dat je Windows gebruikt -.

    —–

    Vraag: Hoe kan ik ervoor zorgen dat ik in de code een hexadecimale waarde aan een pointer kan toekennen?

    Antwoord: Waarom zou je dat willen??? Het kan wel (denk ik) maar ik heb nog nooit nodig gevonden.

    —–

    Vraag: Kan ik decimale waarden en hexadecimale waarden gewoon bij elkaar optellen/aftrekken enz.?

    Antwoord: Ja, voor de computer maak het niets uit, de computer rekent toch uiteindelijk met bineare waarden.

    Martin.
  • 1) Ligt er volgens mij aan waar die variabele ge-alloceerd wordt en of er ook nog andere programma's draaien. Kan het echter mis hebben.

    2) Wil je een pointer een naar een bepaald adres laten wijzen dat bv door een gebruiker kan worden opgegeven? Zo ja, user-input converteren met strtoul (en aanverwanten)

    3) Ja; intern is de waarde altijd een binair getal

    [code:1:1d9c2b23fc]
    int i=43, j=0x55,z=0;

    z=i+j;

    // z is 128 (0x80)
    [/code:1:1d9c2b23fc]
  • Zelfs als ik 30 programma's heb draaien, is het altijd 0x22ff6c. En als ik aan een pointer direct een waarde wilt toewijzen (dus zonder &variablenaam;) geeft hij een error van cannot assign ofzo…
  • Het lijkt me handig als je even de relevante code post. En een tip: post nooit (meer) iets met een de woorden [i:2d0bcad49f][b:2d0bcad49f]of zo[/b:2d0bcad49f][/i:2d0bcad49f]. Exacte foutmeldingen zijn belangrijk [b:2d0bcad49f]!![/b:2d0bcad49f]

    Hieronder een voorbeeld hoe het zou moeten werken. Als ik je goed begrijp breekt jouw compiler zijn nek over de eerste regel onder vb2.
    [code:1:2d0bcad49f]
    #include <stdio.h>

    int main()
    {
    char mystring[20];
    char *ptr;

    strcpy(mystring,"Hallo daar");

    // vb1
    ptr=mystring; // adres waar pointer naar wijst is eerste element van mystring
    printf("%s
    ",ptr); // schrijft 'Hallo daar' naar het scherm
    ptr++; // schrijft 'allo daar' naar het scherm
    // vb 2
    ptr=0x3456789; // adres waar pointer naar wijst is 0x3456789
    printf("%x
    ",*ptr); // print de waarde die is opgeslagen in 0x3456789
    }
    [/code:1:2d0bcad49f]
    Wees voorzichtig met het runnen van het gedeelte onder vb2. Je zou tegen memory problemen (blauwe schermen of segmentation faults) aan kunnen lopen als je code onder een besturingssysteem draait.

  • De variable die jij declareerd wordt op een bepaalt stuk geheugen geplaatst, en het kan zijn dat het adres constant hetzelfde is, omdat je operating system een standaard stuk geheugen reserveerd.

    Over dat zelf adressen toewijsen: Dat kan heel erg gevaarlijk zijn en meestal laat je besturings systeem dat niet toe. Als je namelijk een verkeerd adres pakt kan je de werking van je PC ernstig verstoren.
  • Dat van blauwe schermen kan ik me wel voorstellen. Ik wou dit doen om te proberen een deel van het geheugen uit te lezen. Maar dus als ik het goed begrijp kan je een adres alleen toewijzen aan een pointer als het via de & operator gaat. Want vb 1 en vb 2 werken beide niet in mijn compiler (invalid conversion from int).
  • [quote:278f976804="microchip"]Maar dus als ik het goed begrijp kan je een adres alleen toewijzen aan een pointer als het via de & operator gaat. Want vb 1 en vb 2 werken beide niet in mijn compiler (invalid conversion from int).[/quote:278f976804]Nee, dat begrijp je niet goed. Voorbeeld 1 zou direct moeten werken. Bij voorbeeld 2 was ik wat slordig (ik had 'm ook niet gecompileerd :oops: ), en moet er nog een cast bij.
    [code:1:278f976804]
    ptr=(char*)0x3456789;
    [/code:1:278f976804]
    Door die cast geef je aan dat het getal een pointer naar een char voorstelt.
    Ik heb het voorbeeld nu gecompileerd onder Linux en het werkt (en inderdaad een segmentation-fault in vb 2).
    Onder Windows compileert het ook (zonder de printf's).
  • ok, het werkt nu, maar nu heb ik nog iets wat ik me afvraag:

    Als ik verschillende programma's tegelijk draai, en ik het adres van 2 int variablen laat zien zijn ze allebei (zelfs al draaien ze tegelijk) 0x22ff6c. De pointers die ernaartoe verwijzen, verwijzen in beide programma's naar hun eigen variable. En als ik in 1 van die programma's de declaratie van een int variable weghaal, en er toch een pointer toe laat verwijzen, krijg je niet netjes de inhoud van de variable van het andere programma, maar een waarde dat ik nooit heb toegewezen (dat laatste vind ik wel begrijpelijk, omdat dat met bestanden ook zo is).
  • Helaas weet ik daar zo geen antwoord op. Ik weet dat variabelen op twee plaatsen kunnen staan. Ergens in een dataruimte en ergens op de heap.

    Het volgende kan incorrect zijn:

    Een gewone variabele (hard gedeclareerd met bv [i:197e2c6d0c]int i[/i:197e2c6d0c]) wordt in de dataruimte van het programma opgeslagen, een variabele die met malloc en aanverwanten wordt aangemaakt staat in de heap.
    Als een variabele in de dataruimte van een programma staat, kan ik me zo voorstellen dat de pointer relatief is tot het begin van de dataruimte (een offset). Als je een programma een tweede keer start krijg je opnieuw een dataruimte en de variabele zal op dezelfde offset staan.

    Wat keywords waar je naar kunt zoeken, die hiermee gerelateerd zijn:
    segment:offset (o.a. hier), heap, far

Beantwoord deze vraag

Dit is een gearchiveerde pagina. Antwoorden is niet meer mogelijk.