while (endRay())
{
  // перебираем точки на луче;
}

J>недостаточно входных данных

class BaseFunctor
{
public:
    virtual bool operator()(const int & idata) { return false;}
};

template <class T>
class DerivedFunctor: public BaseFunctor
{
private:
    bool (T::*fpt_)(const int & idata); 
    T * ptTObject_;
public:
    DerivedFunctor(T* ptTObject, bool (T::*fpt)(const int & idata))
    { ptTObject_ = ptTObject; fpt_=fpt;}
    virtual bool operator()(const int & idata) { return (*ptTObject_.*fpt_)(idata);}
};

// классы задающие условия
// по индексу
class IndexEndPath
{
private:
    int endI_; 
public:
    IndexEndPath(const int & endI) {endI_=endI;}

    bool check(const int & idata) {return idata != endI_;}
};
// по количеству элементов
class NrElemsEndPath
{
private:
    int nrElems_;
public:
    NrElemsEndPath(const int & nrElems) {nrElems_ = nrElems;}

    bool check(const int & idata) {return idata != nrElems_;}
};

int main(int argc, char * argv[])
{
    int i=0;
    std::cout << "end by index\n";
    IndexEndPath objIndexEndPath(10);
    DerivedFunctor<IndexEndPath> conditionIndex(&objIndexEndPath, &IndexEndPath::check);
    while (conditionIndex(i))
    {
        std::cout << i++ << std::endl;
    }

    std::cout << "end by nr of elements\n";
    i=0;
    NrElemsEndPath objNrElemsEndPath(5);
    DerivedFunctor<NrElemsEndPath> conditionNrElems(&objNrElemsEndPath, &NrElemsEndPath::check);
    while (conditionNrElems(i))
    {
        std::cout << i++ << std::endl;
    }

    std::cin.get();
    return 0;
}

class IndexIterator
{
   private:
      Point *points_;
      int i_;
      int end_;
      int step_;

   public:
      IndexIterator(Point *p, int start, int end, int step): points_(p), i_(start), end_(end), step_(step) {}

      bool  hasNext       { return i_ < end_; }
      Point *getNext()    { return points_[i_]; }
      void  moveForward() { i_ += step_; }
};

void foo()
{
   Points *p;

   IndexIterator i(p, 0, 10, 1);

   while (i.hasNext())
   {
      Point *p = i.getNext();
      // Do ....
      i.moveForward();
   }
}

template <class T, class Arg>
class DerivedFunctor
{
private:
    T * p_;
    bool (T::*fpt_)(const Arg &); 
public:
    DerivedFunctor(T* p, bool (T::*fpt)(const Arg &)) : p_(p), fpt_(fpt) {}
    bool operator()(const Arg & idata) const { return (*p_.*fpt_)(idata); }
};

    const DerivedFunctor<IndexEndPath, int> conditionIndex(&objIndexEndPath, &IndexEndPath::check);
    const DerivedFunctor<NrElemsEndPath, double> conditionNrElems(&objNrElemsEndPath, &NrElemsEndPath::check);

А>while (endRay())
А>{
А>  // перебираем точки на луче;
А>}
А>

for(Some i=SomeBegin(); i!=SomeEnd(); ++i)
{
    // *i - это текущая точка луча
}

Collection::iterator stop = // на выбор:
    coll.end() // все
    std::find(coll.begin(), coll.end(), value) // отсечка по значению
    std::find_if(coll.begin(), coll.end(), predicate) // отсечка по условию
    coll.begin() + n // заданное количество

for_each(coll.begin(), stop, visitor_func);