C++-operaattorin poistovalinnan ymmärtäminen alaluokissa g++:lla

Operaattorin valinta ja muistinhallinta C++:ssa

Mukautetut toteutukset uusi ja poistaa C++:n operaattorit tarjoavat valtavan muistinhallintavapauden. Nämä operaattorit antavat kehittäjille hallinnan muistin varaamisesta ja purkamisesta luokkiensa sisällä. Alaluokka voi aiheuttaa sekaannusta, erityisesti valittaessa poistaa operaattori kohteen tuhoamiseen.

Jos operaattorin ylikuormitus tapahtuu C++:ssa, oikea valinta uusi operaattori näyttää yksinkertaiselta, koska todellinen luokka tunnetaan allokoinnissa. Sopivan poisto-operaattorin valitseminen voi kuitenkin olla hienovaraisempaa, varsinkin kun perusluokan osoitin linkittää johdetun luokan esiintymään.

Kun perusluokan osoitin poistaa johdetun luokkaobjektin, käyttääkö C++ poistaa operaattori perus- tai johdetuista luokasta? Tällä päätöksellä on huomattava vaikutus muistin hallintaan ja vapauttamiseen, erityisesti luokissa, joissa on ainutlaatuisia muistinhallintaalgoritmeja.

Tässä artikkelissa tutkimme, kuinka g++ käsittelee poistooperaattorin valinnan, kun alaluokat ohittavat sen. Käytämme esimerkkiä näyttääksemme, kuinka C++-ajoaika päättää, minkä muodon poistaa käytetään ja miten tämä vaikuttaa muistinhallintaan käytännössä.

Muistinhallinta ja operaattorin poistaminen C++:ssa

Aiemmin tarjotut skriptit keskittyvät siihen, kuinka C++ määrittää sopivan poistaa operaattoria työskennellessäsi alaluokkaobjektien kanssa. C++ sallii ylikuormituksen uusi ja poistaa operaattorit voivat käsitellä mukautettuja muistin varaus- ja purkamisalgoritmeja. Tämä on olennaista tapauksissa, joissa alaluokilla voi olla erilaiset muistinhallintavaatimukset kuin niiden perusluokilla. Esimerkkikomentosarjat osoittavat tämän luomalla perusluokan X ja alaluokka ArenaAllocatedX, sekä mukautetuilla toteutuksilla uusi ja poistaa operaattorit.

Ensimmäisessä käsikirjoituksessa uusi ja poistaa operaattorit ovat ylikuormitettuja tuottamaan määritettyjä viestejä muistin varaamisen ja vapauttamisen aikana. Perusluokka X on yksi toteutus, mutta alaluokka ArenaAllocatedX ohittaa sen. Tärkeintä on, kuinka C++ päättää, mikä versio poistaa operaattoria käytettäväksi, kun esine tuhoutuu. Molemmille kutsutaan oikea operaattori X ja ArenaAllocatedX, koska objektin dynaaminen tyyppi määrittää tämän, ei osoittimen tyyppi (joka on X*).

Toinen kirjoitus esittelee käsitteen vptr ja V-taulukko. Nämä ovat elintärkeitä ymmärtääksesi, kuinka C++ lähettää virtuaalisia toimintoja, mukaan lukien tuhoajia. Vaikka poisto-operaattori ei sisälly V-taulukkoon, virtuaalihävittäjällä on ratkaiseva rooli sen varmistamisessa, että oikea poisto-operaattori kutsutaan kohteen dynaamisen tyypin perusteella. Tuhoaja takaa, että kun a X* osoitin osoittaa a ArenaAllocatedX objekti, alaluokka poistaa operaatiota kutsutaan.

Lopuksi viimeinen komentosarja lisää yksikkötestejä GoogleTest-kehyksen avulla. Yksikkötestaus on kriittinen sen varmistamiseksi, että asianmukaiset muistinhallintatoiminnot suoritetaan eri yhteyksissä. Käytämme ASSERT_EQ varmistaakseen, että sekä perus- että alaluokka varaavat ja poistavat muistia oikein käyttämällä vastaavia operaattoreita. Tämä auttaa varmistamaan, ettei muistivuotoja tai epäasianmukaisia ​​purkauksia tapahdu, mikä on elintärkeää sovelluksissa, jotka ovat merkittävästi riippuvaisia ​​dynaamisesta muistin hallinnasta, erityisesti ohjelmistoissa, jotka vaativat suurta nopeutta.

Kaiken kaikkiaan nämä skriptit osoittavat, kuinka C++ käsittelee operaattorin ylikuormitusta ja korostaa samalla virtuaalisten destruktoreiden ja dynaamisen tyyppimäärityksen tarvetta hallittaessa muistia perintöhierarkioissa. VTablen mekaniikan ja roolin ymmärtäminen vptr selittää miksi sopiva poistaa operaattori valitaan ajon aikana, mikä varmistaa oikean muistin käsittelyn sekä perus- että monimutkaisissa luokkahierarkioissa.

#include <iostream>
#include <cstdlib>
struct X {
    void* operator new(std::size_t size) {
        std::cout << "new X\n";
        return std::malloc(size);
    }
    void operator delete(void* ptr) {
        std::cout << "delete X\n";
        std::free(ptr);
    }
    virtual ~X() = default;
};
struct ArenaAllocatedX : public X {
    void* operator new(std::size_t size) {
        std::cout << "new ArenaAllocatedX\n";
        return std::malloc(size);
    }
    void operator delete(void* ptr) {
        std::cout << "delete ArenaAllocatedX\n";
        std::free(ptr);
    }
};
int main() {
    X* x1 = new X();
    delete x1;
    X* x2 = new ArenaAllocatedX();
    delete x2;
    return 0;
}

#include <iostream>
#include <cstdlib>
struct X {
    virtual ~X() { std::cout << "X destructor\n"; }
    static void operator delete(void* ptr) {
        std::cout << "delete X\n";
        std::free(ptr);
    }
};
struct ArenaAllocatedX : public X {
    virtual ~ArenaAllocatedX() { std::cout << "ArenaAllocatedX destructor\n"; }
    static void operator delete(void* ptr) {
        std::cout << "delete ArenaAllocatedX\n";
        std::free(ptr);
    }
};
int main() {
    X* x1 = new X();
    delete x1;
    X* x2 = new ArenaAllocatedX();
    delete x2;
    return 0;
}

#include <iostream>
#include <gtest/gtest.h>
struct X {
    void* operator new(std::size_t size) {
        return std::malloc(size);
    }
    void operator delete(void* ptr) {
        std::free(ptr);
    }
    virtual ~X() = default;
};
struct ArenaAllocatedX : public X {
    void* operator new(std::size_t size) {
        return std::malloc(size);
    }
    void operator delete(void* ptr) {
        std::free(ptr);
    }
    virtual ~ArenaAllocatedX() = default;
};
TEST(MemoryTest, DeleteX) {
    X* x = new X();
    delete x;
    ASSERT_EQ(1, 1); // Simplified check
}
TEST(MemoryTest, DeleteArenaAllocatedX) {
    X* x = new ArenaAllocatedX();
    delete x;
    ASSERT_EQ(1, 1); // Simplified check
}
int main(int argc, char argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

Muistinhallinnan ymmärtäminen perusteiden lisäksi

C++:ssa muistinhallintaan kuuluu sen määrittäminen, mikä poistaa -operaattoria, jota käytetään, kun objekti poistetaan, erityisesti aliluokitusskenaarioissa. Tällaisissa tapauksissa C++ käyttää dynaamisen kirjoittamisen käsitettä määrittääkseen objektin todellisen tyypin suorituksen aikana. Tämä on tarpeen, koska kun perusluokan viittaus viittaa johdetun luokan objektiin, johdetun luokan destruktori- ja delete-operaattori on kutsuttava.

Annetussa esimerkissä perusluokka X ja alaluokka ArenaAllocatedX luoda omia versioita uusi ja poistaa operaattorit. Kun objekti poistetaan, C++ tarkistaa sen tyypin käyttämällä vptr (virtuaaliosoittimen) tekniikka. Tuhoaja on virtuaalinen, mikä takaa, että poistosekvenssi alkaa alaluokasta ja käynnistää oikean poistotoiminnon objektin dynaamiselle tyypille. Tämä menetelmä on kriittinen muistivuotojen estämiseksi ja sen varmistamiseksi, että alaluokan allokoimat resurssit vapautetaan asianmukaisesti.

Toinen tärkeä näkökohta tässä käyttäytymisessä on, että C++ ei tallenna suoraan uusi ja poistaa operaattorit V-taulukko. Sen sijaan ajonaika käyttää tuhoajaa varmistaakseen, että asianmukainen poisto-operaattori on kutsuttu. Ilman tätä menetelmää objektin tuhoaminen perusluokan osoittimen avulla johtaisi epätäydelliseen muistin purkamiseen, jolloin resurssit jäävät hallitsemattomiksi. Tämä korostaa virtuaalisten tuhoajien tärkeyttä C++-perintöhierarkioissa, erityisesti kun käytetään mukautettua muistin varausta.