Making a template parameter a friend?

Question

Example:

template<class T>
class Base {
public:
    Base();
    friend class T;
};

Now this doesn't work... Is there a way of doing this?

I'm actually trying to make a general class sealer like this:

class ClassSealer {
private:
   friend class Sealed;
   ClassSealer() {}
};
class Sealed : private virtual ClassSealer
{ 
   // ...
};
class FailsToDerive : public Sealed
{
   // Cannot be instantiated
};

I found this example on this site somewhere but I can't find it... (here)

I know there are other ways of doing this but just now I'm curious if you actually can do something like this.

David Rodríguez - dribeas · Accepted Answer · 2012-05-07T21:52:35.763

It is explicitly disallowed in the standard, even if some versions of VisualStudio do allow it.

C++ Standard 7.1.5.3 Elaborated type specifiers, paragraph 2

3.4.4 describes how name lookup proceeds for the identifier in an elaborated-type-specifier. If the identifier resolves to a class-name or enum-name, the elaborated-type-specifier introduces it into the declaration the same way a simple-type-specifier introduces its type-name. If the identifier resolves to a typedef-name or a template type-parameter, the elaborated-type-specifier is ill-formed. [Note: this implies that, within a class template with a template type-parameter T, the declaration friend class T; is ill-formed. ]

I recognize the code above as a pattern to seal (disallow the extension of) a class. There is another solution, that does not really block the extension but that will flag unadvertidly extending from the class. As seen in ADOBE Source Library:

namespace adobe { namespace implementation {
template <class T>
class final
{
protected:
   final() {}
};
}}
#define ADOBE_FINAL( X ) private virtual adobe::implementation::final<T>

with the usage:

class Sealed : ADOBE_FINAL( Sealed )
{//...
};

While it allows extension if you really force it:

class SealBreaker : public Sealed, ADOBE_FINAL( Sealed )
{
public:
   SealBreaker() : adobe::implementation::final<Sealed>(), Sealed() {}
};

It will restrict users from mistakenly do it.

EDIT:

The upcoming C++11 standard does allow you to befriend a type argument with a slightly different syntax:

template <typename T>
class A {
   // friend class T; // still incorrect: elaborate type specifier
   friend T;          // correct: simple specifier, note lack of "class"
};

...then again, C++11 allows for the keyword "final", for example: class X final{...} (or you can make individual virtual functions final). In any case, I've tried the code above ("friend T;") with g++ 4.8.4 _without_ the -std=c++11 flag and it compiles fine. — blue scorpion, May 26 '17 at 19:02
As of 2023 your addendum "The upcoming C++11 standard does allow..." should come first in your answer IMHO. It's easily overlooked otherwise. — Elmar Zander, Feb 21 '23 at 21:57

score 22 · Answer 2 · edited Apr 10 '11 at 00:36

22

I found a simple trick to declare template parameters as friends:

template < typename T>
struct type_wrapper 
{ 
   typedef T type; 
}; 


template < typename T> class foo 
{ 
  friend class type_wrapper < T>::type 
};   // type_wrapper< T>::type == T

However I do not know how this could help to define an alternative version of a class sealer.

edited Apr 10 '11 at 00:36

sarnold

102,305
22
181
238

answered Apr 09 '11 at 23:04

A Milton

221
2
3

Any idea how standard-conforming this is? Works great though, thanks for the tip! – zennehoy Jun 16 '12 at 22:22
Looks pretty standard-conforming to me, but I'm no standard guru. Nice find! – onitake Jul 26 '12 at 15:56
4

Not quite...clang gives me below error: error: elaborated type refers to a typedef friend class TypeWrapper::type; – Viren May 26 '13 at 03:40

score 1 · Answer 3 · answered Mar 31 '09 at 19:30

1

Do you really need to do this? If you want to prevent someone from deriving from your class, just add a comment and make the destructor non-virtual.

answered Mar 31 '09 at 19:30

rlbond

65,341
56
178
228

:) Sometimes the best technical answer is not technical at all. – David Rodríguez - dribeas Mar 31 '09 at 20:11
2

Sure, but it's better if illegal usage can be flagged at compile time, is it not? It's the same principle as using an assert() instead of a comment -- wouldn't you agree that assert() is useful? – j_random_hacker Apr 01 '09 at 04:27
2

Sometimes you just can't make the destructor non-virtual, because it might have a base class where the destructor is virtual. – Armen Tsirunyan Oct 12 '10 at 20:14

Making a template parameter a friend?

3 Answers3

Linked

Related