How can I get data iteratively from another class in C++?

Question

In class A, there is a vector V. V is a private member.

In class B, I want to print all items of V. What is the best way to do this?

It is very easy to get an iterator of a vector in the same class, but not easy in another class.

Thank you for reading.

Answer 1

I A owns the vector, it's up to A to print it. Expose as little as possible, especially for private members.

An alternative would be the visitor pattern; this keeps the data encapsulated, yet allows a lot of flexibility.

struct A {
   template< typename F > void each( F& f ) const {
     std::for_each( data.begin(), data.end(), f );
   }

private:
   std::vector<int> data;
};

struct B : public A {
  static void tprint()( int i )  { std::cout<<i<<std::endl; }
  void print()const {
    each( tprint );
  }
};

Answer 2

If B wants to print A’s vector, that’s a request to A, so A should have a method in its public interface to make that possible, e.g. (say V has type vector<int>):

class A {
…
public:
    void dump_values(std::ostream& out) const {
        std::copy(V.begin(), V.end(), std::ostream_iterator<int>(out, " "));
    }
}

Answer 3

Without knowing much about the specifics of the responsibilities of class A and B, I would suggest class A return a const reference to the vector stored in class B. This gives you read-only access to the vector and does not require the performance hit of copying.

  class B
  { 
  private:
      std::vector<int> m_vector;
  public:
      const std::vector<int>& GetVector() {return m_vector}
  }


  class A
  {
  private:
       B m_b;
  public:
     void printVector()
     {
         const std::vector<int>& refToVec = m_b.GetVector();
         std::vector<int>::const_iterator iter = refToVec.begin();
         for (; iter != refToVec.end(); ++iter)
         {
            std::cout << *iter << std::endl;
         }
     }
  }

Answer 4

If V is a private member then you have to ask why you would want to get to it from outside of the class? To avoid violating the encapsulation of this data you have several options:

1. Print all items of V from within A.
2. Pass an instance of B to A so that it can use it to print the items from V.

E.g. :

A::printInternalData( const B& printer ) { printer.print( V ); };

Besides this you must expose V to the outside world.

Answer 5

What about implementing this_stuff_begin() and this_stuff_end() members that return iterators for the vector? It's not clear what's the use of having it private though…

Answer 6

Taking your point:

It is very easy to get an iterator of a vector in the same class, but not easy in another class.

(and assuming that wanting to print the elements is a just a place holder for some other complicated action)

You can still expose the an iterator for your vector from A that can be used inside of B via a typedef, e.g.

class A
{
private:
    std::vector<int> V;
public:
    typedef std::vector<int>::const_iterator const_iterator;
    const const_iterator begin() const
    {
     return V.begin();
    }

    const const_iterator end() const
    {
     return V.end();
    }
};

Then you can use those iterators like this:

class B
{
public:
    void Foo()
    {
     A a;
     // do stuff that will put things into the collection inside 'a'
     std::copy(a.begin(), a.end(), std::ostream_iterator<int>(std::cout, " "));
    }
};

I've used const_iterator in this case, because you asked for read-only access, but you can use iterator instead if you need write access (although that's likely to be a poor design choice, writing to an internal member like that).