C++ 友元（系转载多人博客，添加个人见解）

原文地址：http://blog.csdn.net/caroline_wendy/article/details/16916441

原文地址：http://www.cnblogs.com/CBDoctor/archive/2012/02/04/2337733.html

---

一、友元

友元是指：

采用类的机制后实现了数据的隐藏与封装，类的数据成员一般定义为私有成员，成员函数一般定义为公有的，依此提供类与外界间的通信接口。但是，有时需要定义一些函数，这些函数不是类的一部分（注意友元函数不是类的一部分），但又需要频繁地访问类的数据成员，这时可以将这些函数定义为该函数的友元函数。除了友元函数外，还有友元类，两者统称为友元。友元的作用是提高了程序的运行效率（即减少了类型检查和安全性检查等都需要时间开销），但它破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。

class  Data{

public:

...

friend  int set(int &m);//友元函数friend  class peop;     //友元类

...

}

友元分为友元函数和友元类，两种具有不同的调用形式：

A 友元函数：

友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以

声明，声明时只需在友元的名称前加上关键字friend，其格式如下：

friend  类型 函数名(形式参数);

1.友元函数的声明可以放在类的私有部分，也可以放在公有部分，它们是没有区别的，都说明是该类的一个友元函数。

2.一个函数可以是多个类的友元函数，只需要在各个类中分别声明。友元函数的调用与一般函数的调用方式和原理一致。

B 友元类

友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。

例如，以下语句说明类B是类A的友元类：

class A{

 …

public:

 friend class B;

…

};

经过以上说明后，类B的所有成员函数都是类A的友元函数，能存取类A的私有成员和保护成员。

使用友元类时注意：

(1) 友元关系不能被继承。

 

(2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。

(3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明

(4) 友元函数并不是类的成员函数，因此在类外定义的时候不能加上class::function name

下面我们完整的看一个友元的例子：

#include
　　#include
     class Point//声明
　　{
　　public:
　　　　Point(double xx, double yy) { x=xx; y=yy; }//默认构造函数
　　　　void Getxy();//公有成员函数
　　　　friend double Distance(Point &a, Point &b);//友元函数
　　private:
　　　　double x, y;
　　};
 
　　void Point::Getxy()
　　{
　　cout<<"("<
　　}
 
　　double Distance(Point &a, Point &b)  //注意函数名前未加类声明符，因为不是类的成员函数
　　{
　　double dx = a.x - b.x;
　　double dy = a.y - b.y;
　　return sqrt(dx*dx+dy*dy);
　　}
 
　　void main()
　　{
　　Point p1(3.0, 4.0), p2(6.0, 8.0);
　　p1.Getxy();
　　p2.Getxy();
　　double d = Distance(p1, p2);
　　cout<<"Distance is"<
　　}

---

二、类模板友元的六种形式及代码

类模板(class template)的友元(friend)和普通类的友元, 有很多区别,

主要原因是类模板包含模板参数(template parameter), 就会导致友元和类模板有很多匹配形式;

主要包含六种形式:

1. 类 - 友元(friend): "模板参数是当前类"的类模板;

2. 类 - 友元: "模板参数任意"的模板类;

3. 模板类 - 友元: "模板参数相同"的模板类;

4. 模板类 - 友元: "模板参数任意"的模板类

5. 模板类 - 友元: 类;

6. 模板类 - 友元: 当前模板参数(类); (C++11)

具体使用参见代码及注释,

代码如下:

/*
 * cppprimer.cpp
 *
 *  Created on: 2013.11.24
 *      Author: Caroline
 */
 
/*eclipse cdt, gcc 4.8.1*/
 
#include <iostream>
#include <string>
 
template <typename T> class Pal; //pal朋友，这里是先进行声明，后续再进行定义。
 
class C {
    friend class Pal<C>; //"以类C实例化"的Pal类, 为C的友元 //第一种情况 普通类，友元："模板参数是当前类"的类模板;
    template <typename T> friend class Pal2; //Pal2类的所有实例化, 都为C的友元 //第二种情况，普通类，友元: "模板参数任意"的模板类;
private:
    void print() { std::cout << "class C" << std::endl; }
};
 
template <typename T>
class C2 {
    friend class Pal<T>; //"与C2类相同实例化"的Pal类, 为C2的友元 //第三种情况，模板类，友元：模板参数相同的模板类
    //Pal2类的所有实例化, 都为C2的友元, 注意模板参数(X)不能相同
    template <typename X> friend class Pal2; //第四种情况，模板参数任意 //第四种情况，模板类，友元：模板参数任意的模板类
    friend class Pal3; //普通友元 //第五种情况，模板类，友元：普通类
    friend T; //C++11 模板类型参数友元 //第六种情况，模板类，友元：当前模板的参数（参数也是一个类）
private:
    void print() { std::cout << "class C2" << std::endl; }
};
 
template <typename T> //前述进行声明以后，这里就可以开始定义了。
class Pal {
    C myC;
    C2<T> myC2; //必须为T
    //C2<double> myC2; //实例化不同, 无法使用，因为前述定义友元类时，已经声明了，Pal想访问C2类，就必须和C2类的模板参数相同。经过实际实验验证，如果使用该句话，编译都无法通过，因为会说你无法调用print函数。报错位置就是下面的myC2.print函数。
public:
    void printC() {
        std::cout << "this is class Pal : ";
        myC.print();
    }
    void printC2() {
        std::cout << "this is class Pal : ";
        myC2.print();
    }
};
 
template <typename T>
class Pal2 {
    C myC;
    C2<double> myC2;
public:
    void printC() {
        std::cout << "this is class Pal2 : ";
        myC.print();
    }
    void printC2() {
        std::cout << "this is class Pal2 : ";
        myC2.print();
    }
};
 
class Pal3 {
    C2<double> myC2;
public:
    void printC2() {
        std::cout << "this is class Pal3 : ";
        myC2.print();
    }
};
 
class Pal4 {
    C2<Pal4> myC2; //注意Pal4是C2类的模板参数 //这种情况比较特殊，定义的是用Pal4作为模板参数实例化的C2类的对象myC2，同时在C2类中声明了其模板参数作为一个类时，也可以是友元类，即friend class T。所以，这里Pal4可以访问myC2中的内容。
public:
    void printC2() {
        std::cout << "this is class Pal4 : ";
        myC2.print();
    }
};
 
int main (void) {
 
    std::cout << "Hello Mystra!" << std::endl;
 
    Pal<C> pc; //Pal类必须实例化为C
    pc.printC(); //可以使用
    //Pal<int> pci;//你可以如此定义pci，即其内部的成员是C myC，但是无法使用。因为C的友元类时Pal<C>类型，而不是Pal<int>类型。
    //pci.print(); //报错, 访问了私有成员
 
    Pal2<int> pi2; //Pal2类可以随意实例化
    pi2.printC();
 
    Pal<int> pi; //有相同的示例化, 在类声明C2<T>//你可以如此定义pi，即其内部的成员是C myC，同时C2<int> myC2.而前述在C2中声明友元类的时候使用的是，使用的是friend class pal<T>，即模板参数相同。显然，这里是相同的。
    pi.printC2();
 
    pi2.printC2(); //注意, Pal2类被实例化为<int>, 内部C2类被实例化为<double>; //pi2内部的成员是：C2<double>myC2，而前述在C2中声明Pal2友元类的时候，使用的是第四种情况，即模板任意参数，这里的类示例是Pal2<int>pi2。所以，也是可以访问的。
 
    Pal3 p3;
    p3.printC2();
 
    Pal4 p4;
    p4.printC2();
 
    return ;
}

---

为什么要在include后

template <typename T> class Pal; //pal朋友，这里是先进行声明，后续再进行定义。

但是没有对Pal等提前进行声明。

这是因为，在class C中，我们对Pal进行了实例化，所以先在Class C之前进行了声明。而反观在class C中，我们是使用如下语句进行对Pal2和Pal3直接进行了声明的。

为什么这样？就是声明必须在使用前。然后定义可以放在稍后的位置。

template <typename T> friend class Pal2; 
friend class Pal3;

输出:

总结：

一、友元类的声明方式和使用方式必须一致。

二、即使一个类A不是另一个类B的友元类，但是我们在类A中可以定义类B的实例化对象，只不过不能访问其数据成员而已，一旦访问就会报错。

比如上述例子中的，

    //Pal<int> pci;//你可以如此定义pci，即其内部的成员是C myC，但是无法使用。因为C的友元类时Pal<C>类型，而不是Pal<int>类型。
    //pci.print(); //报错, 访问了私有成员
对于这个例子，声明友元类的时候，要求Pal类必须用C实例化后的类对象，才能访问C的数据成员。
定义的时候，直接定义的是C myC。所以，定义可以这样定义，但是与声明的使用方式不一致（没有用C实例化，而是用int实例化），所以会报错。