friend

Suppose I have a Base class: class Base { friend SomeOtherClass; }; And there is another (different) class that inherits from Base : class AnotherClass : public Base {} Is friendship inherited as well? In principle, a derived class inherits every member of a base class except: * its constructor and its destructor * its operator=() members * its friends So, no. Friends are not inherited. No it isn't. Edit: To quote from the C++ Standard, section 11.4/8 Friendship is neither inherited nor transitive. No it isn't, as documented here: http://www.parashift.com/c++-faq-lite/friends.html#faq-14.4 来源：

This question already has answers here : When should you use 'friend' in C++? (30 answers) Possible Duplicate: When should you use 'friend' in C++? I have come to a stumbling block because of lack of documentation on friend classes. Most books just explain it briefly, e.g an excerpt from C++: the Complete Reference : Friend Classes are seldom used. They are supported to allow certain special case situations to be handled. And frankly, I have never seen a friend class in any good code made by an experienced C++ programmer. So , here is my list of problems. Do Inherited Classes have the same

I'm in the proccess of learning the language and this is a noob doubt. Is it possible to use a virtual friend function? I don't know if it's possible, I didn't even test it but it could be useful in some situations. For example, for the overloaded operator<<(). DerivedClass dc; BaseClass &rbc = dc; cout << rbc; My guess is it's possible, but I'm not sure since a friend function is not implemented in the class design, and theoretically is not part of it (though in this example, conceptually it makes sense that operator<<() should be a method, but due to syntax limitations it's not possible to

In other words, why does this compile fine : template<typename Type> class A{ public: void f(); }; class B{ friend void A<int>::f(); }; template<> void A<int>::f(){ B* var = new B(); } While this doesn't : template<typename Type> class A{ public: void f(); }; template<typename Type> // B is now a templated class class B{ friend void A<Type>::f(); // Friending is done using B templated type }; template<> void A<int>::f(){ B<int>* var = new B<int>(); // var is now declared using int as its templated type } For the second code snippet, compiler (gcc 6.2, no special flags) says: main.cpp: In

I heard there is a possibility to enable google-test TestCase classes friends to my classes, thus enabling tests to access my private/protected members. How to accomplish that? Try this (straight from Google Test docs...): FRIEND_TEST(TestCaseName, TestName); For example: // foo.h #include <gtest/gtest_prod.h> // Defines FRIEND_TEST. class Foo { ... private: FRIEND_TEST(FooTest, BarReturnsZeroOnNull); int Bar(void* x); }; // foo_test.cc ... TEST(FooTest, BarReturnsZeroOnNull) { Foo foo; EXPECT_EQ(0, foo.Bar(NULL)); // Uses Foo's private member Bar(). } Ralfizzle I know this is old but I was

I'm having a situation similar to the one described in Specify a class member function as a friend of another class? . However in my case, class B needs to know class A since it's using it, so the solution given in that thread is not working for me. I tried to give also a forward declaration to the function itself but it didn't work as well. It seems that each class need the full definition of the other... Is there any easy way to solve it? I prefer a solution which doesn't involve new classes which wrap one of the old classes. code example: //A.h class B; //not helping void B::fB(); //not