Oppiskele Operaattorin Ylikuormitus | Polymorfismin Yleiskatsaus

Operaattorien ylikuormitus on tehokas ominaisuus olio-ohjelmointikielissä, jonka avulla voit määritellä uudelleen operaattoreiden 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 toiminnallisuuden 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+
    }
};

Ylikuormitettavien operaattoreiden taulukko

Tässä on taulukko, jossa on lueteltu kaikki operaattorit, jotka voidaan ylikuormittaa. On kuitenkin tärkeää huomata, että vaikka näiden operaattoreiden ylikuormittaminen on mahdollista, kaikkia ei ole lainkaan pakko ylikuormittaa omille classes.

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 class-olion 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 mukautetun tulostuskäyttäytymisen määrittelyn classes-olioille, 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 ylikuormitus tulostusvirralle on yleisempää kuin >>-operaattorin ylikuormitus syötevirralle, koska syöteoperaatiot >>-operaattorilla voivat olla virhealttiimpia.

Aritmeettisten operaattoreiden ylikuormitus

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 Point class jäsenfunktioksi. Se ottaa parametrina toisen Point olion ja palauttaa uuden Point olion, joka edustaa kahden pisteen summaa. +-operaattori voidaan korvata -, *, / tai % -operaattorilla, jolloin toteutuslogiikkaa on muutettava vastaavasti.

Inkrementointi ja dekrementointi

Sekä etuliite- että jälkiliiteinkrementointi- ja dekrementointioperaattorit (++ ja --) voidaan ylikuormittaa omille classes. Aloitetaan etuliiteversiosta:

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äen ---operaattoria ja vähennyslaskua.

Kuten huomaat, etuliitteisten lisäys- ja vähennysoperaattoreiden ylikuormittaminen on suoraviivaista. Kuitenkin jälkiliitteisten versioiden kanssa se on 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 myös toteuttaa 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;
}

Huomautus

Kokonaislukuparametri välitetään ilman nimeä ainoastaan osoittamaan kääntäjälle, että jälkimmäinen inkrementtioperaattori ylikuormitetaan. Tämä on tarpeen, koska etu- ja jälkiliitteisten operaattoreiden määrittelyt ovat muuten identtiset.

Jälkiliitteisen inkrementtioperaattorin toteutuksessa alkuperäinen olion arvo tallennetaan väliaikaiseen muuttujaan (temp). Nykyistä oliota kasvatetaan, mutta operaattori palauttaa temp-muuttujaan tallennetun arvon. 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

Pyyhkäise näyttääksesi valikon

Operaattorien ylikuormituksen syntaksi

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+
    }
};

Ylikuormitettavien operaattoreiden taulukko

Virran lisäysoperaattoreiden ylikuormitus

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;
}

Huomio

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

Aritmeettisten operaattoreiden ylikuormitus

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;
}

Inkrementointi ja dekrementointi

Sekä etuliite- että jälkiliiteinkrementointi- ja dekrementointioperaattorit (++ ja --) voidaan ylikuormittaa omille classes. Aloitetaan etuliiteversiosta:

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äen ---operaattoria ja vähennyslaskua.

Kun ylikuormitetaan jälkiliitteisiä lisäys- ja vähennysoperaattoreita, täytyy myös toteuttaa 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;
}

Huomautus

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 5. Luku 4