从存储在 std::container 中的结构中提取元素

Extracting elements from a struct stored in an std::container

本文关键字：提取 元素 结构 container 存储 std      更新时间：2023-10-16

我有一个std：：vector，它存储了一个复杂的结构S（来自实时源），它由嵌套的结构N1，N2，N3组成。结构 S 有一个时间字段。

一个

常见的任务是在两次之间检索 3 个嵌套结构中的任何一个，例如 getSequenceN1（startTime， stopTime， itrStart， itrStop），它为子序列的开始和结束提供 2 个迭代器。

所以代码看起来像这样：

struct {
   double time
   struct N1;
   struct N2;
   struct N3;
} S;
class D {

public: 
   void getSequenceN1(startTime, stopTime, itrStart, itrStop);
   void getSequenceN2(startTime, stopTime, itrStart, itrStop);
   void getSequenceN3(startTime, stopTime, itrStart, itrStop);
private: 
  std::vector<S> stream;
};

实现getSequenceN1功能的正确方法是什么？

一种方法当然是为每个 N1、N2、N3 提供一个向量（在现实生活中有超过 3 个减法），但我想知道 std 是否为此提供了一些不错的功能？

顺便说一句，我没有被迫使用矢量，任何 std 容器（甚至可能是增强）都可以工作。我希望我能为我们只能看到 N1 N2 或 N3 的向量提供类似视图的东西。

一种方法是提供定制的迭代器，分别返回 N1 N2 和 N3。

void getSequenceN1(double startTime, 
                   double stopTime, 
                   vector<struct N1>& sequence)
{
    
    for( S cur: stream)
    {
        if (s.time >= startTime && s.time < endTime)
        {
             sequence.push-back(s.N1's_name);
        }
    }
}

优化和调整开始和结束条件以适应。例如，如果在检查序列时不打算修改 S，则可以使用指针向量来构造 N1 并保存一些复制。

编辑

玩弄这个概念。仍然需要抽象它，因为为每个子结构声明不同的迭代器是一个非常愚蠢的解决方案。非常感谢建议。

#include<iostream>
#include<vector>
struct N1
{
    int count;
    bool operator==(const N1 & rhs) const
    {
        return count == rhs.count;
    }
    bool operator!=(const N1 & rhs) const
    {
        return count != rhs.count;
    }
};
struct S
{
    double time;
    struct N1 n1;
    bool operator<(const S & rhs) const
    {
        return time < rhs.time;
    }
};
class N1Iterator: public std::iterator<std::input_iterator_tag, struct N1>
{
    std::vector<S>::iterator mIt;
public:
    N1Iterator()
    {
    }
    N1Iterator(std::vector<S>::iterator it) :
            mIt(it)
    {
    }
    N1Iterator(const N1Iterator& it) :
            mIt(it.mIt)
    {
    }
    N1Iterator& operator++()
    {
        ++mIt;
        return *this;
    }
    N1Iterator operator++(int)
    {
        N1Iterator tmp(*this);
        operator++();
        return tmp;
    }
    bool operator==(const N1Iterator& rhs)
    {
        return mIt->n1 == rhs.mIt->n1;
    }
    bool operator!=(const N1Iterator& rhs)
    {
        return mIt->n1 != rhs.mIt->n1;
    }
    N1& operator*()
    {
        return mIt->n1;
    }
    N1* operator->()
    {
        return &mIt->n1;
    }
};
std::vector<S> stream;
N1Iterator & getSequenceN1(double startTime,
                         double stopTime,
                         N1Iterator & begin,
                         N1Iterator & end)
{
    S key;
    key.time = startTime;
    begin=N1Iterator(std::lower_bound(stream.begin(), stream.end(), key));
    key.time = stopTime;
    end=N1Iterator(std::lower_bound(stream.begin(), stream.end(), key));
    return begin;
}
int main(int argc, char **argsv)
{
    for (int count = 0; count < 10; count++)
    {
        S s1;
        s1.time = count;
        s1.n1.count = count;
        stream.push_back(s1);
    }
    N1Iterator begin;
    N1Iterator end;
    getSequenceN1(3, 7, begin, end);
    while (begin != end)
    {
        std::cout << begin->count << std::endl;
        ++begin;
    }
}
相关文章：