困扰已久的c++问题，请问如何写一个函数把flag不为-1的连续三个数组元素取出来，用作比较

struct tagStoak
    {
        float high;
        float low;
        float close;
        float open;
        int flag;
        int dir;
        int no;
    };

tagStoak stakData[]
    {
        {3.5,2.6,3.4,2.8,-1,1,1},
        {3.8,2.7,3.3,2.9,0,1,2},
        {3.5,2.6,3.4,2.8,-1,1,3},
        {3.5,2.6,3.4,2.8,-1,1,4},
        {3.5,2.6,3.4,2.8,-1,1,5},
        {5.5,3.6,4.4,3.8,1,1,6},
        {3.5,2.6,3.4,2.8,-1,1,7},
        {3.5,2.6,3.4,2.8,-1,1,8},
        {3.5,2.6,3.4,2.8,-1,1,9},
        {4.5,3.4,3.4,3.7,1,1,10},
        {3.5,2.6,3.4,2.8,-1,1,11},
        {3.5,2.6,3.4,2.8,-1,1,12},
        {3.5,2.6,3.4,2.8,-1,1,13},
        {6.5,4.9,3.4,5.2,1,1,14},
    };

代码：

#include <stdlib.h>
#include <vector>
#include <iostream>

struct tagStoak
{
    float high;
    float low;
    float close;
    float open;
    int flag;
    int dir;
    int no;
};

struct tagStoak stakData[] =
    {
        {3.5, 2.6, 3.4, 2.8, -1, 1, 1},
        {3.8, 2.7, 3.3, 2.9, 0, 1, 2},
        {3.5, 2.6, 3.4, 2.8, -1, 1, 3},
        {3.5, 2.6, 3.4, 2.8, -1, 1, 4},
        {3.5, 2.6, 3.4, 2.8, -1, 1, 5},
        {5.5, 3.6, 4.4, 3.8, 1, 1, 6},
        {3.5, 2.6, 3.4, 2.8, -1, 1, 7},
        {3.5, 2.6, 3.4, 2.8, -1, 1, 8},
        {3.5, 2.6, 3.4, 2.8, -1, 1, 9},
        {4.5, 3.4, 3.4, 3.7, 1, 1, 10},
        {3.5, 2.6, 3.4, 2.8, -1, 1, 11},
        {3.5, 2.6, 3.4, 2.8, -1, 1, 12},
        {3.5, 2.6, 3.4, 2.8, -1, 1, 13},
        {6.5, 4.9, 3.4, 5.2, 1, 1, 14},
};

void fun(std::vector<struct tagStoak> &data)
{
    struct tagStoak *p = stakData;
    while (p != NULL)
    {
        if (p->flag != -1 && data.size() < 3)
        {
            data.push_back(*p);
        }
        if (data.size() == 3)
        {
            break;
        }
        ++p;
    }
}
int main()
{
    std::vector<struct tagStoak> data;
   // 获取flag不为-1的连续三个数组元素
    fun(data);
    
    for (int i = 0; i < data.size(); i++)
    {
        std::cout << data[i].high << "," << data[i].low << "," << data[i].close << "," << data[i].open
                  << "," << data[i].flag << "," << data[i].dir << "," << data[i].no << std::endl;
    }
}

运行结果：

用作比较是什么意思呢？

struct tagStoak
    {
        float high;
        float low;
        float close;
        float open;
        int flag;
        int dir;
        int no;
    };
 
tagStoak stakData[]=
    {
        {3.5,2.6,3.4,2.8,-1,1,1},
        {3.8,2.7,3.3,2.9,0,1,2},
        {3.5,2.6,3.4,2.8,-1,1,3},
        {3.5,2.6,3.4,2.8,-1,1,4},
        {3.5,2.6,3.4,2.8,-1,1,5},
        {5.5,3.6,4.4,3.8,1,1,6},
        {3.5,2.6,3.4,2.8,-1,1,7},
        {3.5,2.6,3.4,2.8,-1,1,8},
        {3.5,2.6,3.4,2.8,-1,1,9},
        {4.5,3.4,3.4,3.7,1,1,10},
        {3.5,2.6,3.4,2.8,-1,1,11},
        {3.5,2.6,3.4,2.8,-1,1,12},
        {3.5,2.6,3.4,2.8,-1,1,13},
        {6.5,4.9,3.4,5.2,1,1,14},
};

int fun(tagStoak data[],int n)
{
  if(n<=2)
    return -1;
  for(int i=0;i<n-2;i++)
  {
    if(data[i].flag != -1 && data[i+1].flag != -1 && data[i+2].flag != -1)
      return i;
  }
  return -1;
}

void main()
{
   int n = sizeof(stakData)/sizeof(tagStoak);
  int idx = fun(stakData,n);
}

这个要嵌套在一个for循环里面，取出三个flag连续不为-1的有效元素在for循环里比较high 和 low的数值大小，作下一步的筛选,以上的数组数据只是我随便写的，真实数据中间可能会隔10几个flag 为-1的元素

可以先寻找第一个不为-1的元素（位置为i），然后再判断i+1与i+2位置是否也不为-1，如果都满足就取出比较即可

遍历数组，用一个额外的下标记录flag为-1的tagStoak，只要下一轮循环tagStoak的flag不为-1，就把这个下标重置为0，反之，当下标增长到3的时候，说明找到了三个连续-1flag的tagStoak。

    tagStoak need[3];
    int count= 0;
    for(int i =0;i<sizeof(stakData)/sizeof(stakData[0]);i++) {
        tagStoak t = stakData[i];
        if (t.flag == -1) {
            need[count++] = t;
        } else {
            count= 0;
        }
        if (count== 3) {
            break;
        }
    }

```c++
struct tagStoak
    {
        float high;
        float low;
        float close;
        float open;
        int flag;
        int dir;
        int no;
    };
 
tagStoak stakData[]
    {
        {3.5,2.6,3.4,2.8,-1,1,1},
        {3.8,2.7,3.3,2.9,0,1,2},
        {3.5,2.6,3.4,2.8,-1,1,3},
        {3.5,2.6,3.4,2.8,-1,1,4},
        {3.5,2.6,3.4,2.8,-1,1,5},
        {5.5,3.6,4.4,3.8,1,1,6},
        {3.5,2.6,3.4,2.8,-1,1,7},
        {3.5,2.6,3.4,2.8,-1,1,8},
        {3.5,2.6,3.4,2.8,-1,1,9},
        {4.5,3.4,3.4,3.7,1,1,10},
        {3.5,2.6,3.4,2.8,-1,1,11},
        {3.5,2.6,3.4,2.8,-1,1,12},
        {3.5,2.6,3.4,2.8,-1,1,13},
        {6.5,4.9,3.4,5.2,1,1,14},
}
void main()
{
    //提取出来存放在test中
    tagStoak test[3];
    inti,j=0;
    for(i=0;i<sizeof(stakData)/sizeof(tagStoak);i++)
    {
        if(stakData[i].flag!=-1)
        {
            test[j]=stakData[i];
            j++;
        }
    }
    //比较，不知道比较什么意思，找不同点？
    ****************
}

```

如果你是在做什么算法题，这个可能满足不了你的要求，如果数据不是特别大就大概还行，传入一个结构体数组还有数组的长度，然后返回一个数组。它只会返回顺序的第一个三个连续不为-1的元素。

供参考：

#include<stdio.h>

struct tagStoak
{
    float high;
    float low;
    float close;
    float open;
    int   flag;
    int   dir;
    int   no;
};
tagStoak stakData[]
{
    {3.5,2.6,3.4,2.8,-1,1,1},
    {3.8,2.7,3.3,2.9,0,1,2},
    {3.5,2.6,3.4,2.8,-1,1,3},
    {3.5,2.6,3.4,2.8,-1,1,4},
    {3.5,2.6,3.4,2.8,-1,1,5},
    {5.5,3.6,4.4,3.8,1,1,6},
    {3.5,2.6,3.4,2.8,-1,1,7},
    {3.5,2.6,3.4,2.8,-1,1,8},
    {3.5,2.6,3.4,2.8,-1,1,9},
    {4.5,3.4,3.4,3.7,1,1,10},
    {3.5,2.6,3.4,2.8,-1,1,11},
    {3.5,2.6,3.4,2.8,-1,1,12},
    {3.5,2.6,3.4,2.8,-1,1,13},
    {6.5,4.9,3.4,5.2,1,1,14},
};

int main()
{
    int i;
    int len = sizeof(stakData)/sizeof(stakData[0]);
    for (i = 0; i < len; i++) {
        if (stakData[i].flag != -1)
            printf("%f %f %f %f %d %d %d\n", stakData[i].high, stakData[i].low,stakData[i].close, 
                            stakData[i].open, stakData[i].flag, stakData[i].dir, stakData[i].no);
    }
}