объявляя набор функций-членов, как друг, используя шаблон

Question

Учитывая следующий код:

class A; 

struct B { 
    static void doIt(A* pa); 
}; 

struct C { 
    static void doIt(A* pa); 
}; 

class A { 
    int i = 9; 
    // below works but requires a line per each type 
    friend void B::doIt(A* pa); 
    friend void C::doIt(A* pa); 

    // the below however doesn't work 
    // template<typename T> 
    // friend void T::doIt(A* pa); 
     // (gcc error: member 'void T::doIt(A*)' declared as friend before type 'T' defined) 
     // (clang just ignores the above and the error is on accessing A::i in B and C)  
}; 

void B::doIt(A* pa) { 
    cout << pa->i << endl; 
} 

void C::doIt(A* pa) { 
    cout << pa->i *2 << endl; 
} 

int main() { 
    A a; 
    B::doIt(&a); 
    C::doIt(&a); 
} 

Можно ли заменить многократные friend декларации, чтобы все void T::doIt(A* pa) методов доступа к закрытым членам A?

Попытка создать экземпляр B и C выше A не помогает.

Answer 1

Я не вижу прямой путь, но одна работа вокруг может быть объявляя один класс с несколькими статическими методами (вместо нескольких классов с одним статическим методом), а затем объявляющего этого класса, как друга, как:

... 
struct D { 
    static void doItB(A* pa); 
    static void doItC(A* pa); 
}; 

class A { 
... 
    friend struct D; 
... 
}; 

void D::doItB(A* pa) { 
    cout << pa->i << endl; 
} 

... 
    D::doItB(&a); 
    D::doItC(&a); 
... 

Answer 2

Не совсем то, что вы просили, но ... если вы плачете шаблоны B, C и т. Д., Вы можете получить что-то подобное.

#include <iostream> 

class A; 

template <std::size_t> 
struct X 
{ static void doIt(A* pa); }; 

class A 
{ 
    int i = 9; 

    template <std::size_t I> 
    friend void X<I>::doIt (A* pa); 
}; 

template <> 
void X<0U>::doIt(A* pa) 
{ std::cout << pa->i << std::endl; } 

template <> 
void X<1U>::doIt(A* pa) 
{ std::cout << pa->i * 2 << std::endl; } 

template <> 
void X<2U>::doIt(A* pa) 
{ std::cout << pa->i * 3 << std::endl; } 

using B = X<0U>; 
using C = X<1U>; 
using D = X<2U>; 

int main() { 
    A a; 
    B::doIt(&a); 
    C::doIt(&a); 
    D::doIt(&a); 
} 

Answer 3

Я считаю, что что-то похожее на то, что вы желаете, может быть выполнено с использованием CRTP и частного/защищенного виртуального наследования. Нижеприведенный код является только демонстрацией и определенно нуждается в некоторой работе, например. чтобы не привлекать метод шаблона дружбы:

#include <iostream> 

using namespace std; 

class base { 
protected: 
    int i = 9; 
}; 

template <class F> 
class crtp_base: virtual base { // private inheritance! 
    template <class T> 
    friend void F::doIt(T*); 
}; 

template <class... AllF> 
struct crtp_bases: crtp_base<AllF>... { }; 

struct B { 
    template <class T> 
    static void doIt(T* pa); 
}; 

struct C { 
    template <class T> 
    static void doIt(T* pa); 
}; 

class A: public crtp_bases<B, C> { 
}; 

template <class T> 
void B::doIt(T* pa) { 
    cout << pa->i << endl; 
} 

template <class T> 
void C::doIt(T* pa) { 
    cout << pa->i * 2 << endl; 
} 

int main() { 
    A a; 
    B::doIt(&a); 
    //cout << a.i << endl; // error i is private member of 'base' 
} 

[live demo]