Cara merangkai dan membuat serialisasi fungsi dengan membebani | operator

Pertama saya berasumsi Anda memiliki beberapa dasar yang terlihat seperti ini

#include <iostream>
struct vec2 {
    double x;
    double y;
};
std::ostream& operator<<(std::ostream& stream, vec2 v2) {return stream<<v2.x<<','<<v2.y;}

//real methods
vec2 translate(vec2 in, double a) {return vec2{in.x+a, in.y+a};} //dummy placeholder implementations
vec2 rotate(vec2 in, double a) {return vec2{in.x+1, in.y-1};}
vec2 scale(vec2 in, double a) {return vec2{in.x*a, in.y*a};}

Jadi yang Anda inginkan adalah kelas proksi untuk operasi, di mana objek proksi dibuat dengan fungsi dan parameter lainnya. (Saya menjadikan fungsi tersebut sebagai parameter templat, yang mencegah penggunaan penunjuk fungsi, dan membantu pengoptimal untuk melakukan inline, sehingga overhead ini hampir nol.)

#include <type_traits>
//operation proxy class
template<class rhst, //type of the only parameter
     vec2(*f)(vec2,rhst)> //the function to call
class vec2_op1 {
    std::decay_t<rhst> rhs; //store the parameter until the call
public:
    vec2_op1(rhst rhs_) : rhs(std::forward<rhst>(rhs_)) {}
    vec2 operator()(vec2 lhs) {return f(lhs, std::forward<rhst>(rhs));}
};

//proxy methods
vec2_op1<double,translate> translate(double a) {return {a};}
vec2_op1<double,rotate> rotate(double a) {return {a};}
vec2_op1<double,scale> scale(double a) {return {a};}

Dan kemudian Anda membuatnya bisa dirantai

//lhs is a vec2, rhs is a vec2_operation to use
template<class rhst, vec2(*f)(vec2,rhst)>
vec2& operator|(vec2& lhs, vec2_op1<rhst, f>&& op) {return lhs=op(lhs);}

Penggunaannya sederhana:

int main() {
    vec2 v2{3,5};
    v2 | translate(2.5) | rotate(30) | translate(3) | scale(2);
    std::cout << v2;
}

http://coliru.stacked-crooked.com/a/9b58992b36ff12d3

Catatan: Tidak ada alokasi, tidak ada petunjuk, tidak ada salinan atau pemindahan. Ini akan menghasilkan kode yang sama seperti jika Anda baru saja melakukan v2.translate(2.5); v2.rotate(30); v2.scale(10); secara langsung.

Untuk contoh vektor yang Anda tambahkan di komentar, Anda dapat memiliki sintaks seperti ini

MyVec vec = {1, 2};
auto vec2 = vec | rotate(90) | scale(2.0) | translate(1.0,2.0);

Cara kerjanya adalah dengan logika berikut:

class Transform {
public:
  virtual ~Transform () = default;
  virtual MyVector apply (const MyVector& in) const = 0;
};
inline MyVector operator| (const MyVector& v, const Transform& t) {
   return t.apply(v);
}

class Rotation : public Transform {
public:
  Rotation (int deg): m_deg(deg) {}
  MyVector apply (const MyVector& v) override {...}
private:
  int m_deg;
}:
Rotation rotate(int deg) { return Rotation(deg); }

dan sesuatu yang serupa untuk operator penskalaan dan operator terjemahan.

Perhatikan bahwa | bersifat asosiatif dari kiri ke kanan, jadi masukannya harus dimasukkan ke kiri. Namun Anda mungkin berpikir untuk menambahkan kelebihan beban ke masing-masing fungsi yang mengambil parameter transformasi dan vektor masukan, sehingga Anda dapat melakukan:

auto vec2 = rotate(90,vec) | scale(2.0) | translate(1.0,2.0);

Sintaks yang terakhir mungkin sedikit lebih intuitif daripada memulai perpipaan dengan, pada dasarnya, dan operator identitas.

Sekarang kompiler saya tersedia untuk saya dan lagi setelah mengerjakan proyek saya sebentar; Inilah yang dapat saya temukan...

Ini tidak sempurna karena function pointer untuk operator() memerlukan 2 parameter khusus seperti yang dapat dilihat pada kode contoh ini...

(Saya mungkin harus menggunakan templat variadik untuk ini serta tanda tangan untuk penunjuk fungsi agar memungkinkan penunjuk fungsi, objek fungsi, fungsi, atau ekspresi lambda dengan sejumlah parameter dari berbagai jenis untuk dapat diterima...)

Ini kode sumber kerja saya...

#pragma once    

#include <exception>
#include <iostream>
#include <memory>

template<typename T>
class pipe;

template<typename T>
class pipe_object {
private:
    T t_;
public:
    explicit pipe_object(T t) : t_{ t } {}

    explicit pipe_object(pipe<T> pipe) : t_{ pipe.current()->value() } {}

    pipe_object(const pipe_object<T>& other) {
        this->t_ = other.t_;
    }

    pipe_object<T>& operator=(const pipe_object<T>& other) {
        this->t_ = other.t_;
        return *this;
    }

    T value() const { return t_; }

    T operator()() {
        return t_;
    }
};

template<typename T>
class pipe {
private:
    std::shared_ptr<pipe_object<T>> current_;
    std::shared_ptr<pipe_object<T>> next_;

public:
    explicit pipe(T t) : 
        current_{ nullptr },
        next_{ nullptr } 
    {
        current_.reset(new pipe_object<T>(t));
    }

    pipe_object<T>* current() const { return current_.get(); }
    pipe_object<T>* next() const { return next_.get(); }

    T operator|(pipe<T> in) {
        pipe_object<T>* temp = current_.get();
        next_.reset(new pipe_object<T>(in));
        current_ = next_;
        return temp->value();
    }

    T operator()(T a, T b, T(*Func)(T,T)) {
        return Func(a,b);
    }
};

constexpr int add(int a, int b) {
    return a + b;
}

int main() {
    try {    
        pipe<int> p1(1);
        pipe<int> p2(3);

        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                int x = p1(i,j, &add) | p2(i,j, &add);
                std::cout << x << ' ';                
            }
            std::cout << '\n';
        }
        // Game game;      
        // game.run();      
    }
    catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

Dan inilah hasil yang diberikannya kepada saya:

0 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 10
2 3 4 5 6 7 8 9 10 11
3 4 5 6 7 8 9 10 11 12
4 5 6 7 8 9 10 11 12 13
5 6 7 8 9 10 11 12 13 14
6 7 8 9 10 11 12 13 14 15
7 8 9 10 11 12 13 14 15 16
8 9 10 11 12 13 14 15 16 17
9 10 11 12 13 14 15 16 17 18

Pipa operator|() tampaknya berfungsi untuk kelas pipe saya... dan saya harus menggunakan shared_ptr dari pipe_object untuk instance saat ini dan instance berikutnya... pipe_object hanyalah pembungkus dasar untuk beberapa tipe T. Satu-satunya fitur khusus dari kelas pipe_object adalah salah satu konstruktornya... Konstruktor itulah yang mengambil objek pipe dan mengekstrak nilai pipe tersebut menggunakannya untuk membuat pipe_object baru. Saya harus menggunakan petunjuk ganda karena sifat opeator|() adalah asosiatif tangan kanan...

Seperti yang Anda lihat dari kode sumber di atas dalam loop for ganda... Saya menggunakan objek pipe operator() untuk meneruskan nilai dan alamat ke suatu fungsi... Saya juga dapat pipe objek-objek ini tanpa memanggil operator()-nya. .. Langkah selanjutnya dari sini adalah menerapkan konsep ini tetapi menjadikannya umum untuk objek apa pun... kecuali saya bisa menggunakan kelas-kelas ini sebagai pembungkus untuk menggunakan teknik rangkaian pipa! Maksud saya dengan membuat kelas saya yang lain mewarisi dari kelas pipe ini seperti yang dilakukan seseorang dengan menggunakan CRTP.

Biarkan aku tahu apa yang Anda pikirkan!