Making an optional template parameter a friend?

Question

There is a post explaining that a template parameter can be declared as friend with the following syntax:

template <typename T>
class A {
   friend T;
};

but what if in some scenarios A needs a fried and in others does not? Is it possible to make T an optional argument?

Is there a better solution than using some kind of FakeClass as T?

EDIT1: I found another solution:

    class B {};

    template <typename T>
    class A {
       friend T;
    };

    template <>
    class A<void> {
    };

int main()
{
    A<B> a1;
    A<void> a2;
    return 0;
}

but what if A is a complicated class with 300 lines of code? Is there an alternative solution without template specialization?

If A is complicated you could do one more layer of abstraction. You move all the implementation in an `A_Impl` class and jusyt inherit from it in both specializations of `A` — Petok Lorand, Jul 25 '19 at 11:46

Quentin · Accepted Answer · 2019-07-25T12:04:43.907

7

I think befriending a dummy is the cleanest thing you can do, since you can't inherit or conditionally declare friends. You don't even need to create a new dummy type, since:

[class.friend§3]

If the type specifier in a friend declaration designates a (possibly cv-qualified) class type, that class is declared as a friend; otherwise, the friend declaration is ignored.

Which means that you can pretend to befriend int or even void and they'll play along just fine.

_{_{This advice is valid only within the limits of the C++ standard and is not intended as a real life guideline. The poster declines any and all responsibilities concerning the application of the advice.}}

edited Jul 25 '19 at 12:04

answered Jul 25 '19 at 11:21

Quentin

62,093
7
131
191

A is a nice solution. – Alexey Starinsky Jul 25 '19 at 11:39
2

Dummies need friends too. It's not bad advice. – StoryTeller - Unslander Monica Jul 25 '19 at 11:53

Zang MingJie · Answer 2 · 2019-07-25T11:43:17.173

Try this

template<typename... T>
class A {
    private:
        static const int i = 10;
    public:
        friend typename std::conditional<sizeof...(T) == 1, T..., void>::type;
};

class X {
    public:
        static const int a = A<X>::i;
};

class Y {
    public:
        static const int a = A<>::i; // error, A::i is private                                                                                                                                                 
};

Making an optional template parameter a friend?

2 Answers2