Friend class

[sza110]

I would like to declare Estimator class a friend of YLC2Plot class. Any ideas??
Thanks in advance.
Regards: Shabbar Abbas
i am using sun c++ 5.9 ( CC )


*********************************************/
#ifndef _ESTIMATOR_H
#define _ESTIMATOR_H

template<typename RadarType, typename FilterType>
class IMM: public RadarType, public FilterType {
public:
//....
protected:
//...
private:
//..

};

#endif
/******************************************/

#ifndef _YLC2PLOT_H
#define _YLC2PLOT_H


#include "Estimator.h"

class YLC2Plot : public BasePlot {
public:
friend IMM;

protected:
//....

private:
//.....
};


#endif /* _YLC2PLOT_H */

[TheCPUWizard]

You are doing it backwards. You have declared IMM a friend of YLC2Plot.

The Freient declaration goes into the class that you want another class to have access to, it does NOT go into the "friend" class.

So modifying the IMM class declaration to include Estimator as a friend is the solution.

[Graham]

Can unspecialised template classes even be friends? Which class are you specifying?

IMM is not a class - it's a template from which the compiler can generate classes. The only way you can make it a friend is to fully specialise all the template parameters of IMM in the friend declaration, so that you have an actual class to make friends with, not a template.

[couling]

Annoyingly friendship isn't inherited. However one workaround might be to create a YLC2Plot_Friend class declare it a friend of YLC2Plot and put a bunch of get/set methods and fuction passthoughs that access everything private. Then make the class IMM inherit from YLC2Plot_Friend.

Its not pretty, but it will give IMM and all things that inherit from it the required functionality.

[TheCPUWizard]

Can unspecialised template classes even be friends? Which class are you specifying?

IMM is not a class - it's a template from which the compiler can generate classes. The only way you can make it a friend is to fully specialise all the template parameters of IMM in the friend declaration, so that you have an actual class to make friends with, not a template.

OUCH...I missed the template...

One alternative (which I tend to use ALOT) is to derive my template classes from a non-templated base.

a) It clearly deliniates specialized from general aspects
b) It *may* reduce code size
c) You can friend other classes to the base easily...

[sza110]

thankyou all for the ideas. I finally nailed it. Thnaks again

[superbonzo]

It clearly deliniates specialized from general aspects ...
... You can friend other classes to the base easily

here you seem to restrict friendship to the general (base) type;
Is this intentional ? Then, do you use an accessor/mutator pattern as suggested by couling ?
In some sense I tend to do the opposite (as in sza110 code), i.e. I friend a "secondary" class when it needs to access inherently specific parts of a "primary" class. Is this good practice ?

[TheCPUWizard]

here you seem to restrict friendship to the general (base) type;
Is this intentional ? Then, do you use an accessor/mutator pattern as suggested by couling ?
In some sense I tend to do the opposite (as in sza110 code), i.e. I friend a "secondary" class when it needs to access inherently specific parts of a "primary" class. Is this good practice ?

As posted previously there are some issues with friending specializations. If the relationship is sich that it does not require access to the specialization itself (which is often the case) then my approach may make things cleaner.

[exterminator]

Can unspecialised template classes even be friends?

I thought they could. And in that case, all instantiations would be a friend to the class the template is declared as a friend of. The following test code compiled with Comeau online as well with VC++ 2005:

class SomeType
{
     int data;
	 public : 
		 SomeType() : data(0){}
     template<class T>
     friend struct TemplateClass;
};

template<class T>
struct TemplateClass
{
     void accessAndChangePrivate(SomeType& ref)
     {
         ref.data = 10;
     }
};

int main()
{
    TemplateClass<int> obj;
    TemplateClass<float> obj2;
    SomeType objST;
    obj.accessAndChangePrivate(objST);
    obj2.accessAndChangePrivate(objST);
}

The OP's syntax looks inappropriate though.

[TheCPUWizard]

I thought they could. And in that case, all instantiations would be a friend to the class the template is declared as a friend of. The following test code compiled with Comeau online as well with VC++ 2005[</snip>

Here you are making all of the specializations of TemplateClass friends of the non-template class SomeType.

I understand the issue to be more of the other way aound...

That is to make class X a friend of a specialized templated class. In otherwords make class X a friend of TemplateClass<int>.

[exterminator]

Here you are making all of the specializations of TemplateClass friends of the non-template class SomeType.

I understand the issue to be more of the other way aound...

I don't think so, but then I am feeling sleepy now. IMM is the class template declared as friend. So, we are talking of 'friend class templates' which is exactly what I tried to put-in in the sample code.

[TheCPUWizard]

I don't think so, but then I am feeling sleepy now. IMM is the class template declared as friend. So, we are talking of 'friend class templates' which is exactly what I tried to put-in in the sample code.

The original post contains a conflict (reversal) between the TEXT and the CODE.....

GoodNight