C++ friend 用法總結
C++中的友元機制允許類的非公有成員被一個類或者函數訪問，友元按類型分為三種：普通非類成員函數作為友元,類的成員函數作為友元，類作為友元。
1 友元的內容
友元包括友元的聲明以及友元的定義。友元的聲明默認為了extern，就是說友元類或者友元函數的作用域已經擴展到了包含該類定義的作用域，所以即便我們在類的內部定義友元函數也是沒有關系的。
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 如果想要指定兩個類都有成員函數作為對方的友元，那麼必須第2個類是第一個類的友元
//A.h
#pragma once
// class B is a friend class of A
class A
{
friend class B;
public:
A(void):ma(10),mb(20){}
~A(void){}
int funa(B& b);
private:
int ma;
int mb;
};
//B.h
#pragma once
#include "A.h"
// A's function funa is a friend function of B
class B
{
friend int A::funa(B& b);
public:
B(void);
~B(void);
int funb(A& a);
int func(A& a);
private:
int mx;
int my;
};
//A.cpp
#include "A.h"
#include "B.h"
int A::funa(B& b)
{
return b.mx * b.my;
}
//B.cpp
#include "B.h"
B::B(void):mx(12),my(15)
{
}
B::~B(void)
{
}
int B::funb(A& a)
{
return a.ma + a.mb;
}
int B::func(A& a)
{
return a.ma * a.mb;
}
//main.cpp
#include "A.h"
#include "B.h"
#include
using namespace std;
void main()
{
A a;
B b;
cout<
