Question

我有一些文件格式解码器，它返回自定义input iterator。此迭代器的值类型（当使用*iter取消引用时）可以是许多令牌类型之一。

这是一个简化的用法示例：

File file {"/path/to/file"};

for (const auto& token : file) {
    // do something with token
}

这个token如何有多种可能的类型？根据令牌的类型，其有效负载的类型也会发生变化。

在遍历期间，性能非常重要。例如，我不想要任何不必要的分配。这就是迭代器类型是输入迭代器的原因：只要你推进迭代器，前一个令牌就会根据InputIterator标记的要求而失效。

到目前为止，我有两个想法：

使用单个Token类，其中包含所有可能的有效负载（使用其公共getter）和公共类型ID（union）getter的私有enum。用户需要打开此类型ID以了解要调用的有效负载getter：
```
for (const auto& token : file) {
    switch (token.type()) {
    case Token::Type::APPLE:
        const auto& apple = token.apple();
        // ...
        break;

    case Token::Type::BANANA:
        const auto& banana = token.banana();
        // ...
        break;

    // ...
    }
}
```
虽然这可能是我在C中选择的，但我不是C ++中这个解决方案的粉丝，因为用户仍然可以调用错误的getter而没有任何东西可以执行此操作（除了我想要的运行时检查）避免出现性能问题。）
创建一个抽象的Token基类，它具有一个accept()方法来接受访问者，以及一个继承该基类的多个具体类（每个有效负载类型一个）。在迭代器对象中，在创建时实例化每个具体类中的一个。还有一个Token *token成员。迭代时，填充适当的预分配有效负载对象，并设置this->token = this->specificToken。让operator*()返回this->token（引用）。要求用户在迭代期间使用访问者（或者更糟糕的是，使用dynamic_cast）：
```
class MyVisitor : public TokenVisitor {
public:
    void visit(const AppleToken& token) override {
        // ...
    }

    void visit(const BananaToken& token) override {
        // ...
    }
};

TokenVisitor visitor;

for (const auto& token : file) {
    token.accept(visitor);
}
```
这为每个令牌引入了额外的函数调用，其中至少有一个是虚拟的，但这可能不是世界末日;我对此解决方案持开放态度。

还有其他有趣的解决方案吗？我认为返回boost::variant或std::variant与想法＃2相同。

Answer 1

虽然这可能是我在C中选择的，但我不是C ++中这个解决方案的粉丝，因为用户仍然可以调用错误的getter而没有任何东西可以执行此操作（除了我想要避免的运行时检查）对于性能问题）。

您可以反转该方法并接受可调用对象，而不是将迭代器返回给用户。然后，您可以在内部迭代容器并分派正确的类型。这样，用户不会因为忽略标记工会所带来的信息而犯错误，因为你负责考虑这一点。

这是一个最小的工作示例来展示我的意思：

#include <vector>
#include <utility>
#include <iostream>

struct A {};
struct B {};

class C {
    struct S {
        enum { A_TAG, B_TAG } tag;
        union { A a; B b; };
    };

public:
    void add(A a) {
        S s;
        s.a = a;
        s.tag = S::A_TAG;
        vec.push_back(s);
    }

    void add(B b) {
        S s;
        s.b = b;
        s.tag = S::B_TAG;
        vec.push_back(s);
    }

    template<typename F>
    void iterate(F &&f) {
        for(auto &&s: vec) {
            if(s.tag == S::A_TAG) {
                std::forward<F>(f)(s.a);
            } else {
                std::forward<F>(f)(s.b);
            }
        }
    }

private:
    std::vector<S> vec;
};

void f(const A &) {
    std::cout << "A" << std::endl;
}

void f(const B &) {
    std::cout << "B" << std::endl;
}

int main() {
    C c;
    c.add(A{});
    c.add(B{});
    c.add(A{});
    c.iterate([](auto item) { f(item); });

}

在Coliru上查看并运行。

如何从具有高性能的输入迭代器返回变量？

1 个答案: