C++26: variadic friends

crtp.cpp

// The base class
template<class Crtp, class MsgT>
class Receiver { 
  void receive(MsgT) {
    static_cast<Crtp*>(this)->private_ += 1;
  }
};


// The derived class
template<class MsgT>
struct Dispatcher :
  public Receiver<Dispatcher<MsgT>, MsgT>
{
  //_private member exposed to the base class, called Receiver
  using Receiver<Dispatcher, MsgT>::Receiver;
  friend Receiver<Dispatcher, MsgT>;

private:
  int private_;
};

crtp_variadic_friends.cpp

// The base class
template<class Crtp, class MsgT>
class Receiver {
  void receive(MsgT) {
    static_cast<Crtp*>(this)->private_ += 1;
  }
};

// The derived class
template<class... MsgTs> // notice the variadic template parameters
struct Dispatcher :
  public Receiver<Dispatcher<MsgTs...>, MsgTs>... // Inheritance supports pack expansion
{
  using Receiver<Dispatcher, MsgTs>::Receiver...;  // The using directive support pack expansion
  friend Receiver<Dispatcher, MsgTs>...; // Error pre-C++26, accepted from C++26

private:
  int private_;
};

pack_of_friends.cpp

// https://www.sandordargo.com/blog/2025/04/02/cpp26-variadic-friends

template<class T=void,
         class U=void>
class Foo {
  friend T;
  friend U;
};

template<class... Ts>
class Foo {
  friend Ts...;
};

passkey_idiom.cpp

template<class T>
class Passkey {
  friend T;
  Passkey() = default; // note that this ctor is private!
};

class A;
class B;

class C {
  friend A;
private:
  void internal();
public:
  void intentionalA(Passkey<A>);
  void intentionalB(Passkey<B>);
};

class A {
  void m(C& c) {
    c.internal(); // OK
    c.intentionalA({}); // OK
    c.intentionalB({}); // Error, Passkey<B>'s constructor is inaccessible
  }
};

class B {
  void m(C& c) {
    c.intentionalB({}); // OK
  }
};

passkey_idiom_variadic_friends.cpp

template<class... T>
class Passkey {
  friend T...;
  Passkey() {}
};

class A;
class B;

class C {
  friend A;
private:
  void internal();
public:
  void intentional(Passkey<A, B>);
};

class A {
  void m(C& c) {
    c.internal(); // OK
    c.intentional({}); // OK
  }
};

class B {
  void m(C& c) {
    c.intentional({}); // OK
  }
};