C++ – friend function in derived class with private inheritance

cinheritance

If a class Derived is inherited privately from a class Base and the Derived class has a friend function f(), so what members can f() access from Derived class and Base class.

class Base {
public:
    int a;
protected:
    int b;
private:
    int c;
};  


class Derived: private Base {    
    void friend f() {}

public:
    int d;
protected:
    int e;
private:
    int f;
};

I understand that if a class is inherited privately from the base class, everything is private in the derived class.

But why in the code above, the function f() can access a, b, d, e, f but not c?

Best Answer

'Friendship' grants access to the class that declares the friend - it's not transitive. To use a bad analogy - my friends are not necessarily my dad's friends.

The C++ FAQ has a bit more detail:

http://www.parashift.com/c++-faq-lite/friends.html#faq-14.4

Related Solutions

C# – Calling the base constructor in C#

Modify your constructor to the following so that it calls the base class constructor properly:

public class MyExceptionClass : Exception
{
    public MyExceptionClass(string message, string extrainfo) : base(message)
    {
        //other stuff here
    }
}

Note that a constructor is not something that you can call anytime within a method. That's the reason you're getting errors in your call in the constructor body.

C++ – How to call a parent class function from derived class function

I'll take the risk of stating the obvious: You call the function, if it's defined in the base class it's automatically available in the derived class (unless it's private).

If there is a function with the same signature in the derived class you can disambiguate it by adding the base class's name followed by two colons base_class::foo(...). You should note that unlike Java and C#, C++ does not have a keyword for "the base class" (super or base) since C++ supports multiple inheritance which may lead to ambiguity.

class left {
public:
    void foo();
};

class right {
public:
    void foo();
};

class bottom : public left, public right {
public:
    void foo()
    {
        //base::foo();// ambiguous
        left::foo();
        right::foo();

        // and when foo() is not called for 'this':
        bottom b;
        b.left::foo();  // calls b.foo() from 'left'
        b.right::foo();  // call b.foo() from 'right'
    }
};

Incidentally, you can't derive directly from the same class twice since there will be no way to refer to one of the base classes over the other.

class bottom : public left, public left { // Illegal
};

Best Answer

Related Solutions

C# – Calling the base constructor in C#

C++ – How to call a parent class function from derived class function

Related Topic