วิธีเชื่อมโยงและทำให้เป็นอนุกรมฟังก์ชันโดยการโอเวอร์โหลด | ตัวดำเนินการ

ก่อนอื่นฉันคิดว่าคุณมีพื้นฐานบางอย่างที่มีลักษณะเช่นนี้

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

ดังนั้นสิ่งที่คุณต้องการคือคลาสพร็อกซีสำหรับการดำเนินการ โดยที่อ็อบเจ็กต์พร็อกซีถูกสร้างขึ้นด้วยฟังก์ชันและพารามิเตอร์อื่นๆ (ฉันสร้างฟังก์ชันให้เป็นพารามิเตอร์เทมเพลต ซึ่งป้องกันการใช้พอยน์เตอร์ของฟังก์ชัน และช่วยให้เครื่องมือเพิ่มประสิทธิภาพสามารถอินไลน์ได้ ทำให้ค่าใช้จ่ายนี้เกือบเป็นศูนย์)

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

จากนั้นคุณก็แค่ทำให้โซ่นั้นเชื่อมโยงได้

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

การใช้งานนั้นง่าย:

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

หมายเหตุ: ไม่มีการจัดสรร ไม่มีตัวชี้ ห้ามคัดลอกหรือย้าย สิ่งนี้ควรสร้างโค้ดเดียวกันกับที่คุณเพิ่งทำ v2.translate(2.5); v2.rotate(30); v2.scale(10); โดยตรง

สำหรับตัวอย่างเวกเตอร์ที่คุณเพิ่มในความคิดเห็น คุณอาจมีไวยากรณ์เช่นนี้

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

วิธีการทำงานเป็นไปตามตรรกะต่อไปนี้:

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

และสิ่งที่คล้ายกันสำหรับตัวดำเนินการปรับขนาดและตัวดำเนินการแปล

โปรดสังเกตว่า | เป็นแบบเชื่อมโยงจากซ้ายไปขวา ดังนั้นจึงต้องป้อนอินพุตทางด้านซ้าย แต่คุณอาจนึกถึงการเพิ่มโอเวอร์โหลดให้กับแต่ละฟังก์ชันที่รับพารามิเตอร์การแปลงและเวกเตอร์อินพุต เพื่อให้คุณสามารถ:

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

ไวยากรณ์หลังอาจใช้งานง่ายกว่าการเริ่มไพพ์ด้วยตัวดำเนินการพื้นฐานและเอกลักษณ์เล็กน้อย

ตอนนี้ฉันมีคอมไพเลอร์ให้ฉันแล้วและอีกครั้งหลังจากทำงานในโครงการของฉันไปสักหน่อย นี่คือสิ่งที่ฉันคิดขึ้นมาได้...

มันไม่สมบูรณ์แบบเนื่องจาก function pointer สำหรับ operator() ต้องการพารามิเตอร์ 2 ตัวโดยเฉพาะดังที่เห็นในโค้ดตัวอย่างนี้...

(ฉันอาจต้องใช้เทมเพลต variadic สำหรับสิ่งนี้ เช่นเดียวกับลายเซ็นสำหรับตัวชี้ฟังก์ชันเพื่ออนุญาตให้มีตัวชี้ฟังก์ชัน วัตถุฟังก์ชัน functor หรือนิพจน์แลมบ์ดาพร้อมพารามิเตอร์จำนวนเท่าใดก็ได้ในประเภทที่แตกต่างกันไป เป็นที่ยอมรับ...)

นี่คือซอร์สโค้ดการทำงานของฉัน...

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

และนี่คือผลลัพธ์ที่ให้ฉัน:

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

ดูเหมือนว่าไปป์ operator|() จะใช้ได้กับคลาส pipe ของฉัน... และฉันต้องใช้ shared_ptr ของ pipe_object สำหรับอินสแตนซ์ปัจจุบันและอินสแตนซ์ถัดไป... pipe_object เป็นเพียง wrapper พื้นฐานสำหรับบางประเภท T คุณลักษณะพิเศษเพียงอย่างเดียวของคลาส pipe_object คือหนึ่งในตัวสร้างของมัน... ตัวสร้างที่ใช้วัตถุ pipe และแยกค่าของ pipe นั้นออกมาใช้เพื่อสร้าง pipe_object ใหม่ ฉันต้องใช้พอยน์เตอร์สองตัวเนื่องจากลักษณะของ opeator|() เป็นการเชื่อมโยงของมือขวา...

ดังที่คุณเห็นจากซอร์สโค้ดด้านบนภายใน double for loop... ฉันกำลังใช้อ็อบเจ็กต์ของ pipe operator() เพื่อส่งผ่านค่าและที่อยู่ไปยังฟังก์ชัน... ฉันยังสามารถ pipe อ็อบเจ็กต์เหล่านี้ได้โดยไม่ต้องเรียก operator() .. ขั้นตอนต่อไปคือการใช้แนวคิดนี้ แต่เพื่อให้เป็นเรื่องทั่วไปสำหรับวัตถุทุกประเภท... เว้นแต่ฉันจะใช้คลาสเหล่านี้เป็น wrapper เพื่อใช้เทคนิคการผูกมัดท่อ! ฉันหมายถึงการให้คลาสอื่นของฉันสืบทอดจากคลาส pipe นี้เหมือนกับที่ใครๆ จะทำโดยใช้ CRTP

แจ้งให้เราทราบสิ่งที่คุณคิด!