mixing bound and unbound friends

[Christof Warlich]

Hi,

I need to make a templated class A a friend of class B.
My problem: I think I know how to do this for both

1) _one_ specific template instantiation of class A, e.g.:

template<typena me Type, unsigned int xclass A {
public:
void useSomeFunction alityOfB(void);
};
class B {
friend class A<float, 7>;
};

2) _any_ instantiation of class A, e.g.:

template<typena me Type, unsigned int xclass A {
public:
void useSomeFunction alityOfB(void);
};
class B {
template<typena me Type, unsigned int xfriend class A;
};

But I do _not_ know how to mix the two extremes, e.g.
how to make class A a friend of class B only for Type float,
but for any unsigned int x.

Is it possible to express this at all, and if so, how?

Thanks for any help,

Christof

[Ondra Holub]

On 23 ec, 13:32, Christof Warlich <cwarl...@gmx.d ewrote:

Hi,

I need to make a templated class A a friend of class B.
My problem: I think I know how to do this for both

1) _one_ specific template instantiation of class A, e.g.:

template<typena me Type, unsigned int xclass A {
public:
void useSomeFunction alityOfB(void); };

class B {
friend class A<float, 7>;

};

2) _any_ instantiation of class A, e.g.:

template<typena me Type, unsigned int xclass A {
public:
void useSomeFunction alityOfB(void); };

class B {
template<typena me Type, unsigned int xfriend class A;

};

But I do _not_ know how to mix the two extremes, e.g.
how to make class A a friend of class B only for Type float,
but for any unsigned int x.

Is it possible to express this at all, and if so, how?

Thanks for any help,

Christof

Hi Christof.

You can define intermediate access class which is templated only with
one parameter:

#include <iostream>

template<typena me Tstruct AccessB;

class B {
friend struct AccessB<float>; // Make only AccessB<floatfr iend

private:
static void MethodOfB() { std::cout << "B::MethodOfB() \n"; }
};

template<typena me Tstruct AccessB {
static void useSomeFunction alityOfB()
{
B::MethodOfB();
}
};

template<typena me Type, unsigned int xclass A {
public:
A() { }

void useSomeFunction alityOfB()
{
// This will compile only when Type is float
AccessB<Type>:: useSomeFunction alityOfB();
}
};

int main()
{
// This is OK
A<float, 10af10;
af10.useSomeFun ctionalityOfB() ;

// The following will not compile
// A<double, 10ad10;
// ad10.useSomeFun ctionalityOfB() ;
}

If you uncomment last 2 lines in main(), you will get compile error,
because you will be trying to access private member of B. It is a bit
obscure, but maybe it could help you.

[Ondra Holub]

On 23 ec, 14:07, Ondra Holub <ondra.ho...@po st.czwrote:

Hi Christof.

You can define intermediate access class which is templated only with
one parameter

However this way you will provide a "backdoor" to class B - anyone may
use AccessB to access private method of B.

[Christof Warlich]

Ondra Holub schrieb:

On 23 ec, 14:07, Ondra Holub <ondra.ho...@po st.czwrote:

>Hi Christof.

You can define intermediate access class which is templated only with
one parameter

However this way you will provide a "backdoor" to class B - anyone may
use AccessB to access private method of B.

Hi Ondra,

thanks, good idea. However, quite some effort to just restrict access
to its minimum. Thus, if there is no direct way to express this, I'll
probably just go the unbound friend approach, accepting that access is
not as much restricted as it could.

Cheers,

Christof

[Ondra Holub]

I have another idea:

You can define templated method in B, which takes as parameter Type:

class B
{
template<typena me T>
static void Method()
{
// Here should be some static assertion
// ...
}
};

Specialize Method() only for template parameter float:

template<>
void AAA::Method<flo at>()
{
// Do what you need
// ...
}

For all types but float it should stop compilation on static assertion
(which has to be searched on web, I do not remember, how is it made).
But for float there is another specialization, so it will not stop on
static assert.