c++ - 我可以在 C++ 中动态组合函数和类型吗？

Question

我正在尝试实现一种过滤图。这个过滤器图形是基于我已经实现的数学算法，简单地说，定义了一组接受一些输入并产生某种类型输出的仿函数。我在 C++ 中将这些仿函数中的每一个实现为不同的类，并使用共同的基类型来允许将仿函数组合在一起。

下面是一个非常简单的实现:

#include <iostream>
#include <cassert>
#include <cctype>

// Simple filter that takes a string and returns some new type
template <typename A>
struct Filter {
    virtual A filter(const std::string& input) = 0;
};

// Takes a single char, returns that same char
struct SingleChar : public Filter<char> {
    char filter(const std::string& input) {
        assert(input.size() == 1);
        return input[0];
    }
};

// Takes a string, returns a pair of data types
template <typename A, typename B>
struct Sequence : public Filter<std::pair<A, B>> {
    Filter<A>* left;
    Filter<B>* right;

    std::pair<A, B> filter(const std::string& input) {
        assert(input.size() > 1);
        return std::make_pair(left->filter(input.substr(0, 1)), right->filter(input.substr(1)));
    }
};

template <typename B, typename A>
struct Transform : public Filter<A> {
    Filter<B>* innerFilter;
    std::function<A(B)> transform;

    A filter(const std::string& input) {
        return transform(innerFilter->filter(input));
    }
};

// Simple helper function to join two strings with a space
std::string joinStringPair(std::pair<std::string, std::string> pair) {
    return pair.first + ' ' + pair.second;
}

int main() {
    // Takes a single char, returns that same char (i.e. "A" -> "A")
    SingleChar singleLetter;

    // Takes a single char, returns that same char + it's lower-case version (i.e. "A" -> "Aa")
    Transform<char, std::string> letterAndLower;
    letterAndLower.innerFilter = &singleLetter;
    letterAndLower.transform = [](char c){ return std::string(1, c) + std::string(1, std::tolower(c)); };

    // Takes two chars, returns each one + its lower-case version (i.e. "AB" -> "Aa", "Bb")
    Sequence<std::string, std::string> twoLetterPair;
    twoLetterPair.left = &letterAndLower;
    twoLetterPair.right = &letterAndLower;

    // Takes two chars, returns them and their lower-case versions joined with a space (i.e. "AB" -> "Aa Bb")
    Transform<std::pair<std::string, std::string>, std::string> twoLetterString;
    twoLetterString.innerFilter = &twoLetterPair;
    twoLetterString.transform = joinStringPair;

    // Takes three chars, returns each one + its lower-case version and space-joins the last two (i.e. "ABC" -> "Aa", "Bb Cc")
    Sequence<std::string, std::string> threeLetterPair;
    threeLetterPair.left = &letterAndLower;
    threeLetterPair.right = &twoLetterString;

    // Takes three chars, returns them and their lower-case versions joined with a space (i.e. "ABC" -> "Aa Bb Cc")
    Transform<std::pair<std::string, std::string>, std::string> threeLetterString;
    threeLetterString.innerFilter = &threeLetterPair;
    threeLetterString.transform = joinStringPair;

    // Outputs "Aa Bb Cc"
    std::cout << threeLetterString.filter("ABC") << std::endl;

    // Outputs "Xx Yy Zz"
    std::cout << threeLetterString.filter("XYZ") << std::endl;
}

上面的简单例子都是硬编码的。真正的实现是动态构建这个过滤图。考虑以下在运行时基于动态提供的参数构建过滤器图的简单示例。是的，这很简单，但它说明了多态性抽象出确切数据类型的观点(例如，返回的 Transform 的 innerFiler 可能是 SingleChar 或 Sequence )。希望这个例子能让人更容易想象一个更复杂的过程，该过程构建一个图，其节点类型随着用户提供的不同输入而不同(并且涉及的类型不仅仅是 char 和 string)。

Filter<std::string>* makeStringFilter(int stringLength) {
    // (ignore the memory leaks with not explicitly deleting allocated memory;
    // I'm ignoring memory leaks in this naive example for simplicity's sake)
    if (stringLength == 1) {
        // Take a single char, transform it to a string
        Transform<char, std::string>* transform = new Transform<char, std::string>;
        transform->innerFilter = new SingleChar;
        transform->transform = [](char c){ return std::string(1, c); };
        return transform;
    }

    // Take a char and string pair (like a car, cdr pair in Lisp)
    Sequence<char, std::string>* sequence = new Sequence<char, std::string>;
    sequence->left = new SingleChar;
    sequence->right = makeStringFilter(stringLength - 1);

    // Turn the pair into a proper string
    Transform<std::pair<char, std::string>, std::string>* transform = new Transform<std::pair<char, std::string>, std::string>;
    transform->innerFilter = sequence;
    transform->transform = [](std::pair<char, std::string> pair){ return pair.first + pair.second; };

    return transform;
}

// Using the above function; outputs "Hello world!" (fails on strings with length != 12)
Filter<std::string>* sixLetterString = makeStringFilter(12);
std::cout << sixLetterString->filter("Hello world!") << std::endl;

作为我程序的一部分，我经常构建、遍历和操作这些图。在实践中，很多嵌套 Transform节点在这个过程中建立(尤其是在重复操作图形时)，因此图形最终看起来像:

... -> Transform -> Transform -> Transform -> ... -> Transform -> SingleChar

所有这些嵌套 Transform s 会导致图形变得非常大，从而增加遍历和操作时间。理想情况下，我想压缩所有这些嵌套的 Transform s 一起成为一个单一的变换节点(因此图形只是 ... -> Transform -> SingleChar )。这可以通过制作一个新的 Transform 来完成。刚组成所有 Transform 的节点s' Transform::transform函数并直接指向最后一个SingleChar .

但是，我遇到了 C++ 的静态类型和压缩这些问题 Transform秒。在动态类型语言中，压缩很容易，因为我可以编写 Transform s 和类型都在运行时计算出来。但是让类型在 C++ 中工作是一件令人头疼的事情。

原因是因为innerFilter的 Transform只是一个多态指针。如果我有一个 Transform<B, A>用innerFilter指向 Transform<C, B> , 那innerFilter只是有一个多态类型 Filter<B> .为了压缩这两个Transform s，我需要创建一个类型为 Transform<C, A> 的新转换.但是，问题是类型 C已被多态性“删除”；我只有类型 A和 B .

是否可以压缩这些转换？我研究过类型删除，但它似乎不是解决方案。多态模板函数(可以理解)在 C++ 中是不合法的。静态多态性(la CRTP)在这里没有用，因为我在运行时根据用户输入构建、遍历和操作这些过滤器图。

我愿意完全修改实现以使其正常工作。确切的实现是不固定的；但是，它需要具有与此实现相同的整体功能和类型安全性。我在理论上需要一个新的实现(如果这完全可能的话)，因为你不能在运行时在 C++ 中动态创建新类型，这似乎是在这个实现中压缩嵌套转换所需要的。

Answer 1

我认为这行得通。首先，创建一个可以组合任何 2 Transform 的类:

// First transform takes and A and returns a B, second takes a B and returns a C
template<A, B, C>
struct TwoTransform {
   std::function<B(A)> t1;
   std::function<C(B)> t2;
   TwoTransform(std::function<B(A)> t1, std::function<C(B)> t2) {
      this.t1 = t1;
      this.t2 = t2;
    }

    C filter(A input) {
        return t2(t1(input));
    }
}

然后，您可以为 TwoTransform 构建一个方法，该方法采用另一个 Transform 并返回另一个 TwoTransform:

template<A, B, C>
struct TwoTransform {
  // Same code as above
  TwoTransform<A, C, D> addAnother(std::function<D(C)> nextOne) {
      return new TwoTransform(this, nextOne);
   }
}

所以你可以这样使用:

Transform<A, B> t1;
Transofrm<B, C> t2;
Transform<C, D> t3;
Transform<D, E> t4;

Transform<A, E> final = new TwoTransform(t1, t2).addAnother(t3).addAnother(t4);

请注意:我最近一直在写 Java，但没有尝试过；我怀疑我在一些地方使用了 Java 语法而不是 C++，但希望你能理解一般的想法。