There is a very simple pattern, which has retro-actively been dubbed PassKey, and which is very easy in C++11: template <typename T> class Key { friend T; Key() {} Key(Key const&) {} }; And with that: class Foo; class Bar { public: void special(int a, Key<Foo>); }; And the call site, in any Foo method, … Read more
Here is a highly simplified but hopefully relevant view of what happens when you build your code in C++. C++ splits the load of generating machine executable code in following different phases – Preprocessing – This is where any macros – #defines etc you might be using get expanded. Compiling – Each cpp file along … Read more
template<typename> friend class foo this will however make all templates friends to each other. But I think this is what you want?
Ideally, you shouldn’t need to unit test private methods at all. All a consumer of your class should care about is the public interface, so that’s what you should test. If a private method has a bug, it should be caught by a unit test that invokes some public method on the class which eventually … Read more
After having asked more or less the same question here myself, I wanted to share the (apparently) updated answer for C++11: Quoted from https://stackoverflow.com/a/14759027/1984137: standard $11.7.1 “A nested class is a member and as such has the same access rights as any other member. The members of an enclosing class have no special access to … Read more
This is one of those frequently asked questions that have different approaches that are similar but not really the same. The three approaches differ in who you are declaring to be a friend of your function –and then on how you implement it. The extrovert Declare all instantiations of the template as friends. This is … Read more
Because I may write Foo and its friend Bar (thus there is a trust relationship). But do I trust the people who write classes that are derived from Bar? Not really. So they should not inherit friendship. Any change in the internal representation of a class will require a modification to anything that is dependent … Read more
No, there’s no difference – you just tell that class B is a friend of class A and now can access its private and protected members, that’s all.
There are several ways to write swap, some better than others. Over time, though, it was found a single definition works best. Let’s consider how we might think about writing a swap function. We first see that containers like std::vector<> have a single-argument member function swap, such as: struct vector { void swap(vector&) { /* … Read more
On a side note. Using friend is not about violating the encapsulation, but on the contrary it’s about enforcing it. Like accessors+mutators, operators overloading, public inheritance, downcasting, etc., it’s often misused, but it does not mean the keyword has no, or worse, a bad purpose. See Konrad Rudolph’s message in the other thread, or if … Read more