How do I make a template parameter's constructor a friend?

Question

In C++11, they made it possible to friend a template parameter simply with friend T. You can also friend methods within that parameter with friend T::Method().

However, how do you friend a template parameter's constructor?

class BeMyFriend
{
public:
 BeMyFriend& operator=(const BeMyFriend& rhs) = default;
 BeMyFriend(const BeMyFriend& rhs) = default;
};

template<class T>
class Test
{
 friend T& T::operator=(const T&); //Works fine, no error
 friend T::T(const T&); //error: prototype for 'BeMyFriend::BeMyFriend(const BeMyFriend&)' does not match any in class 'BeMyFriend'
};

int main()
{
 Test<BeMyFriend> hmm;

 return 0;
}

I'm able to friend the template parameter's operator= just fine, but I'm unable to friend T::T(const T&).

How can I make friend T::T(const T&); work?

---

edit: This appears to be a different issue than what is solved in Make Friend the constructor of a template class. The issue there is dealing with circular template parameters in a declaration. It doesn't deal with the constructor of an actual template parameter.

The type of the Foo is a normal templated class, not a template parameter like T in my example. Something like friend Foo<B>::Foo<B>() from that submission should compile just fine, unlike the issue I'm having here with friend T::T(const T&).

edit: In case this ends up mattering, I'm compiling with gcc 7.2.

edit: I also want to clarify that C++ does support making constructors friends. For example, friend X::X(char), X::~X(); in the first example at http://en.cppreference.com/w/cpp/language/friend.

The issue here is how to make a template parameter's constructor a friend.

Answer 1

Somehow I think T::T(const T&) isn't well parsed by the compiler because it doesn't consider the namespace T:: before the member constructor T() as a reference to some external class, obviously seen in error console ISO C++ forbids declaration of ‘T’ with no type and prototype for ‘BeMyFriend::BeMyFriend(const BeMyFriend&)’ does not match any in class ‘BeMyFriend’ where the compiler is blatantly trying to get any definition or declaration exported from outside the class, thus T:: should be forced by the user to get introduced to the compiler referenced to the befriended class like so T&:: this is sufficient to remove ambiguity.

You can check here that the instantiator "works" perfectly and the value is properly befriended.

If, neverthless, you see in this example the error shown std::__cxx11::string Test<BeMyFriend>::mything’ is private within this context areyoumyfriend.mything; depicts the status of violation access to a private value, this is because the member function is not befriended to the host class simply.

Answer 2

I think the C++ standard prohibits what you are trying to do. Maybe it's a defect/oversight; maybe it was intentional. I'm not sure, so I'll just lay out the pieces I found in the standard (it's safe to skim over the section numbers unless/until someone is checking my analysis):

1. In 6.4.3.1.2, there is a description of when something is considered to name a constructor. This involves the "injected-class-name" which (according to 12.2) means the name of the class inserted into the class' scope. In your context, I read these sections as saying that to name the constructor, you need T:: followed by the class-name of T. You have T::T, which works if T is considered the class-name of T. Let's see how this plays out.

2. In 15.1.1, it is stated that your friend declaration would need to name a constructor. It goes on to say that the class-name shall not be a typedef-name. So we should be fine as long as T is not a typedef-name.

3. In 17.1.3, it is stated that in your class Test, the identifier T is a typedef-name. Uh-oh.

So it's kind of weird. If I'm reading things correctly, you would need to use friend T::BeMyFriend to name the constructor, which of course only works in this one particular example. For other template parameters, this would look for a member function named "BeMyFriend". Not what you are looking for.

(You might notice that in the examples of constructors declared as friends, the class name being used is always the name used when defining the class. In that situation, there is no typedef'ing going on, so this issue does not arise.)

Solution? I think you need to make the class T a friend, make a static function in T a friend and call that from the constructor, or find a (better?) way to do what you want to do without using friends. There is a warning flag waving in the back of my mind when I see a template parameter made a friend -- it's legal, but often goes against the principles of encapsulation.

Answer 3

Constructors are very special methods. They have no return type (not even void) and no real name. AFAIK that just cannot be used in friend declaration.

A possible workaround is to build a copy factory function in class BeMyFriend:

class BeMyFriend
{
public:
 BeMyFriend& operator=(const BeMyFriend& rhs) = default;
 BeMyFriend(const BeMyFriend& rhs) = default;
 static BeMyFriend makeCopy(const BeMyFriend& rhs) {
    BeMyFriend tmp(rhs);
    return tmp;
 }
};

template<class T>
class Test
{
 friend T& T::operator=(const T&); //Works fine, no error
 //friend T::T(const T&); //error: prototype for 'BeMyFriend::BeMyFriend(const BeMyFriend&)' does not match any in class 'BeMyFriend'
 friend T T::makeCopy(const T&);
};

int main()
{
 Test<BeMyFriend> hmm;

 return 0;
}

This does not really answer your question because a default copy construction would not be friend, but in the followin code:

BeMyFriend foo;
BeMyFriend bar = BeMyFriend::makeCopy(foo);

you get a friend copy contruction inside makeCopy, and next one is likely to be elided.

Anyway I cannot really imagine a real use case for friending only a specific constructor from a class and not the whode class...

Answer 4

I was able to get it to compile in GCC by adding void after friend:

friend void T::T(const T&);

I was then able to access one of Test's private members from BeMyFriend's constructor. However, note that this is compiler specific. I tried it in clang, and it did not work.