C++ 无法使BOOST_FOREACH与我的自定义类一起工作

我实现了一个平凡的类

MyClass

，其中有一个分配了

new

的数组（我知道我可以使用STL容器，但我试图了解它们是如何工作的）。我还创建了一个迭代器子类，能够迭代

MyClass

对象的所有元素：

class MyIterator : public iterator<forward_iterator_tag,int>
{
private:
    int* data= nullptr;
    int length;
    int pointer=0;
    int nullvalue=0;
public:
    MyIterator(int* data, int length, bool end= false)
    {
        this->data= data;
        this->length= length;
        if(end)
            pointer=-1;
    }
    ~MyIterator()
    {
        delete[] data;
    }
    MyIterator& operator++()
    {
        if(pointer!= length-1)
        {
            pointer++;
        }
        else
        {
            pointer= -1;
        }
        return *this;
    }
    bool operator==(const MyIterator& other)
    {
        return pointer==other.pointer;
    }
    bool operator!=(const MyIterator& other)
    {
        return pointer!= other.pointer;
    }
    int& operator* ()
    {
        if(pointer==-1)
            return nullvalue;
        else
            return data[pointer];
    }
};

class MyClass
{
private:
    int* data= nullptr;
    int length= 100;
public:
    MyClass()
    {
        data= new int[length];
        for(int i=0; i<length;i++)
            data[i]=i+1;
    }
    iterator<forward_iterator_tag,int> begin()
    {
        return MyIterator(data,length);
    }
    iterator<forward_iterator_tag,int> end()
    {
        return MyIterator(data,length,true);
    }
};

如果我尝试将其与BOOST_FOREACH一起使用，则它不起作用：

BOOST_FOREACH(int i, MyClass_instance) {...}

以下是我得到的错误：

• 通过将迭代器按值返回为

  std:：iterator

  ，可以对迭代器进行切片。你不能那样做
  通过引用返回将避免切片问题，但是引入了一个更糟糕的问题：它返回一个对一个临时文件的引用
  因此，通过按值返回实际的迭代器类型来修复它

• 您的类型缺少常量迭代器

• 所有迭代器成员的常量都不正确

• 另外，根据页面看起来您需要添加

  namespace boost {
      template<> struct range_mutable_iterator<MyClass> {
          typedef MyClass::MyIterator type;
      };
  
      template<> struct range_const_iterator<MyClass> {
          typedef MyClass::MyConstIterator type;
      };
  }
  

  ---

  ---

  1（除非您将迭代器存储在其他地方，但由于许多原因，这将是一个巨大的反模式）
  工作示例我得到一个无法理解的语法错误：“没有匹配的函数用于调用‘deref’”，在调用BOOST\u FOREACH的同一行中。问题出在名为struct u iterator u traits impl的结构中，在STL的迭代器头中。@RamyAlZuhouri有趣。你注意到现场样品了吗？我很想假设你在做不同的事情。我真的无法解释你没有显示的代码。

  namespace boost {
      template<> struct range_mutable_iterator<MyClass> {
          typedef MyClass::MyIterator type;
      };
  
      template<> struct range_const_iterator<MyClass> {
          typedef MyClass::MyConstIterator type;
      };
  }
  

  #include <iterator>
  #include <boost/foreach.hpp>
  
  class MyClass
  {
  private:
      int* data  = nullptr;
      int length = 100;
  
  public:
      class MyIterator : public std::iterator<std::forward_iterator_tag, int>
      {
          public:
              MyIterator(int* data, int length, bool end = false)
              {
                  this->data= data;
                  this->length= length;
                  if(end)
                      pointer=-1;
              }
              MyIterator& operator++()
              {
                  if(pointer!= length-1) {
                      pointer++;
                  }
                  else {
                      pointer= -1;
                  }
                  return *this;
              }
  
              bool operator==(const MyIterator& other) const { return pointer==other.pointer; }
              bool operator!=(const MyIterator& other) const { return pointer!= other.pointer; }
              int& operator*() const
              {
                  if(pointer==-1)
                      return nullvalue;
                  else
                      return data[pointer];
              }
          private:
              value_type* data     = nullptr;
              int length;
              int pointer          = 0;
              mutable value_type nullvalue = 0;
      };
  
      class MyConstIterator : public std::iterator<std::forward_iterator_tag, const int>
      {
          public:
              MyConstIterator(int const* data, int length, bool end = false)
              {
                  this->data= data;
                  this->length= length;
                  if(end)
                      pointer=-1;
              }
              MyConstIterator& operator++()
              {
                  if(pointer!= length-1) {
                      pointer++;
                  }
                  else {
                      pointer= -1;
                  }
                  return *this;
              }
  
              bool operator==(const MyConstIterator& other) const { return pointer==other.pointer; }
              bool operator!=(const MyConstIterator& other) const { return pointer!= other.pointer; }
              int const& operator*() const
              {
                  if(pointer==-1)
                      return nullvalue;
                  else
                      return data[pointer];
              }
          private:
              value_type* data     = nullptr;
              int length;
              int pointer          = 0;
              value_type nullvalue = 0;
      };
  
  public:
      typedef MyIterator iterator_type;
      typedef MyConstIterator const_iterator_type;
  
      MyClass()
      {
          data= new int[length];
          for(int i=0; i<length;i++)
              data[i]=i+1;
      }
      ~MyClass() {
          delete[] data;
      }
      iterator_type begin()             { return MyIterator(data,length);      }
      iterator_type end()               { return MyIterator(data,length,true); }
      const_iterator_type begin() const { return MyConstIterator(data,length);      }
      const_iterator_type end()   const { return MyConstIterator(data,length,true); }
  };
  
  namespace boost {
      template<> struct range_mutable_iterator<MyClass> {
          typedef MyClass::MyIterator type;
      };
  
      template<> struct range_const_iterator<MyClass> {
          typedef MyClass::MyConstIterator type;
      };
  }
  
  #include <iostream>
  
  int main()
  {
      MyClass c;
      BOOST_FOREACH(int i, c) {
          std::cout << i << "\n";
      }
  }