friend

[ Of course, the question is not restricted to a specific "friend" implementation, feel free though to point out implementation specifics if relevant ] Reading through the unanswered questions, I stumbled upon the InternalsVisibleTo attribute: Specifies that types that are ordinarily visible only within the current assembly are visible to another assembly. The C# Programming Guide on MSDN has a section Friend Assemblies describing how to use the attribute to allow the use of internal methods and types to another assembly. I'm wondering whether it would be a Good Idea to use this to create a

This question already has an answer here: Is there a way to simulate the C++ 'friend' concept in Java? 19 answers How does one implement the friend concept in Java (like C++)? Alastor Moody Java does not have the friend keyword from C++. There is, however, a way to emulate that; a way that actually gives a lot more precise control. Suppose that you have classes A and B. B needs access to some private method or field in A. public class A { private int privateInt = 31415; public class SomePrivateMethods { public int getSomethingPrivate() { return privateInt; } private SomePrivateMethods() { } //

Suppose I have three C++ classes FooA, FooB and FooC. FooA has an member function named Hello , I want to call this function in class FooB, but I don't want class FooC be able to call it. The best way I can figure out to realize this is to declare FooB as a friend class of FooA. But as long as I do this, all FooA's private and protected members will be exposed which is quite unacceptable to me. So, I wanna know if there is any mechanism in C++(03 or 11) better than friend class which can solve this dilemma. And I assume it will be nice if the following syntax is possible: class FooA { private

In the (otherwise) excellent book C++ Coding Standards , Item 44, titled "Prefer writing nonmember nonfriend functions" , Sutter and Alexandrescu recommend that only functions that really need access to the members of a class be themselves members of that class. All other operations which can be written by using only member functions should not be part of the class. They should be nonmembers and nonfriends. The arguments are that: It promotes encapsulation, because there is less code that needs access to the internals of a class. It makes writing function templates easier, because you don't

Consider the following clause in [namespace.memdef]/3: If the name in a friend declaration is neither qualified nor a template-id and the declaration is a function or an elaborated-type-specifier , the lookup to determine whether the entity has been previously declared shall not consider any scopes outside the innermost enclosing namespace. Is there a reason for the exception for template-id along with the qualified name? For that matter, is there a reason for the lookup of an unqualified name that isn't a template-id to be restricted to the innermost enclosing namespace? Is there a specific