c++ - 是否可以逐列遍历 vector 的 vector ？

Question

我有一个字符串 vector 的 vector 。我想找到每列中最长字符串的长度。所有的子 vector 都具有相同的长度并存储了一个元素，因此使用两个 for 循环和反向索引很容易找到它。

vector<vector<string>> myvec = {
                                { "a", "aaa",   "aa"},
                                {"bb",   "b", "bbbb"},
                                {"cc",  "cc",  "ccc"}
                               };

但是是否可以在不使用索引的情况下使用迭代器来做到这一点？

Answer 1

假设内部 vector 都是相同的长度，你可以有类似的东西

template <typename T>
class columnwise {
    std::vector<std::vector<T>> * underlying;
    struct proxy {
        std::vector<std::vector<T>> * underlying;
        std::vector<T>::difference_type offset;
        struct iterator {
            std::vector<std::vector<T>>::iterator outer;
            std::vector<T>::difference_type offset;
            using reference = typename std::vector<T>::reference;
            using pointer = typename std::vector<T>::pointer;
            iterator operator++() { ++outer; return *this; }
            reference operator*() { return *(outer->begin() + offset); }
            pointer operator->() { return (outer->begin() + offset).operator->(); }
            bool operator==(iterator rhs) { return (outer == rhs.outer) && (offset == rhs.offset); }
        };
    public:
        iterator begin() { return { underlying->begin(), offset }; }
        iterator end() { return { underlying->end(), offset }; }
    };
    struct iterator {
        // member type aliases
        std::vector<std::vector<T>> * underlying;
        std::vector<T>::difference_type offset;
        iterator operator++() { ++offset; return *this; }
        proxy operator*() { return { underlying, offset }; }
        bool operator==(iterator rhs) { return (underlying== rhs.underlying) && (offset == rhs.offset); }
    };
    std::vector<T>::difference_type inner_size() { if (auto it = underlying->begin(); it != underlying->end()) { return it->size(); } return 0; }
public:
    columnwise(std::vector<std::vector<T>> & vec) : underlying(&vec) {}
    iterator begin() { return { underlying, 0 }; }
    iterator end() { return { underlying, inner_size() }; }
};

迭代 as you expect .