Question

I have a data structure “Person”

struct Person
{
  protected:
    string name;
    int age;
    string address;
    ...
}

I want to create “views” around this structure to separate out access to different member variables:

class PersonRead: public Person
{
  public:
    string getName() {..}
    int getAge() {...}
    ...
}
class PersonUpdate: public Person
{
  public:
    void setAddress( string address_ ) {...}
    void setAge( int age_ ) {...}
    ...
}

I use this to only expose those methods/variables which are really required:

int main()
{
...
    writePersonDataToFile ( (PersonRead) personObj );
    updatePersonData ( (PersonUpdate) personObj);
...
}

Though the above code serves my purpose, there are several issues including:

1. The public inheritence here is not exactly an ‘is-a’ relationship

2. I need to derive IndianPerson from Person, and all the corresponding interfaces. This leads to bad diamond pattern:

   struct IndianPerson: public Person {};
   class IndianPersonRead: public IndianPerson, public PersonRead {}; //Person Class common, Diamond pattern here!
   

Is there a name for such a design pattern? What are better ways to implement this pattern? I have a feeling Policy classes might help, but cant figure out how to implement this

Any examples would be great help

Answer 1

For your scenario this might seem like overkill but, if you want fine grained control over which classes can call different methods on your class the c++ client-attorney idiom idiom might be appropriate.

For a detailed description of this idiom see http://drdobbs.com/184402053

Here is a rough example (note: this has not been compiled, although it is based on production code I am currently using):

class Person
{
public:
   /// constructor destructor etc:

private:
    string getName() { return name; }

public:
    /// Writer Attourney that access to allows class PersonReader access 
    /// to getXXX functions
    class ReaderAttorney
    {
    private:
        /// Add additional reader member functions...
        static string readName( Person& p )
        { 
            return p.getName();
        }

        // Make any classes that shuold be allowde read access friends of the 
        // attorney here
        friend class PersonReader;
    };

    /// Writer Attourney that access to allows class PersonWriter access 
    /// to setXXX functions
    class WriterAttorney
    {
    private:
        /// Add additiona reader member functions...
        static string setName( Person& p, const string& newName )
        { 
            p.setName( newName );
        }
        friend class PersonWriter;
    };

private:
    string name;
    int age;
    string address;
};

This can be used as follows:

void PersonWriter::setPersonDetails( const string& name, int age .... )
{
   // PersonWriter is a frend of WriterAttorney and is granted access
   Person::WriterAttorney::setName( name );
   Person::WriterAttorney::setName( age );

   // Note this will fail, since PersonWriter is not a friend of 
   // ReaderAttorney, ergo it is not granted read permission:
   Person::ReaderAttorney::readName();
}