C++ Access private member of nested class

c++, class, class-visibility

Solution

Technically, that's a nested class (declared within another class), not a subclass (which inherits from its superclass).

You can allow the Tree class to access its privates by making it a friend:

class UserElement {
    friend class Tree;
    // ...
};

or, for better encapsulation, you could restrict access only to the member function(s) that need it, although it gets a bit messy due to the need to declare things in the right order:

class Tree {
public:
    // Declare this so we can declare the function
    template <typename T> class UserElement;

    // Declare this before defining `UserElement` so we can use it
    // in the friend declaration
    template <typename T>
    void doSomethingWithTheTree(list<UserElement<T>> elements) {
        elements.front().leaf;
    }

    template <typename T>
    class UserElement {
        // Finally, we can declare it a friend.
        friend void Tree::doSomethingWithTheTree<T>(list<UserElement<T>>);
        // ...
    };
};

Problem

The title might be a bit misleading. I have the following problem: I have a tree consisting of leaves and internal nodes. The user should be able to store any information in the leaves and the tree has some methods which get a set of user-defined values and need to access the corresponding leaves in constant time (not amortized). I came up with the following idea but it does not work because unfortunately I cannot access private members of a nested class: The user creates the tree and also for each leaf an instance of `UserElement` which contains the user_defined value for the corresponding leaf. Once a method like doSomethingWithTheTree(list>) is called and the tree is built, the tree creates the corresponding leaves and saves it in the private field `leaf`. Whenever the user wants to call a method with some of the leaves corresponding to its user_defined values, he/she just has to call the method by giving the corresponding `UserElement`s and the tree can retrieve the corresponding leaves in constant time. ``` class Tree { public: template <typename T> class UserElement { private: T user_value; tree_node* leaf; // this has to be private for // everyone outside the class `Tree` public: T getInf() { return user_value; } void setInf(T i) { user_value = i; } }; void doSomethingWithTheTree(list<UserElement<T>> elements) { ... // I want to be able to access elem.leaf for all elements } } ```

Original source