Class interaction tips - c++

Question

I am puzzled by some issues when trying to design interacting classes.
If a class A needs some data from class B, either in the form of a pointer or standard container format, (or even lets become more ambitious and say in the form of some shared_ptr members to stl containers.), my way is to use a function that returns the same kind of arguments and design class B methods with conforming arguments? Are there a general rules of thumb for designing interacting classes and share data between these classes?
Could you please draw a general scheme for some common situations that are generally encountered in practice(and along some examples are appreciated)? I guess I should read some examples on class interaction in C++, any pointers on this are also appreciated?
A small sample could be:
#include <iostream>
#include <vector>
#include <iterator>
#include <cassert>
using namespace std;
class A{
public:
A(int s, int val):sz(s), val(val), v(new vector<int>){}
int fill_vector(){
for(int k=0;k!=sz;++k)
v->push_back(val);
return 0;
}
~A(){
cout << "Dtor is deleting the pointer to vector\n";
delete v;
}
vector<int>* get_pointer_to_vector_in_A(){ return v; }
private:
int sz, val;
vector<int> *v;
};
class B{
public:
B(){} // does nothing basically
int print_vector_contents_from_A( vector<int> *v_from_A ) const
{
assert(!v_from_A->empty());
copy(v_from_A->begin(), v_from_A->end(),
ostream_iterator<int>(cout, "\n") );
}
};
int main()
{
A a(10, 4);
a.fill_vector();
B b;
b.print_vector_contents_from_A( a.get_pointer_to_vector_in_A() );
return 0;
}

Answer 1

It rather depends on what A is, conceptually. If A can be validly viewed as a sequence of int, then I'd implement size_t size() const and int &operator[](size_t) (+ its const counterpart) on it. These can just delegate their activities to v.size and v[] or v.at.
In B, you can then define
static void B::print_contents(A const &a)
{
for (size_t i=0; i < a.size(); i++)
std::cout << a[i] << '\n';
}
A member that returns an std::vector<int>* breaks encapsulation: you can never change the implementation of A away from std::vector<int> except with very ugly hacks to ensure get_pointer_to_vector_in_A still works with the same semantics.

Answer 2

One great one-directional way to do this is:
class A {
public:
void fill_vector();
int vec_size() const { return vec.size(); }
int get_data(int i) const { return vec[i]; }
};
class B {
public:
B(A &a) : a(a) { }
void init() { a.fill_vector(); }
void fetch_and_print()
{ for(int i=0;i<a.vec_size();i++) std::cout << a.get_data(i); }
private:
A &a;
};
int main() {
A a;
B b(a);
b.init();
b.fetch_and_print();
}
The constructor parameter for class B is the important bit.