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

我正在尝试实现一种过滤图。这个绘制的过滤器基于我实现的数学算法，该算法简单地定义了一组接受一些输入并产生某种类型的输出的函子。我已经在 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都会导致图形变得非常大，从而增加遍历和操作时间。理想情况下，我想将所有这些嵌套的Transform压缩到一个转换节点中(因此图形只是... -> Transform -> SingleChar(。这可以通过创建一个新的Transform节点来完成，该节点仅组合所有Transform的Transform::transform函数并直接指向最后一个SingleChar。

但是，我在C++的静态类型和压缩这些Transform时遇到了问题。在动态类型语言中，压缩很容易，因为我只需编写Transform，并且类型都在运行时完成。但是让打字在C++中工作是一个令人头疼的问题。

原因是因为Transform的innerFilter只是一个多态指针。如果我有一个Transform<B, A>，其innerFilter指向Transform<C, B>，那么innerFilter只是具有多态型Filter<B>。为了压缩这两个Transform，我需要创建一个类型为 Transform<C, A> 的新转换。但问题是，类型 C 已被多态性"擦除";我只有A和B的类型。

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

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