Jobbérték referenciák

A create_noisy_on_return() és create_noisy_from_local() függvényekben tud RVO-t használni a fordító. Ha optimalizálhatja a másolásokat, akkor itt egyáltalán nem történik se másolás, se mozgatás.

A create_noisy_with_move() függvény egy tipikus kódolási hibát mutat. A lokális változóknál nem kell külön engedélyezni a mozgatást a visszatérési értékben; ha nem engedélyezzük, akkor is mozgatás történik, ha van ilyen konstruktor. Az std::move()-ot kiírva viszont letiltjuk a visszatérési érték optimalizációját, mivel azt csak akkor tudja alkalmazni a fordító, ha egy változónevet adunk meg a return utasításnál.

A do_something_with_noisy_cref() függvénynél biztosan nem látunk másolást, mert referencia paraméterű. A do_something_with_noisy_value() függvénynek értékparamétere van, de lehet, hogy itt sem látunk másolást. Mivel a jobbérték objektumnak nincs neve, biztos, hogy senki más nem látja, ezért „elhasználható” a függvény paramétereként. Érdekes, hogy emiatt az optimalizáció miatt néha gyorsabb lehet a program értékparaméterrel, mint referenciaparaméterrel.

Ehhez mozgató konstruktort és értékadó operátort kell csinálni. Ezek paraméterébe jobbérték referencia kell, de figyelni kell arra, hogy a jobbérték referencián keresztül az objektumot balértéknek látjuk (mert neve van). Így std::move-olni kell legalább a sztringet, hogy annak a tartalmát is mozgatni lehessen, másolás helyett.

Az std::vector-nak (és a többi szabványos tárolónak) vannak jobbértéket átvevő beszúró függvényei, pl. push_back(T&&).

#include <cstdio>
#include <vector>
#include <stdexcept>
#include <string>
#include <iostream>

/* FILE* RAII */
class FilePtr {
  public:
    FilePtr(char const *filename, char const *mode)
      : fp_{fopen(filename, mode)}
      , name_{filename} {
        if (fp_ == nullptr)
            throw std::runtime_error("no such file");
        std::cerr << "Opened " << name_ << std::endl;
    }
    ~FilePtr() {
        close_if_open();
    }
    /* nem másolható */
    FilePtr(FilePtr const &) = delete;
    FilePtr & operator=(FilePtr const &) = delete;
    /* de mozgatható */
    FilePtr(FilePtr && the_other) noexcept
      : fp_{std::move(the_other.fp_)}
      , name_{std::move(the_other.name_)} {
        the_other.fp_ = nullptr;
    }
    FilePtr & operator=(FilePtr && rhs) noexcept {
        if (fp_ != rhs.fp_) {
            close_if_open();
            /* a pointernél nem lenne muszáj move-olni, de a sztringnél érdemes! */
            fp_ = std::move(rhs.fp_);
            name_ = std::move(rhs.name_);
            rhs.fp_ = nullptr;
        }
        return *this;
    }

    operator FILE* () const {
        return fp_;
    }
  private:
    FILE *fp_;
    std::string name_;

    void close_if_open() {
        if (fp_ != nullptr) {
            fclose(fp_);
            std::cerr << "Closed " << name_ << std::endl;
        }
        fp_ = nullptr;
        name_.clear();
    }
};


/* ne lehessen ilyet csinálni (az operator FILE* miatt lehetne) */
void fclose(FilePtr) = delete;


FilePtr open_for_writing(char const *name) {
    return FilePtr{name, "wt"};
}


int main() {
    std::vector<FilePtr> files;
    files.push_back(open_for_writing("hello.txt"));
    files.push_back(open_for_writing("hello2.txt"));
    fprintf(files[0], "hello.txt");
    fprintf(files[1], "hello.txt");
}

A programrész működni fog: a pointer átmásolódik az új objektumba, és a régi objektum pointere kinullázódik. A furcsaság, vagy inkább hiba, benne az std::move helytelen használata. Ebben a kontextusban egyáltalán nincsen rá szükség. Amikor egy sztringtől elvesszük az erőforrást, akkor a sztring a jobbérték, nem pedig az objektum; a sztringre mondjuk azt, hogy belőle az erőforrás kivehető. A pointernél már semmi értelme a jobbértékké konvertálásnak; a beépített típusok amúgy sem mozgathatóak, csak másolhatóak. (Mit jelentene egy int mozgatása?)

Az összes feladat megoldása. A kommentek magyaráznak, ahol kell. A teszteléshez érdemes kikapcsolni a másolások optimalizálását (-fno-elide-constructors), akkor látszik az összes copy és move.

#include <iostream>
#include <iomanip>
#include <initializer_list>
#include <algorithm>
#include <cassert>

/* másolás/mozgatás üzenetek: 0 vagy 1 */
#define DEBUG 1

class Matrix {
  public:
    /* létrehozás */
    Matrix();
    Matrix(size_t w, size_t h);
    Matrix(size_t w, size_t h, std::initializer_list<double> init);

    /* az öt függvény */
    ~Matrix();
    Matrix(Matrix const &the_other);
    Matrix & operator=(Matrix const &rhs);
    Matrix(Matrix && the_other) noexcept;
    Matrix & operator=(Matrix &&rhs) noexcept;

    /* hogy csinálni is lehessen vele valamit */
    size_t get_w() const { return w_; }
    size_t get_h() const { return h_; }
    /* konstans indexelés */
    double const & operator()(size_t x, size_t y) const;
    /* nem konstans indexelés: ugyanaz, mint a konstans, csak a const levarázsolva */
    double & operator()(size_t x, size_t y) {
        return const_cast<double &>(const_cast<Matrix const &>(*this)(x, y));
    }
    
    /* összeadások */
    friend Matrix operator+(Matrix const &a, Matrix const &b);
    friend Matrix operator+(Matrix &&a, Matrix const &b);

  private:
    size_t w_;
    size_t h_;
    double *data_;
    class Uninitialized {};
    Matrix(size_t w, size_t h, Uninitialized);
};


/* az alapértelmezett konstruktor által létrehozott mátrixnak nincs erőforrása.
 * így fog kinézni a mozgató konstruktor által kiürített mátrix is.
 * a nullptr-re a delete[] hatástalan, így a destruktorban is jó lesz. */
Matrix::Matrix()
: w_{0}
, h_{0} {
    data_ = nullptr;
}


/* ez a konsturktor privát, csak a kódduplikáció elkerülésére van.
 * létrehozza a mátrix tömbjét, de nem inicializálja. */
Matrix::Matrix(size_t w, size_t h, Uninitialized)
: w_{w}
, h_{h} {
    data_ = new double[w_*h_];
}


/* alapértelmezett konstruktor. nullákkal inicializálja. */
Matrix::Matrix(size_t w, size_t h)
: Matrix{w, h, Uninitialized{}} {
    std::fill(data_, data_ + w_*h_, 0.0);
}


/* adott számokkal inicializálás. */
Matrix::Matrix(size_t w, size_t h, std::initializer_list<double> init)
: Matrix{w, h} {
    /* ellenőrizzük, hogy tényleg akkora-e az init lista, mint a mátrix.
     * ha nem, programozói hiba. azért nem érdemes itt kivételt, mert
     * ez nem futási időben derül ki, hanem már a kódban el van rontva. */
    assert(w*h == init.size()); 
    std::copy(init.begin(), init.end(), data_);
}


Matrix::~Matrix() {
    delete[] data_;
}


/* létrehozza a privát konstruktorral a megfelelő méretű tömböt.
 * utána már csak be kell másolnia a számokat. */
Matrix::Matrix(Matrix const &the_other)
: Matrix{the_other.w_, the_other.h_} {
    std::copy(the_other.data_, the_other.data_ + w_*h_, data_);
#if DEBUG
    std::cerr << w_ << "x" << h_ << " matrix copied\n";
#endif
}


/* op= = dtor+copy */
Matrix & Matrix::operator=(Matrix const &rhs) {
    if (this == &rhs)
        return *this;
    /* ha nem akkora, amekkorából értéket adunk, átméretezés */
    if (w_ != rhs.w_ || h_ != rhs.h_) {
        delete[] data_;
        w_ = rhs.w_;
        h_ = rhs.h_;
        data_ = new double[w_*h_];
    }
    /* a számokat másolni mindig kell */
    std::copy(rhs.data_, rhs.data_ + w_*h_, data_);
    return *this;
}


Matrix::Matrix(Matrix &&the_other) noexcept {
    /* ez olyan lesz, mint a másik */
    w_ = the_other.w_;
    h_ = the_other.h_;
    data_ = the_other.data_;
    /* a másik meg üres, mint a default ctoros */
    the_other.w_ = 0;
    the_other.h_ = 0;
    the_other.data_ = nullptr;
#if DEBUG
    std::cerr << w_ << "x" << h_ << " matrix moved\n";
#endif
}


Matrix & Matrix::operator=(Matrix &&rhs) noexcept {
    if (this == &rhs)
        return *this;
    /* itt nem varázsolunk a méretekkel, mert csak le kell nyúlni a tömböt */
    delete[] data_;
    w_ = rhs.w_;
    h_ = rhs.h_;
    data_ = rhs.data_;
    rhs.w_ = 0;
    rhs.h_ = 0;
    rhs.data_ = nullptr;
    return *this;
}


/* indexelő operátor. vigyázat, 1-től kell indexelni, mint matek órán! */
double const & Matrix::operator()(size_t x, size_t y) const {
    if (x < 1 || x > w_ || y < 1 || y > h_)
        throw std::out_of_range{"invalid index for matrix"};
    return data_[(y-1)*w_ + (x-1)];
}


std::ostream & operator<<(std::ostream & os, Matrix const &m) {
    for (size_t y = 1; y <= m.get_h(); ++y) {
        os << "[";
        for (size_t x = 1; x <= m.get_w(); ++x)
            os << std::setw(4) << m(x, y);
        os << "   ]\n";
    }
    return os;
}


/* az összeadásnál nem indexelgetünk. csak egymástól függetlenül
 * össze kell adni az összes számot és kész. */
Matrix operator+(Matrix const &a, Matrix const &b) {
    if (a.w_ != b.w_ || a.h_ != b.h_)
        throw std::out_of_range{"matrix sizes do not match in operator+"};
    Matrix sum{a.w_, a.h_, Matrix::Uninitialized{}};
    for (size_t i = 0; i != a.w_*a.h_; ++i)
        sum.data_[i] = a.data_[i] + b.data_[i];
    return sum;
}


/* ha az egyik operandus balérték, akkor lenyúlhatjuk a tömbjét.
 * std::move-olni kell, mert a-n keresztül balértéknek látszik!
 * (úgy is írhatnánk, hogy a[i]+=b[i], aztán return std::move(a).) */
Matrix operator+(Matrix &&a, Matrix const &b) {
    if (a.w_ != b.w_ || a.h_ != b.h_)
        throw std::out_of_range{"matrix sizes do not match in operator+"};
    Matrix sum{std::move(a)};
    for (size_t i = 0; i != a.w_*a.h_; ++i)
        sum.data_[i] += b.data_[i];
    return sum;
}


/* ha a másik a jobbérték, akkor egyszerűen megcseréljük őket-
 * ez oké, mert kommutatív az összeadás. move kell! */
Matrix operator+(Matrix const &a, Matrix &&b) {
    return std::move(b)+a;
}


/* ha csak a fenti függvények lennének, jobbérték+jobbérték
 * ambiguous lenne. viszont mindegy, melyikből mozgatunk. */
Matrix operator+(Matrix &&a, Matrix &&b) {
    return std::move(a)+b;
}


int main() {
    Matrix m{2, 3, {
        1, 2,
        3, 4,
        5, 6,
    }};
    const Matrix n{2, 3, {
        2, 3,
        4, 5,
        6, 7,
    }};
    
    std::cout << m;
    std::cout << m + n;
    std::cout << (m+n)+m;   /* jobb+bal */
    std::cout << m+(n+m);   /* bal+jobb */
    std::cout << (m+n)+(n+m);   /* jobb+jobb */
}