像位运算一样构造tuple

前言

使用位运算写flag是一种很直观优雅的做法

比如flag = flagA | flagB | flagC

这里flag是一个简单的bitmap,一般用unsigned int的简单类型表示

但这个问题在于:

  1. 类型限定,你只能是操作一些位,一般是整数类型或者布尔类型
  2. 范围限定,范围取决于flag的最大值,毕竟就是一个值
  3. 单一类型,能否把位运算用于不同类型,也就是说,允许任意多类型绑定

那这些问题能不能全部解决掉,实现一个动态类型的bitwise or?

期望

已知C++标准库已经提供了std::tuple,期望实现代码如下

// 假设 typename ...Ts == int, double, std::string, std::vector<int>
std::tuple<int, double, std::string, std::vector<int>> test() {
    int a = 123;
    double b = 4.5;
    std::string c = "678";
    std::vector<int> d { 9, 10 };
    return a | b | std::move(c) | std::move(d); // 期望的做法
}

做法

很显然这种写法是不对的

但是可以曲线救国

大概方法:

  • 实现一个类型,重载operator|,并允许链式调用
  • 实现隐式转型到std::tuple<Ts...>
  • 由于这种特殊条件下的tuple大小是不可推导的,因此可以用std::vector等可变长的类型来支持存储
  • 由于std::shared_ptr<void>自带析构器,因此可以当作低配版std::any来使用

我的话说完了,你应该能get到我要干嘛

class use_or {
public:
    template <typename T>
    use_or& operator|(T t) {
        _cont.emplace_back(std::make_shared<T>(std::move(t)));
        return *this;
    }

    template <typename ...Ts>
    operator std::tuple<Ts...>() {
        using seq = std::make_index_sequence<sizeof...(Ts)>;
        return make<std::tuple<Ts...>>(seq{});
    }

private:
    template <typename Tuple, size_t ...Is>
    Tuple make(std::index_sequence<Is...>) {
        Tuple tup;
        std::initializer_list<int> { ((get<Is>(tup)), 0)... };
        return tup;
    }

    template <size_t I, typename Tuple>
    void get(Tuple &tup) {
        if(I >= _cont.size()) return;
        using T = typename std::remove_reference<decltype(std::get<I>(tup))>::type;
        auto ptr = reinterpret_cast<T*>(_cont[I].get());
        std::get<I>(tup) = std::move(*ptr);
    }

private:
    std::vector<std::shared_ptr<void>> _cont;
};

测试

std::tuple<int, double, std::string, std::vector<int>> test() {
    int a = 123;
    double b = 4.5;
    std::string c = "678";
    std::vector<int> d { 9, 10 };
    return use_or{} | a | b | std::move(c) | std::move(d); // ok!
}

int main() {
    auto tup = test();
    std::cout << std::get<2>(tup) << ' '
              << std::get<3>(tup)[0] << std::endl;
    return 0;
}

然而

标准库其实已经提供了std::make_tuple,不也很香吗?

  • 标准的做法当然是好,不仅性能好,而且类型安全,但,我喜欢|
  • std::make_tuple不允许省略参数,比如在上述例子中少了d,则直接不允许编译(毕竟类型推导直接放到接口上了)

更多?

要是愿意花更多时间还可以实现像&&= ~(...)这种常用操作

不过也没啥意思,就是多提供一个comparator和换更复杂的容器的事情,不写了

后记

把静态语言写成动态语言,除了爽我也没觉得有啥意义啊

看来这篇文章只能当作爽文了

发表评论

邮箱地址不会被公开。 必填项已用*标注