修改

Question

我有一个std :: vector，它存储一个复杂的struct 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是否为此提供了一些不错的功能？

我没有被迫使用矢量顺便说一句，任何标准容器（甚至可以提升）都有效。我希望我能为矢量提供像 view 这样的东西，我们要么只看到N1 N2或N3。

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

Answer 1

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;
    }
}

从存储在std :: container

1 个答案:

修改