Providing my own simple iterators

[std10093]

I follow the example in this link. There, it has an int. I want to have a std::vector<double>.

Here is my attempt

#include <iterator>     // std::iterator, std::input_iterator_tag

class MyIterator : public std::iterator<std::input_iterator_tag, std::vector<double> >
{
  std::vector<double>* p;
public:
  MyIterator(std::vector<double>& x) :p(&x) {}
  MyIterator(const MyIterator& mit) : p(mit.p) {}
  MyIterator& operator++() {++p;return *this;}
  MyIterator operator++(int) {MyIterator tmp(*this); operator++(); return tmp;}
  bool operator==(const MyIterator& rhs) {return p==rhs.p;}
  bool operator!=(const MyIterator& rhs) {return p!=rhs.p;}
  double& operator*() {return p->at(0);}

  // obviously this is wrong
  void operator=(std::vector<double>::iterator& x) { p=&x; }
  std::vector<double>::iterator begin() { return p->begin(); }
  std::vector<double>::iterator end() { return p->end(); }
};

What can I do?

[phantomotap]

O_o

That is wrong in very many ways.

What are you trying to do?

If you just want to use the iterators of a `std::vector<double>', just call `begin/end' storing the result in a `std::vector<double>::iterator'.

If you want something else, ignore the example; explain the idea.

[Edit]
With "explain the idea", I am not asking for you to tell me again that you want to provide your own iterators.

I want to know what kind of iterator you want to provide. What does iterator do? For what type of collection does the iterator provide navigation? I am interested in that sort of information.
[/Edit]

Soma

[std10093]

Ok, here is the idea.
I have a class Point, which has as a private member an std::vector.
I want however, to have another class, that will inherit from Point and I want to be able to increment the iterator of the vectors by a constance factor, e.g. 4. I do not however to let vector exposed to that other class.

class A : public Point {
   void foo(Iterator to the point1 a, Iterator to point2 b) { // or any suitable arguments
      a += 4;
      b += 5;
}

Of though of using a typedef maybe. But it would be nice to learn something about iterators too.

[phantomotap]

O_o

1): The `value_type' of the iterator would still be `double'.
2): The constructor should be provided, by the `begin'/`end' functions implemented within `Point', the iterators returned by the member variable `std::vector<???>' instance--the containers `begin'/`end'.
3): The provided iterators should be stored by your custom iterator.

You may then easily implement the functionality of your custom iterator using the interfaces provided by the "composed" iterators.

Soma

[std10093]

I don't get the 3rd point.

[whiteflags]

You are going to have to contain the iterators to the actual vector in your custom iterator in order to mess with them.

[std10093]

Can you provide an example or something? :/

[whiteflags]

I guess I can do that. I'm gleaning as much from the conversation as I can, but I really feel like I'm guessing.

class PointsIterator : public std::iterator<std::input_iterator_tag, double>
{
   private:
   std::vector<double>::iterator containerStart;
   
   public:
   PointsIterator (const std::vector<double>& dataSource): containerStart(dataSource.begin())
   {
   }

   double operator * ()
   {
      // operations that should occur during access
      return (*containerStart);
   }

   PointsIterator& operator ++ ()
   {
      // operations that should occur during update
      containerStart += 4; // possibly? the idea is still rather opaque to me.
      return (*this);
   }
};

I would think you would at least need to know that much about your iterator to write it. Then you have to consider copy semantics and such.

Point would contain the begin() and end() methods, and would have to call the contructor for the iterator.

[phantomotap]

Can you provide an example or something?

O_o

I rarely provide examples with so little effort.

If you want more help, show more effort. Take what you've been told with the code provided by whiteflags and post what you code you manage.

possibly? the idea is still rather opaque to me.

The idea has two common names depending on ancestry: skip iterators and filtered iterators.

Technically, a skip iterator is a specific flavor of a filter iterator where the filter is "skip every x elements".

The idea is often used in combination with some form of packing.

class SAdapterPackingColor
{
    // ...
};

class SColor
{
    // ...
    typedef SAdapterPackingColor RAdapter;
    // ...
    float mRed;
    float mGreen;
    float mBlue;    
    // ...
};

// ...

float * sLine = new float[sWidth + padding];

// ...

SIteratorSpan<SColor> sPixels(sLine, sWidth + padding, 3);

// ...

*sPixels = SColor(0.0f, 0.0f, 0.0f); // sLine[0] = 0.0f; sLine[1] = 0.0f; sLine[2] = 0.0f;
++sPixels;
*sPixels = SColor(0.0f, 0.0f, 0.0f); // sLine[3] = 0.0f; sLine[4] = 0.0f; sLine[5] = 0.0f;

Obviously, the idea works "better" with languages that support a more significant form of "duck typing".

Soma

[std10093]

Here is where I reached:

class A {
public:
  class PointsIterator : public std::iterator<std::input_iterator_tag, double>
  {
     private:
     std::vector<double>::iterator p;

     public:
     PointsIterator (std::vector<double>& dataSource):
       p(dataSource.begin())
     {
     }

     PointsIterator(const PointsIterator& mit) : p(mit.p) {}

     double operator * ()
     {
        // operations that should occur during access
        return (*p);
     }

     PointsIterator& operator++() {++p;return *this;}
     PointsIterator operator++(int) {PointsIterator tmp(*this); operator++(); return tmp;}
     bool operator==(const PointsIterator& rhs) {return p==rhs.p;}
     bool operator!=(const PointsIterator& rhs) {return p!=rhs.p;}
  };
  // no idea what to put here
  //PointsIterator& begin() { return v.begin(); }
  void push(double a) { v.push_back(a); }
  //typedef typename std::vector<double>::iterator it;
private:
  std::vector<double> v;
};

int main()
{

  A numbers;
  numbers.push(1);
  numbers.push(2);
  numbers.push(3);
  numbers.push(4);
  numbers.push(5);

  A::PointsIterator from(numbers);
  PointsIterator until(numbers);
  for (PointsIterator it=from.begin(); it!=until.end(); it++)
    std::cout << *it << ' ';
  std::cout << '\n';

  return 0;
}

Errors:

./main.cpp: In function ‘int main()’:
../main.cpp:56:33: error: no matching function for call to ‘A::PointsIterator::PointsIterator(A&)’
../main.cpp:56:33: note: candidates are:
../main.cpp:25:6: note: A::PointsIterator::PointsIterator(const A::PointsIterator&)
../main.cpp:25:6: note:   no known conversion for argument 1 from ‘A’ to ‘const A::PointsIterator&’
../main.cpp:20:6: note: A::PointsIterator::PointsIterator(std::vector<double>&)
../main.cpp:20:6: note:   no known conversion for argument 1 from ‘A’ to ‘std::vector<double>&’
../main.cpp:57:3: error: ‘PointsIterator’ was not declared in this scope
../main.cpp:57:18: error: expected ‘;’ before ‘until’
../main.cpp:58:23: error: expected ‘;’ before ‘it’
../main.cpp:58:40: error: ‘it’ was not declared in this scope
../main.cpp:58:44: error: ‘until’ was not declared in this scope
make: *** [main.o] Error 1

[std10093]

Oh Whiteflags I forgot. I do not want the ++ to do +4. Doing a normal ++ is ok.

[Elysia]

I have trouble seeing why you need an iterator.

What is an iterator to point? What are you iterating over? Unless you cannot make a good argument over something in your point that you could naturally expect to iterate over, I would refrain from making an iterator. I cannot see why you need an iterator for a Point. You are iterator what - sub-points?

If you want a derived class to be able to iterate over a private variable, how about exposing some protected members functions that returns a const iterator to the vector (appropriately named of course)?

[std10093]

I want the later you said (iterate over the private vector of Point class, without exposing the vector). Well, yes I thought of protected too and other ways to do it. But maybe I just wanted to see a little about iterators too. In order to get the job done, I just overloaded an operator inside the class Point.

[phantomotap]

O_o

Do you know how constructors work?

You are trying too much at one pass for something you don't understand.

You should start hitting what I explained in post four. Don't worry about the operators and other stuff. Start by getting the construction correct. Again, the class which owns the custom iterator is responsible for providing a `begin'/`end'.

[Edit]
The client code should use a compatible iterator interface which you are responsible for providing.

A compatible example matching the client code you posted:

int main()
{
    A numbers;
    numbers.push(1);
    numbers.push(2);
    numbers.push(3);
    numbers.push(4);
    numbers.push(5);
    A::PointsIterator from(numbers.begin());
    A::PointsIterator until(numbers.end());
    for(A::PointsIterator it(from); it != until; ++it)
        std::cout << *it << ' ';
    std::cout << '\n';
    return(0);
}

[/Edit]

Soma

[std10093]

This outputs the numbers, but I had to remove some refernces..What do you think about it?

class A {
public:
  class PointsIterator : public std::iterator<std::input_iterator_tag, double>
  {
     private:
     std::vector<double>::iterator p;

     public:
     PointsIterator (std::vector<double>::iterator dataSource):
       p(dataSource)
     {
     }

     PointsIterator(const PointsIterator& mit) : p(mit.p) {}

     double operator * ()
     {
        // operations that should occur during access
        return (*p);
     }

     PointsIterator& operator++() {++p;return *this;}
     PointsIterator operator++(int) {PointsIterator tmp(*this); operator++(); return tmp;}
     bool operator==(const PointsIterator& rhs) {return p==rhs.p;}
     bool operator!=(const PointsIterator& rhs) {return p!=rhs.p;}
  };

  std::vector<double>::iterator begin() {return v.begin();}
  std::vector<double>::iterator end() {return v.end();}
  void push(double a) { v.push_back(a); }
private:
  std::vector<double> v;
};

int main()
{
    A numbers;
    numbers.push(1);
    numbers.push(2);
    numbers.push(3);
    numbers.push(4);
    numbers.push(5);
    A::PointsIterator from(numbers.begin());
    A::PointsIterator until(numbers.end());
    for(A::PointsIterator it(from); it != until; ++it)
        std::cout << *it << ' ';
    std::cout << '\n';
    return(0);
}