Re: Permitting access to only a subset of the public methods

Hi,

I'm not sure if i'm asking the question correctly but anyway here it
is.

Say I have 3 classes - class A, class B, class R.
1) A and B are the building blocks and R is like a repository that
stores objects of A and B.
2) A is at the lowest level and should "know about" only other As. B
should know only about As and other Bs.
3) R has 3 types of public methods - (i) methods to add A,B (ii)
methods to access A, B and (iii) all other methods.

For now I pass a pointer to R to both A and B so that they can access
information from R as required. However, this exposes all public
methods (ie., (i), (ii) and (iii)) of R to both A and B.

How do I change it so that A and B can only access methods of type
(ii)? (The rationale is that A/B will never add another A/B and they
shouldn't be doing anything else related to R). Is there a way to make
a subclass of R called Rsub and pass that pointer to A,B? Is that a
good way to do it?

I have included code below.

Thanks.

#include <iostream>
#include <vector>

using namespace std;

class A;
class B;
class R;

class A {
public:
    A (R* r, const int& i) : rp(r), N(i) {}
    int getN (void) const { return N; }
    void fA (const int& idx)
        {
            // Access an A object at index idx through rp
        }
private:
    R* rp;
    int N;
};

class B {
public:
    B (R* r, const string& s) : rp(r), str(s) {}
    string getStr (void) const { return str; }
    void fB1 (const int& idx)
        {
            // Access an A object at index idx through rp
        }
    void fB2 (const int& idx)
        {
            // Access a B object at index idx through rp
        }
private:
    R* rp;
    string str;
};

class R {
public:
    // Methods to add A, B
// void addA (const int& i) { A a(i); vA.push_back(a); }
// void addB (const string& s) { B b(s); vB.push_back(b); }
    void addA (const A& a) { vA.push_back(a); }
    void addB (const B& b) { vB.push_back(b); }

    // Methods to access information for A,B
    int getAN (const int& idx) const { return vA.at(idx).getN(); }
    string getBstr (const int& idx) const { return
vB.at(idx).getStr(); }
    // ... some more info

    // All other methods
    // ...
private:
    vector<A> vA;
    vector<B> vB;
};

int main() {
    R rep;

    A a1(&rep, 100);
    A a2(&rep, 200);
    rep.addA(a1);
    rep.addA(a2);
    cout << rep.getAN(0) << " and " << rep.getAN(1) << endl;

    // a2.fA(0); // should return info about a1

    B b1(&rep, "dog");
    B b2(&rep, "cat");
    rep.addB(b1);
    rep.addB(b2);
    cout << rep.getBstr(0) << " and " << rep.getBstr(1) << endl;

    // b2.fB1(0); // should return info about a1
    // b2.fB2(0); // should return info about b1

    return 0;
}