Как связать и сериализовать функции, перегружая | оператор

Сначала я предполагаю, что у вас есть некоторые основы, которые выглядят так

#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 параметра, как видно из этого примера кода...

(Мне, вероятно, придется использовать вариативный шаблон для этого, а также для подписи для указателя функции, чтобы разрешить указатель функции, объект функции, функтор или лямбда-выражение с любым количеством параметров различных типов для быть приемлемым...)

Вот мой рабочий исходный код...

#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 — это просто базовая оболочка для некоторого типа T. Единственной особенностью класса pipe_object является один из его конструкторов... Это конструктор, который берет объект pipe и извлекает значение этого pipe, используя его для создания нового pipe_object. Мне пришлось использовать двойные указатели из-за того, что opeator|() является правосторонним ассоциативным...

Как видно из приведенного выше исходного кода в двойном цикле for... Я использую объекты pipe operator() для передачи значений и адреса функции... Я также могу pipe эти объекты не вызывать их operator(). .. Следующим шагом здесь будет применение этой концепции, но сделать ее общей для любого типа объектов... если только я не смогу просто использовать эти классы в качестве оболочки для использования метода цепочки конвейеров! Я имею в виду, что мой другой класс наследуется от этого класса pipe, как это делается с использованием CRTP.

Дайте мне знать, что вы думаете!