C++ friend 用法总结(一)

1 友元的内容

2 普通的非成员函数友元

//OpeClass.h
#pragma once
class OpeClass
{
	friend int func(const OpeClass xx);
public:
	OpeClass(void);
	OpeClass(int x,int y);
	~OpeClass(void);
private:
	int width;
	int height;
};

//OpeClass.cpp
#include "OpeClass.h"


OpeClass::OpeClass(void)
{
	width = 50;
	height = 50;
}


OpeClass::OpeClass(int x,int y):width(x),height(y)
{
}


OpeClass::~OpeClass(void)
{
}


int func(const OpeClass xx)
{
	return xx.height * xx.width;
}

//main.cpp
#include "OpeClass.h"
#include 
  
   
using namespace std;


void main()
{
	OpeClass XO;
	cout<
    
    
3 类作为友元
 类作为友元需要注意的是友元类和原始类之间的相互依赖关系，如果在友元类中定义的函数使用到了原始类的私有变量，那么就需要在友元类定义的文件中包含原始类定义的头文件。
    
 但是在原始类的定义中（包含友元类声明的那个类），就不需要包含友元类的头文件，也不需要在类定义前去声明友元类，因为友元类的声明自身就是一种声明（它指明可以在类外找到友元类），示例程序如下所示：
    
 
    
//A.h
#pragma once
#include 
     
      
using namespace std;
class A
{
	friend class B;
public:
	~A(void);
	static void func()
	{
		cout<<"This is in A"<
      
       
 
       
//A.cpp
#include "A.h"
const A A::Test = A();
A::~A(void)
{
}
       
 
       
//B.h
#pragma once
#include "C.h"
class B
{
public:
	B(void);
	~B(void);
	void func(C& c);
};
       
 
       
//B.cpp
#include "B.h"
#include "A.h"
#include "C.h"
#include 
        
         
using namespace std;


B::B(void)
{
}




B::~B(void)
{
}


void B::func(C& c)
{
	cout<<"This is in B"<
         
          
 
          
//C.h
#pragma once
class A;
class C
{
public:
	C(void);
	~C(void);
	void func(const A& a);
};
          
 
          
//C.cpp
#include "C.h"
#include 
           
            
using namespace std;

C::C(void)
{
}

C::~C(void)
{
}

void C::func(const A& a)
{
	cout<<"This is in C"<
            
             
 
             
//main.cpp
#include "A.h"
#include "B.h"
#include "C.h"
#include 
              
               
using namespace std;

void main()
{
	B b;
	C c;
	b.func(c);
	system("pause");
}
              
 
             
4 类成员函数作为友元函数
 
             
这个稍微有点复杂，因为你要类成员函数作为友元，你在声明友元的时候要用类限定符，所以必须先定义包含友元函数的类，但是在定义友元的函数时候，又必须事先定义原始类。通常的做法先定义包含友元函数的类，再定义原始类，这个顺序不能乱。(如果是友元类，则没有这种这种必须)如下面所示：
 
             






             
//B.h
#pragma once
class A;
class B
{
public:
	B(void);
	~B(void);
	int func(A xx);
};
             
 
             
//A.h
#pragma once
#include "B.h"
class A
{
friend int B::func(A xx);
public:
	A(void):mx(20),my(30){}
	~A(void){}
private:
	int mx;
	int my;
};
             
 
             
//B.cpp
#include "B.h"
#include "A.h"


B::B(void)
{
}


B::~B(void)
{
}

int B::func(A xx)
{
	return xx.mx * xx.my;
}
             
 
             
//main.cpp
#include "A.h"
#include "B.h"
#include 
              
               
using namespace std;
void main()
{
	A a;
	B b;
	cout<
               
                
 5 友元不具有相互性，只具有单项性
                
 若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
                
 
                
 
                
6 友元不能被继承
 B是A的友元类，C是B的子类，推不出C是A的友元 
                
7 友元不具有传递性
 B是A的友元，C是B的友元，推不出C是A的友元
                
 
                
8 相互为友元的类
 这个其实没什么好注意的，下面是实例，类A，类B互为友元
                
 
                
//A.h
#pragma once
class A
{
friend class B;
public:
	A(void);
	~A(void);
	int funa(B& b);
private:
	int mx;
	int my;
};

                
 
                
//A.cpp
#include "A.h"
#include "B.h"


A::A(void)
{
	mx = 10;
	my = 10;
}


A::~A(void)
{
}


int A::funa(B& b)
{
	return b.mb * b.mc;
}
                
 
                
//B.h
#pragma once
class B
{
	friend class A;
public:
	B(void);
	~B(void);
	int funb(A& a);
private:
	int mb;
	int mc;
};
                
 
                
//B.cpp
#include "B.h"
#include "A.h"


B::B(void)
{
	mb = 20;
	mc = 20;
}

B::~B(void)
{
}

int B::funb(A& a)
{
	return a.mx *a.my;
}

                
 
                
//main.cpp
#include "A.h"
#include "B.h"
#include 
                 
                  
using namespace std;
void main()
{
	A a;
	B b;
	cout<
                  
                   
 
                   
9 如果想要指定两个