C++: how to make a group of derived classes be able to access private members of one class?

Question

Suppose a class: Library

And we have a group of derived class from the base class LibraryCustomer, such as: Kid, Parent, Student, etc

In the class of Library, there are a group of (tons of) private members variables. Since there are tons of private members in the class of Library, I do not want to use getter and setter which are tedious. Plus the LibraryCustomer derived classes will often refer to those members. Getter and Setter are not convenient.

In order for those LibraryCustomers to access those private member in Library, I need to claim those LibraryCustomers as friend classes in Library.

But since the derived classes keep growing, I do not want to add them one by one in the class Library.

Add the base class LibraryCustomer as friend in Library seems not to work. So what is another better way?

[Update] I want to access tons of private member variables in the class of Library. Since there are many, so I do not want to use getter and setter. I hope the derived classes from LibraryCustomer can freely access those private member variables in the class of Library.

Answer 1

Provide a function in LibraryCustomer that accesses Library to get the data and provides that data to the classes derived from LibraryCustomer.

class Library
{
   friend class LibraryCustomer;

   private:

     std::string name;
};

class LibraryCustomer
{
   protected:

   std::string getLibraryName(Library const& lib)
   {
      return lib.name;
   }
};

class Kid : public LibraryCustomer
{
    // Can use LibraryCustomer::getLibraryName() any where
    // it needs to.
};

Having said that, it will be easier to provide access to the data from Library itself.

class Library
{
   public:

      std::string getName() const { return name; }

   private:

     std::string name;
};

Then, there won't be the need for the friend declaration and the wrapper function LibraryCustomer::getLibraryName().

EDIT

@MooingDuck has interesting suggestion. If you have to expose many such variables, it might be better to put them all in one class. Working code at http://coliru.stacked-crooked.com/a/2d647c3d290604e9.

#include <iostream>
#include <string>

class LibraryInterface {
public:
    std::string name;
    std::string name1;
    std::string name2;
    std::string name3;
    std::string name4;
    std::string name5;
    std::string name6;
};

class Library : private LibraryInterface
{
public:
    Library() {name="BOB";}
private:
    LibraryInterface* getLibraryInterface() {return this;} //only LibraryCustomer can aquire the interface pointer
    friend class LibraryCustomer;
};

class LibraryCustomer
{
   protected:
       LibraryInterface* getLibraryInterface(Library& lib) {return lib.getLibraryInterface();} //only things deriving from LibraryCustomer can aquire the interface pointer
};

class Kid : public LibraryCustomer
{
public:
    void function(Library& lib) {
        LibraryInterface* interface = getLibraryInterface(lib);
        std::cout << interface->name;
    }
};

int main() {
    Library lib;
    Kid k;
    k.function(lib);
}