View Single Post
Sitat av ClockWorx Vis innlegg
Har fått med meg at læreren ikke er helt med, han er dårlig til å formulere oppgaver og forelesningene hans er generelt sett dårlige. Må jo bare ta det som en lærerik opplevelse og heller lære meg de litt "bedre" praksisene på egen hånd, takk for svar skal prøve ut dette nå! Et kvikt spørsmål bare, "this ->" har jeg sett tidligere, men forstår ikke helt hva den gjør. Fungerer den slik at den alltid vil bruke det klasseobjektet som blir benyttet for øyeblikket slik at man slipper å bytte om dette?

ville for eksempel noe slikt være mulig?

Kode

void Topp::skriv() {                    //  Skriver ALLE data:
	cout << this->navn;
	cout << this->moh;
	cout << this->hoyde;
	cout << this->lengde;			
}
Ville dette skrevet ut hvert enkelt objekts informasjon hvis jeg looper gjennom alle objektene?
Vis hele sitatet...
Ja, 'this' er en pointer som alltid peker til bunnen av sin egen klasse. Så hvis du jobber på innsiden av en metode som tilhører klassen 'Topp', så vil 'this' peke til bunnen av klassen 'Topp'. Og legg merke til at når jeg sier bunnen, så mener jeg ikke bunnen av klassen bokstavelig, men heller toppen.

Grunnen til at jeg sier bunnen er fordi når koden din blir kompilert, så vil det som oftest (jeg kan ikke si alltid, siden det finnes rimelig mange minne/CPU arkitekturer og systemer i verden) føre til at «starten» av klassen din ligger på et lavere minne adresse en egenskapene og metodene i klassen gjør. Hvis du ser på eksemplet under:

Kode

#include <cstdlib>
#include <iostream>

class Foo
{
        private:
                int a;
                int b;
                int c;

        public:
                std::ptrdiff_t diff_a(); // Henter differancen mellom this -> a og this oppgitt i byte
                std::ptrdiff_t diff_b(); // Henter differancen mellom this -> b og this oppgitt i byte
                std::ptrdiff_t diff_c(); // Henter differancen mellom this -> c og this oppgitt i byte
};

std::ptrdiff_t Foo::diff_a()
{
        std::ptrdiff_t address_this = reinterpret_cast<std::ptrdiff_t>(this);
        std::ptrdiff_t address_a = reinterpret_cast<std::ptrdiff_t>(&(this -> a));

        return(address_a - address_this);
}

std::ptrdiff_t Foo::diff_b()
{
        std::ptrdiff_t address_this = reinterpret_cast<std::ptrdiff_t>(this);
        std::ptrdiff_t address_b = reinterpret_cast<std::ptrdiff_t>(&(this -> b));

        return(address_b - address_this);
}

std::ptrdiff_t Foo::diff_c()
{
        std::ptrdiff_t address_this = reinterpret_cast<std::ptrdiff_t>(this);
        std::ptrdiff_t address_c = reinterpret_cast<std::ptrdiff_t>(&(this -> c));

        return(address_c - address_this);
}

int main(int argc, char **argv)
{
        Foo foo;

        std::cout << "&(this -> a) - this = " << foo.diff_a() << std::endl;
        std::cout << "&(this -> b) - this = " << foo.diff_b() << std::endl;
        std::cout << "&(this -> c) - this = " << foo.diff_c() << std::endl;

        return(EXIT_SUCCESS);
}
Output:

Kode

&(this -> a) - this = 0
&(this -> b) - this = 4
&(this -> c) - this = 8
Så vil du se at 'this' peker til samme adresse som 'this -> a' (0 i differanse mellom disse to). Mens 'this -> b' ligger 4 byte over minne adressen til 'this' eller 'this -> a' (int er normalt 4 byte, altså &(this -> a) + 4) og samme med c. Så når man sier at den peker til bunnen av en klasse, så mener man med andre ord toppen.
Sist endret av 0xFF; 14. november 2017 kl. 13:29.