Supraîncărcarea operatorului

Aflați cum să supraîncărcați corect operatorii — membru vs non-membru, forme canonice, operatori de flux, operatorul navei spațiale C++20 și capcanele comune.

Filosofia supraîncărcării operatorului

C++ vă permite să definiți modul în care operatorii (+,==,<<,[]etc.) funcționează pentru propriile tipuri. Regula de aur: faceți ceea ce fac ints. Operatorii supraîncărcați ar trebui să se comporte așa cum se așteaptă utilizatorii de la tipurile încorporate. Dacăa + bmodificăa, ați încălcat așteptările utilizatorilor.

Supraîncărcarea operatorului este ceea ce face ca tipuri precumstd::string,std::vectorșistd::complexsă pară naturale. Dar folosit prost, creează cod confuz, care nu poate fi întreținut. Nu supraîncărcați niciodată operatorii pentru a face ceva surprinzător.

Operatori membri vs. nemembri

Unii operatori trebuie să fie membri (=,[],->,()). Alții sunt mai buni ca non-membri (în special operatori binari precum+și==) pentru a permite conversiile simetrice. Modelul canonic: implementați+=ca membru, apoi+ca non-membru folosind+=.

operators.cpp

#include <iostream>

class Vec2 {
    double x_, y_;

public:
    Vec2(double x = 0, double y = 0) : x_{x}, y_{y} {}

    // += is a member: modifies *this
    Vec2& operator+=(const Vec2& rhs) {
        x_ += rhs.x_;
        y_ += rhs.y_;
        return *this;
    }

    // Unary minus (member)
    Vec2 operator-() const {
        return Vec2{-x_, -y_};
    }

    // Accessors for non-member operators
    double x() const { return x_; }
    double y() const { return y_; }

    // [] operator (must be member)
    double& operator[](int i) {
        return i == 0 ? x_ : y_;
    }
    const double& operator[](int i) const {
        return i == 0 ? x_ : y_;
    }
};

// + is a non-member using +=  (canonical form)
Vec2 operator+(Vec2 lhs, const Vec2& rhs) {  // lhs by value!
    lhs += rhs;
    return lhs;
}

// == as non-member (symmetric: allows conversions on both sides)
bool operator==(const Vec2& a, const Vec2& b) {
    return a.x() == b.x() && a.y() == b.y();
}

// Stream output operator (must be non-member)
std::ostream& operator<<(std::ostream& os, const Vec2& v) {
    return os << '(' << v.x() << ", " << v.y() << ')';
}

int main() {
    Vec2 a{1.0, 2.0}, b{3.0, 4.0};
    Vec2 c = a + b;           // uses non-member operator+
    std::cout << c << '\n';   // (4, 6)
    std::cout << -c << '\n';  // (-4, -6)
    std::cout << c[0] << '\n'; // 4
    std::cout << std::boolalpha << (a == b) << '\n'; // false
    return 0;
}

Operator de navă spațială C++20 (<=>)

C++20 introduce operatorul de comparație în trei sensuri<=>(„operatorul navei spațiale”). O singură definițieoperator<=>generează automat toți cei șase operatori de comparație (<,>,<=,>=,==,!=). Folosiți= defaultatunci când doriți să comparați în funcție de membri.

spaceship.cpp

#include <iostream>
#include <compare>
#include <string>

class Version {
    int major_;
    int minor_;
    int patch_;

public:
    Version(int major, int minor, int patch)
        : major_{major}, minor_{minor}, patch_{patch} {}

    // Defaulted <=>: compares members in declaration order
    auto operator<=>(const Version&) const = default;

    friend std::ostream& operator<<(std::ostream& os, const Version& v) {
        return os << v.major_ << '.' << v.minor_ << '.' << v.patch_;
    }
};

class Student {
    std::string name_;
    double gpa_;

public:
    Student(const std::string& name, double gpa)
        : name_{name}, gpa_{gpa} {}

    // Custom <=>: compare only by GPA
    auto operator<=>(const Student& other) const {
        return gpa_ <=> other.gpa_;
    }

    // Need separate == if <=> is not defaulted
    bool operator==(const Student& other) const {
        return gpa_ == other.gpa_;
    }

    friend std::ostream& operator<<(std::ostream& os, const Student& s) {
        return os << s.name_ << " (GPA: " << s.gpa_ << ')';
    }
};

int main() {
    Version v1{2, 0, 0}, v2{1, 9, 5};
    std::cout << v1 << " > " << v2 << "? "
              << std::boolalpha << (v1 > v2) << '\n';  // true
    std::cout << (v1 == v2) << '\n';  // false

    Student alice{"Alice", 3.9};
    Student bob{"Bob", 3.7};
    std::cout << (alice > bob) << '\n';  // true (higher GPA)
    return 0;
}

operator() — Obiecte funcție

Supraîncărcareaoperator()creează un functor (obiect funcție). Functorii pot deține stare, făcându-i mai flexibili decât indicatorii de funcție simpli. Ele sunt utilizate pe scară largă cu algoritmii STL.

functor.cpp

#include <iostream>
#include <vector>
#include <algorithm>

// A functor that counts how many times it's called
class Counter {
    int count_ = 0;
    int threshold_;

public:
    explicit Counter(int threshold) : threshold_{threshold} {}

    bool operator()(int value) {
        ++count_;
        return value > threshold_;
    }

    int calls() const { return count_; }
};

int main() {
    std::vector<int> nums{1, 5, 3, 8, 2, 9, 4, 7, 6};

    Counter above_five{5};
    auto count = std::count_if(nums.begin(), nums.end(), above_five);
    std::cout << count << " elements above 5\n";  // 4

    // Functors can also be used directly
    Counter is_positive{0};
    std::cout << std::boolalpha;
    std::cout << is_positive(42) << '\n';   // true
    std::cout << is_positive(-1) << '\n';   // false
    std::cout << "Calls: " << is_positive.calls() << '\n';  // 2

    return 0;
}

Capcană

Nu supraîncărcați operatorii pentru a face lucruri surprinzătoare.operator+ar trebui să adauge, nu să scadă.operator*pe unMatrixar trebui să facă înmulțirea matricei, nu înmulțirea în funcție de elemente (cu excepția cazului în care asta se așteaptă domeniul dvs.). Unii operatori nu pot fi supraîncărcați:::,.,.*,?:șisizeof. De asemenea, supraîncărcarea&&și||pierde evaluarea scurtcircuitului - aproape niciodată o idee bună.

Bună practică

Urmați formele canonice: implementați atribuirea compusă (+=,-=) ca membri, apoi definiți operatorii binari (+,-) ca non-membri folosind versiunea compusă. Implementați întotdeaunaoperator==dacă implementațioperator<(sau mai bine, utilizați C++20<=>pentru a obține toate cele șase). Implementați operatorii de flux (<<,>>) ca prieteni non-membri. Utilizațiexplicitpe operatorii de conversie pentru a preveni conversiile implicite accidentale.

Idei cheie

Urmați principiul „fă ceea ce fac ints” — operatorii ar trebui să se comporte așa cum se așteaptă utilizatorii
Implementați atribuirea compusă (+=) ca membru, apoi+ca non-membru folosind+=
operator<=>de la C++20 generează toți cei șase operatori de comparație dintr-o singură definiție
Supraîncărcareaoperator()creează functori — obiecte care pot fi numite ca funcții
&&,||pierd evaluarea scurtcircuitului atunci când sunt supraîncărcate - evitați supraîncărcarea acestora
Unii operatori nu pot fi supraîncărcați:::,.,.*,?:,sizeof

Test — Verifică-ți cunoștințele

(15 XP)

1. De ce este de obicei implementat`operator+`ca o funcție non-membră?

2. Ce face`auto operator<=>(const T&) const = default;`în C++20?

3. Why should you avoid overloading`operator&&`and`operator||`?

Funcții virtuale, vtable și polimorfism

Următor

Static Members, Singletons & PIMPL