C++ C++；异构类型迭代器迭代器

我有一个包含不同类型向量的结构。我想创建一个迭代器，它将迭代每个向量的每个元素，并根据特定规则，使用

*

操作符提供特定值。我已经为迭代器的迭代器创建了一个玩具示例：

/*--------------------------------------------------------------------*/
/*  Copyright (C) Inria 2014

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/*
 *  Project:    MixtComp
 *  Created on: Feb 20, 2014
 *  Author:     Vincent KUBICKI <vincent.kubicki@inria.fr>
 **/

#include <iostream>
#include <iterator>
#include <vector>

class MyIterator : public std::iterator<std::input_iterator_tag, int>
{
  typedef std::vector<int>::const_iterator it   ;
  typedef std::vector<it>                  vecit;
  typedef std::vector<it>::iterator        itit ;
public:
  MyIterator(it itA ,
             it itB ,
             it endA,
             it endB)
  {
    vec_it_.push_back(itA);
    vec_it_.push_back(itB);
    vec_end_.push_back(endA);
    vec_end_.push_back(endB);

    it_vec_it_ = vec_it_.begin();
    it_vec_end_ = vec_end_.begin();
    if (itA == endA)
    {
      ++it_vec_it_;
      ++it_vec_end_;
    }
  }

  MyIterator(const MyIterator& mit) :
    vec_it_(mit.vec_it_),
    vec_end_(mit.vec_end_),
    it_vec_it_(mit.it_vec_it_),
    it_vec_end_(mit.it_vec_end_)
  {}

  MyIterator& operator++()
  {
    if (*it_vec_it_ != *it_vec_end_)
    {
      ++(*it_vec_it_);
      if (*it_vec_it_ == *it_vec_end_)
      {
        ++it_vec_it_;
        ++it_vec_end_;
      }
    }
    return *this;
  }

  MyIterator operator++(int)
  {
    MyIterator tmp(*this);
    operator++();
    return tmp;
  }

  bool operator==(const MyIterator& rhs)
  {
    return (*it_vec_it_ == *(rhs.it_vec_it_));
  }

  bool operator!=(const MyIterator& rhs)
  {
    return (*it_vec_it_ != *(rhs.it_vec_it_));
  }

  const int operator*()
  {
    return *(*it_vec_it_);
  }

private:
  vecit vec_it_; // vector of current iterators
  vecit vec_end_; // vector of end iterators

  itit it_vec_it_; // iterator on vec_it_
  itit it_vec_end_; // iterator on vec_end_
};

int main () {
  std::vector<int> dataA {1, 3, 4, 9};
  std::vector<int> dataB {11, 34, 43};

  MyIterator from(dataA.begin(),
                  dataB.begin(),
                  dataA.end(),
                  dataB.end());
  MyIterator until(dataA.end(),
                   dataB.end(),
                   dataA.end(),
                   dataB.end());

  for (MyIterator it = from; it != until; ++it)
  {
    std::cout << *it << std::endl;
  }
  return 0;
}

/*--------------------------------------------------------------------*/
/*版权所有（C）Inria 2014
此程序是免费软件：您可以重新发布和/或修改它
它是根据GNU通用公共许可证的条款发布的
自由软件基金会，或者许可证的第3版，或者
（由您选择）任何更高版本。
这个节目的发布是希望它会有用，
但无任何保证；甚至没有任何关于
适销性或适合某一特定目的。见
有关更多详细信息，请参阅GNU通用公共许可证。
您应该已经收到GNU通用公共许可证的副本
和这个节目一起。如果没有，请参阅。
*/
/*
*项目：MixtComp
*创建日期：2014年2月20日
*作者：Vincent KUBICKI
**/
#包括
#包括
#包括
类MyIterator:public std:：iterator
{
typedef std:：vector:：const_迭代器it；
typedef std：：向量向量；
typedef std:：vector:：迭代器itit；
公众：
我的迭代器（it），
它是itB，
它结束了，
(完)
{
车辆后推（itA）；
车辆后推（itB）；
vec_end_.向后推（endA）；
vec_end_.向后推（endB）；
it_vec_it_=vec_it_.begin（）；
it_vec_end_=vec_end_.begin（）；
if（itA==endA）
{
++it_vec_it_；
++它的目的是什么；
}
}
MyIterator（常量MyIterator&mit）：
vec_it_（mit.vec_it_），
vec_end_（mit.vec_end_），
it_vec_it_（麻省理工学院，it_vec_it），
it_vec_end_（麻省理工学院，it_vec_end_）
{}
MyIterator&运算符++（）
{
如果（*it_vec_it！=*it_vec_end_）
{
++（*it_vec_it_）；
if（*it_vec_it_==*it_vec_end_）
{
++it_vec_it_；
++它的目的是什么；
}
}
归还*这个；
}
MyIterator运算符++（int）
{
MyIterator tmp（*this）；
运算符++（）；
返回tmp；
}
布尔运算符==（常量MyIterator和rhs）
{
return（*it_vec_it_==*（rhs.it_vec_it_））；
}
布尔运算符！=（常量MyIterator和rhs）
{
return（*it_vec_it！=*（rhs.it_vec_it））；
}
常量整型运算符*（）
{
返回*（*it_vec_it_）；
}
私人：
vecit-vec\u-it；//当前迭代器的向量
vecit vec\u end；//结束迭代器的向量
itit it_vec_it；//向量上的迭代器_
itit_vec_end；//向量上的迭代器_
};
int main（）{
std：：向量数据a{1,3,4,9}；
std：：载体数据库{11,34,43}；
来自（dataA.begin（））的MyIterator，
dataB.begin（），
dataA.end（），
dataB.end（））；
MyIterator直到（dataA.end（），
dataB.end（），
dataA.end（），
dataB.end（））；
for（MyIterator it=from；it！=until；++it）
{
std:：cout我们要做的是用一个
开关/case
结构替换
itit
。一个整数将跟踪“当前”
it
对象。
您是否有所有类型派生自的公共基类？否则您将丢失有关该类型的信息。然后，boost:：any可能是一个选项您也可以查看
boost:：variant
。感谢您提供的信息。