Oppiskele Operaattorin Ylikuormitus | Polymorfismin Yleiskatsaus

Pyyhkäise näyttääksesi valikon

Operaattorien ylikuormitus on tehokas ominaisuus olio-ohjelmointikielissä, jonka avulla voit määritellä operaattoreille uuden toiminnan käyttäjän määrittelemille classes. Ylikuormittamalla operaattoreita voit tarjota räätälöityjä toteutuksia operaatioille, jotka koskevat class olioita, mahdollistaen intuitiivisemman ja ilmeikkäämmän koodin.

Operaattorien ylikuormituksen syntaksi

Ylikuormitus toteutetaan määrittelemällä erityisiä jäsenfunktioita tai ystäväfunktioita, jotka toteuttavat halutun toiminnan operaattorille. Operaattorien ylikuormituksen syntaksi vaihtelee sen mukaan, mitä operaattoria halutaan ylikuormittaa. Yleinen muoto näyttää tältä:

overloading.h


              1
            
return_type operator operator_symbol(parameters);

Syntaksi, eli tarkemmin sanottuna parametrien määrä ja palautustyyppi, riippuvat myös siitä, ylikuormitatko operaattoreita jäsenfunktioina vai ystäväfunktioina.

Member.h

Friend.h


              123456
            
class Example {
public:
    Example operator+ (const Example& other) {
        // Define behavior for operator+
    }
};

Ylikuormitettavissa olevien operaattoreiden taulukko

Alla on taulukko, jossa on lueteltu kaikki ylikuormitettavissa olevat operaattorit. On kuitenkin tärkeää huomata, että vaikka näiden operaattoreiden ylikuormittaminen on mahdollista, kaikkia ei ole lainkaan pakko ylikuormittaa omille classes-olioille.

Virran lisäysoperaattoreiden ylikuormitus

Ylikuormittaaksesi <<- ja >>-operaattorit class-tyypille, määritellään tyypillisesti ystäväfunktio tai jäsenfunktio, joka ottaa tulostusvirran (std::ostream&) tai syötevirran (std::istream&) vasemmaksi operandiksi ja olion omasta class-luokasta oikeaksi operandiksi. Tämä funktio muotoilee olion tiedot ja siirtää ne virtaan tai virrasta.

Point.h


              123456789101112131415
            
class Point {
public:
    friend std::ostream& operator<<(std::ostream& out, const Point& point);
    friend std::istream& operator>>(std::istream& in,  Point& point);
private: 
    int x, y;
};

std::ostream& operator<<(std::ostream& out, const Point& point) {
    return out << "x: " << point.x << ", y: " << point.y << std::endl;
}

std::istream& operator>>(std::istream& in,  Point& point) {
    return in >> point.x >> point.y;
}

Virran lisäysoperaattoreiden, kuten <<, ylikuormitus mahdollistaa oman tulostuskäyttäytymisen määrittelyn olioille omista classes-luokista, kun ne siirretään tulostusvirtaan, kuten std::cout. Tämä ominaisuus on erityisen hyödyllinen koodin luettavuuden ja käytettävyyden parantamiseksi työskenneltäessä omien tietotyyppien kanssa.

Huomio

<<-operaattorin ylikuormittaminen tulostusvirralle on yleisempää kuin >>-operaattorin ylikuormittaminen syötevirralle, koska syöteoperaatiot >>-operaattorilla voivat olla virhealttiimpia.

Aritmeettisten operaattoreiden ylikuormittaminen

Voit ylikuormittaa muita aritmeettisia operaattoreita (-, *, /, %) samalla tavalla suorittaaksesi mukautettuja operaatioita omilla tietotyypeilläsi.

main.cpp


              12345678910111213141516171819202122
            
#include <iostream>

class Point {
public:
    Point(int xCoord, int yCoord) : x(xCoord), y(yCoord) {}
    
    Point operator+(const Point& other) 
    {
        return Point(x + other.x, y + other.y);
    }
    
    int getX() { return x; }
    int getY() { return y; }
private: 
    int x, y;
};

int main()
{
    Point p = Point(2, 4) + Point(2, 6);
    std::cout << p.getX() << ' ' << p.getY() << std::endl;
}

Operaattori ylikuormitetaan luokan Point class jäsenfunktioksi. Se ottaa toisen Point olion parametrina ja palauttaa uuden Point olion, joka edustaa kahden pisteen summaa. +-operaattori voidaan korvata -, *, / tai %, ja toteutuslogiikkaa on muokattava vastaavasti.

Inkrementti ja dekrementti

Sekä etuliitteiset että jälkiliitteiset inkrementti- ja dekrementtioperaattorit (++ ja --) voidaan ylikuormittaa omille classes. Aloitetaan etuliitteisestä versiosta:

main.cpp


              123456789101112131415161718192021222324
            
#include <iostream>

class Point {
public:
    Point(int xCoord, int yCoord) : x(xCoord), y(yCoord) {}
    
    // Prefix increment operator (++point)
    Point& operator++() {
        ++x; ++y;
        return *this;
    }
    
    int getX() { return x; }
    int getY() { return y; }
private: 
    int x, y;
};

int main()
{
    Point p(2, 2);
    ++p;
    std::cout << p.getX() << ' ' << p.getY() << std::endl;
}

Huomio

Vähennysoperaattori ylikuormitetaan samalla tavalla kuin lisäysoperaattori, käyttämällä ---operaattoria ja vähennyslaskua.

Kuten huomaat, etuliitteisten lisäys- ja vähennysoperaattoreiden ylikuormitus on suoraviivaista. Jälkiliitteisten versioiden kanssa se on kuitenkin monimutkaisempaa. Muista, että suorituksen järjestyksessä on ero etuliitteisten ja jälkiliitteisten operaatioiden välillä.

Kun ylikuormitetaan jälkiliitteisiä lisäys- ja vähennysoperaattoreita, täytyy toteuttaa myös suorituksen järjestysominaisuus. Se näyttää suunnilleen tältä:

main.cpp


              1234567891011121314151617181920212223242526
            
#include <iostream>

class Point {
public:
    Point(int xCoord, int yCoord) : x(xCoord), y(yCoord) {}
    
    // Postfix increment operator (point++)
    Point operator++(int) {
        Point temp = *this; // Creating a temp variable
        ++(this->x); // Incrementing original Point's x
        ++(this->y); // Incrementing original Point's y
	    return temp; // Returning created temp variable
    }
    
    int getX() { return x; }
    int getY() { return y; }
private: 
    int x, y;
};

int main()
{
    Point p(2, 2);
    p++;
    std::cout << p.getX() << ' ' << p.getY() << std::endl;
}

Huomio

Kokonaislukuparametri välitetään ilman nimeä ainoastaan osoittamaan kääntäjälle, että jälkiliitteinen inkrementtioperaattori on ylikuormitettu. Tämä on tarpeen, koska etuliitteisen ja jälkiliitteisen operaattorin määrittelyt ovat muuten identtiset.

Jälkiliitteisen inkrementtioperaattorin toteutuksessa alkuperäinen olion arvo tallennetaan väliaikaiseen muuttujaan (temp). Nykyistä oliota kasvatetaan, mutta operaattori palauttaa arvon, joka on tallennettu muuttujaan temp. Tämä tarkoittaa, että muuttuja kasvaa, mutta muutos tulee voimaan vasta seuraavassa lausekkeessa, koska operaattori palauttaa alkuperäisen arvon.

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 5. Luku 4

Kysy tekoälyä

Kysy mitä tahansa tai kokeile jotakin ehdotetuista kysymyksistä aloittaaksesi keskustelumme

Osio 5. Luku 4