在C++中，一个类中可以有 public、protected、private 三种属性的成员，通过对象可以访问 public 成员，只有本类中的函数可以访问本类的 private 成员。现在，我们来介绍一种例外情况——友元（friend）。借助友元（friend），可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。

friend 的意思是朋友，或者说是好友，与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉，倾诉自己的秘密，而对一般人会谨言慎行，潜意识里就自我保护。在 C++ 中，这种友好关系可以用 friend 关键字指明，中文多译为“友元”，借助友元可以访问与其有好友关系的类中的私有成员。如果你对“友元”这个名词不习惯，可以按原文 friend 理解为朋友。
 
友元函数
 
在当前类以外定义的、不属于当前类的函数也可以在类中声明，但要在前面加 friend 关键字，这样就构成了友元函数。友元函数可以是不属于任何类的非成员函数，也可以是其他类的成员函数。

友元函数可以访问当前类中的所有成员，包括 public、protected、private 属性的。
 
1) 将非成员函数声明为友元函数。
 
请大家直接看下面的例子：
 
#include <iostream>
using namespace std;

class Student{
public:
    Student(char *name, int age, float score);
public:
    friend void show(Student *pstu);  //将show()声明为友元函数
private:
    char *m_name;
    int m_age;
    float m_score;
};

Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }

//非成员函数
void show(Student *pstu){
    cout<<pstu->m_name<<"的年龄是 "<<pstu->m_age<<"，成绩是 "<<pstu->m_score<<endl;
}

int main(){
    Student stu("小明", 15, 90.6);
    show(&stu);  //调用友元函数
    Student *pstu = new Student("李磊", 16, 80.5);
    show(pstu);  //调用友元函数

    return 0;
}

//运行结果：
//小明的年龄是 15，成绩是 90.6
//李磊的年龄是 16，成绩是 80.5
 
show() 是一个全局范围内的非成员函数，它不属于任何类，它的作用是输出学生的信息。m_name、m_age、m_score 是 Student 类的 private 成员，原则上不能通过对象访问，但在 show() 函数中又必须使用这些 private 成员，所以将 show() 声明为 Student 类的友元函数。
 

注意，友元函数不同于类的成员函数，在友元函数中不能直接访问类的成员，必须要借助对象。下面的写法是错误的：
 
 
 
void show()
{
    cout<<m_name<<"的年龄是 "<<m_age<<"，成绩是 "<<m_score<<endl;
}
 
 
 
  





成员函数在调用时会隐式地增加 this 指针，指向调用它的对象，从而使用该对象的成员；而 show() 是非成员函数，没有 this 指针，编译器不知道使用哪个对象的成员，要想明确这一点，就必须通过参数传递对象（可以直接传递对象，也可以传递对象指针或对象引用），并在访问成员时指明对象。
 
 
 
 
2) 将其他类的成员函数声明为友元函数
 
friend 函数不仅可以是全局函数（非成员函数），还可以是另外一个类的成员函数。请看下面的例子：
 
#include <iostream>
using namespace std;

class Address;  //提前声明Address类

//声明Student类
class Student{
public:
    Student(char *name, int age, float score);
public:
    void show(Address *addr);
private:
    char *m_name;
    int m_age;
    float m_score;
};

//声明Address类
class Address{
private:
    char *m_province;  //省份
    char *m_city;  //城市
    char *m_district;  //区（市区）
public:
    Address(char *province, char *city, char *district);
    //将Student类中的成员函数show()声明为友元函数
    friend void Student::show(Address *addr);
};

//实现Student类
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
void Student::show(Address *addr){
    cout<<m_name<<"的年龄是 "<<m_age<<"，成绩是 "<<m_score<<endl;
    cout<<"家庭住址："<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
}

//实现Address类
Address::Address(char *province, char *city, char *district){
    m_province = province;
    m_city = city;
    m_district = district;
}

int main(){
    Student stu("小明", 16, 95.5f);
    Address addr("陕西", "西安", "雁塔");
    stu.show(&addr);
   
    Student *pstu = new Student("李磊", 16, 80.5);
    Address *paddr = new Address("河北", "衡水", "桃城");
    pstu -> show(paddr);

    return 0;
}

//运行结果：
//小明的年龄是 16，成绩是 95.5
//家庭住址：陕西省西安市雁塔区
//李磊的年龄是 16，成绩是 80.5
//家庭住址：河北省衡水市桃城区
 

本例定义了两个类 Student 和 Address，程序第 27 行将 Student 类的成员函数 show() 声明为 Address 类的友元函数，由此，show() 就可以访问 Address 类的 private 成员变量了。

几点注意：
① 程序第 对Address 类进行了提前声明，是因为在 Address 类定义之前、在 Student 类中使用到了它，如果不提前声明，编译器会报错，提示'Address' has not been declared。类的提前声明和函数的提前声明是一个道理。

② 程序将 Student 类的声明和实现分开了，而将 Address 类的声明放在了中间，这是因为编译器从上到下编译代码，show() 函数体中用到了 Address 的成员 province、city、district，如果提前不知道 Address 的具体声明内容，就不能确定 Address 是否拥有该成员（类的声明中指明了类有哪些成员）。

③ 一个函数可以被多个类声明为友元函数，这样就可以访问多个类中的 private 成员。
 
 
 
友元类
 
不仅可以将一个函数声明为一个类的“朋友”，还可以将整个类声明为另一个类的“朋友”，这就是友元类。友元类中的所有成员函数都是另外一个类的友元函数。

例如将类 B 声明为类 A 的友元类，那么类 B 中的所有成员函数都是类 A 的友元函数，可以访问类 A 的所有成员，包括 public、protected、private 属性的。

更改上例的代码，将 Student 类声明为 Address 类的友元类：
 
#include <iostream>
using namespace std;

class Address;  //提前声明Address类

//声明Student类
class Student{
public:
    Student(char *name, int age, float score);
public:
    void show(Address *addr);
private:
    char *m_name;
    int m_age;
    float m_score;
};

//声明Address类
class Address{
public:
    Address(char *province, char *city, char *district);
public:
    //将Student类声明为Address类的友元类
    friend class Student;
private:
    char *m_province;  //省份
    char *m_city;  //城市
    char *m_district;  //区（市区）
};

//实现Student类
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
void Student::show(Address *addr){
    cout<<m_name<<"的年龄是 "<<m_age<<"，成绩是 "<<m_score<<endl;
    cout<<"家庭住址："<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
}

//实现Address类
Address::Address(char *province, char *city, char *district){
    m_province = province;
    m_city = city;
    m_district = district;
}

int main(){
    Student stu("小明", 16, 95.5f);
    Address addr("陕西", "西安", "雁塔");
    stu.show(&addr);
   
    Student *pstu = new Student("李磊", 16, 80.5);
    Address *paddr = new Address("河北", "衡水", "桃城");
    pstu -> show(paddr);

    return 0;
}
 
将 Student 类声明为 Address 类的友元类，声明语句为：
 
friend class Student;
 
有的编译器也可以不写 class 关键字，不过为了增强兼容性还是建议写上。

关于友元，有两点需要说明：
 
友元的关系是单向的而不是双向的。如果声明了类 B 是类 A 的友元类，不等于类 A 是类 B 的友元类，类 A 中的成员函数不能访问类 B 中的 private 成员。
友元的关系不能传递。如果类 B 是类 A 的友元类，类 C 是类 B 的友元类，不等于类 C 是类 A 的友元类。
除非有必要，一般不建议把整个类声明为友元类，而只将某些成员函数声明为友元函数，这样更安全一些。

本文参考：http://www.itxueyuan.org/view/100.html
 
< C++析构函数C++友元类 >
 
类的封装性实现了数据隐藏，即类的私有成员在该类的作用域之外是不可见的。但有时可能需要在类的外部访问类的私有成员，为此 C++ 提供了一种允许类外的函数或其他的类访问该类的私有成员的方法，它通过关键字 friend 把其他类或函数声明为一个类的友元。

 友元的使用就好比一个独立的个人，私有成员是个人的秘密，本来对外界是保密的，但对于好朋友却没必要隐藏，这样好朋友就可以了解个人的所有秘密。在编程中，如果模拟空调和遥控器的程序，就可以使用友元关系来处理，遥控器不是空调或空调的一部分，但可以改变空调的状态。

 本节只讲解 C++ 友元函数，C++ 友元类将在下节讲解。

 友元函数是声明在类体内的一般函数，也可以是另一个类中的成员函数。友元函数并不是这个类中的函数，但它具有这个类中成员函数所具有的访问该类所有成员的功能。接下来分两种情况讨论友元函数。
 
C++普通函数作为友元函数
 
普通函数作为友元函数，其语法格式如下：
 
friend 函数返回值类型 函数名(形式参数列表);
 

 接下来演示普通函数作为友元函数的用法，如例 1 所示。

 【例 1】
 
#include <iostream>
#include <cmath>
using namespace std;
class Point
{
public:
Point(int a = 0, int b = 0)
{
x = a;
y = b;
}
void print()
{
cout << "(" << x <<","<< y<< ")";
}
friend double Distance(Point a, Point b); //友元函数的声明
private:
int x, y;
};
double Distance(Point a, Point b) //友元函数的定义
{
int x = a.x - b.x;
int y = a.y - b.y;
return sqrt(x * x + y * y);
}
int main()
{
Point p1(3, 4), p2;
double d = Distance(p1, p2); //友元函数的调用
p1.print();
p2.print();
cout << " 距离为"<< d << endl;
return 0;
}
 
程序执行结果为：
 
(3,4)(0,0) 距离为5
 
在例 1 中，Point 类中声明了一个友元函数，它是普通函数定义在类体外。友元函数中通过指定的对象访问了类中的私有数据成员，并进行了运算。
 
C++类中的成员函数作为另一个类的友元函数
 
类中的成员函数作为另一个类的友元函数，其语法格式如下：
 
friend 类名::函数返回值类型 函数名(形式参数列表);
 

 接下来演示类中的成员函数作为另一个类的友元函数的用法，如例 2 所示。

 【例 2】
 
#include <iostream>
using namespace std;
class B; //声明B类
class A //定义A类
{
public:
A(int x = 0)
{
a = x;
}
void print()
{
cout << "A: a = " << a << endl;
}
void func(B &var);
private:
int a;
};
class B //定义 B 类
{
public:
B(int y = 0)
{
b = y;
}
void print()
{
cout << "B: b = " << b << endl;
}
friend void A::func(B &var); //将 A 类中的成员函数 func() 声明为 B 类的友元函数
private:
int b;
};
void A::func(B &var) //友元函数的定义
{
a = var.b;
}
int main()
{
A m(2);
m.print();
B y(3);
y.print();
m.func(y); //友元函数的调用
m.print();
return 0;
}
 
程序执行结果为：
 
A: a = 2
B: b = 3
A: a = 3
 
在例 2 中，第 3 行必须声明 B 类，因为只有 A 类完整定义过之后，才能定义友元的 B 类，而A类中又使用了“B”这个标识符，因此就需要使用类的声明。类的声明并不是对类的完整定义，它只是告诉编译器标识符的含义，一个只有声明的类是不能实例化的。

 在使用友元函数时，还需要注意以下几点：
 
友元函数必须在类的定义中声明；
友元函数的声明可以出现在类的任何地方，包括在 private 和 protected 部分；
C++ 不允许将某个类的构造函数、析构函数和虚函数声明为友元函数。
C++primer5th上250页说，不完全类型只能在以下情况使用（1）可以定义指向这种类型的指针或引用（2）可以声明（不能定义）以不完全类型作为参数或者返回类型的函数。
 
 
我自己写了一个程序，证明不完全类型也可以声明指向它自己类型的引用。（估计定义指向它的指针也可以），如下：
 
#include <iostream>
#include <string>
using namespace std;
class Test{
	public:
		Test() = default;
		Test(int k1,int k2):i(k1),j(k2){}
		void print()const;
		void fun(Test &t);//这里，Test还没没定义完，还是个不完全类型。结果通过编译
	private:
		int i;
		int j;
};
void Test::print()const
{
cout << i << endl;
cout << j << endl;
}
void Test::fun(Test &t)
{
   if(i > 0) {cout << "first private data's sum:" << i + t.i<< endl;}
   if(j > 0) {cout <<"second private data's sum:."<< j+ t.j << endl;}
}
int main()
{
Test t1(1,2);
Test t2(100,200);
t1.print();
t1.fun(t2);


return 0;
}
 
结论，不完全类型可以声明它的引用。

友元
 1.1为什么要使用友元函数
 在实现类之间数据共享时，减少系统开销，提高效率。如果类A中的函数要访问类B中的成员（例如：智能指针类的实现），那么类A中该函数要是类B的友元函数。
 具体来说：为了使其他类的成员函数直接访问该类的私有变量。即：允许外面的类或函数去访问类的私有变量和保护变量，从而使两个类共享同一函数。
 
实际上具体大概有下面两种情况需要使用友元函数：（1）运算符重载的某些场合需要使用友元。（2）两个类要共享数据的时候。
 
1.2使用友元函数的优缺点
 优点：能够提高效率，表达简单、清晰。
 
缺点：友元函数破环了封装机制，尽量不使用成员函数，除非不得已的情况下才使用友元函数。
 
B类中嵌A类对象，但是B的成员函数无法直接访问A的私有成员
 1.某类中嵌套了一个类，该类普通成员函数可以直接访问
 2.普通函数可以访问那个类中的数据
 实现：
 
友元函数（普通函数+其他了类的成员函数）
 
<1>friend <类型标识符> <友元函数名> （参数表）
 <2>friend <类型标识符> 类名 ::<友元函数名> （参数表）
 
简单使用，普通函数
 <1>
 
class cpoint
{
	doule x, y;
public:
	
}
 
重载运算符
 
//重载+运算符
const Integer operator+(const Integer & other) const;
const Integer operator-(const Integer & other) const;
const Integer operator*(const Integer & other) const;
const Integer operator/(const Integer & other) const;
const Integer operator%(const Integer & other) const;
//重载赋值运算符，需要const修饰函数
//num4.operator = (num3)
const Integer & operator = (const Integer & other);
//二元运算符建议采用友元得方式重载
friend const Integer operator + (int intvalue, const Integer & other)
//流运算符一般智能使用友元函数进行重载
friend ostream & operator << (ostream & out , const Integer & num);



//友元函数不需要使用域运算符了
const Integer operator +( int intvalue , const Integer & other)
{
	return Integer(intvalue + other.m_value);
}
//流运算符友元函数重载

 
继承和派生
 在C++中 代码重用通过继承机制实现
 
继承就是在一个已有类得基础上，建立一个新类
类可升级可维护
基类定义了公共得内容，方便统一修改
代码得可重用性：类库
添加新类，新成员方便
 
注意：
 
派生类对象包含了基类得数据成员，派生类继承了积累得实现
派生类对象可以使用基类得非私有函数
派生类需要自己的构造函数
派生类可以添加额外的数据成员和函数
 
1、公有继承
 
//hero.h文件
#ifndef HER0_H
#define HER0_H
#include <iostream>
#include <string>
using namespace std;
/**
  *英雄基类/父类
  */
class Hero
{
	private:
		string m_NickName;
		int m_lever;
		int m_MaxLife;
		int m_CurrLife
	public:
		Hero();
		void Move();
}
class Warrior :public Hero
{
	//战士特有的成员和函数
}
class Archmage :public Hero
{
	//法师特有的成员和函数
}
#endif //HER0_H
 
继承方式提供程序员对类进行封装的机制
 
公有继承：（无法访问基类的私有，维持基类的访问权限）
私有继承：（除了基类的私有成员，其他成员都会改为私有）
受保护继承：（无法访问基类的私有，基类的共有变为受保护）
 
不管使用哪种继承，派生类都不能访问基类的私有成员（除非改为共有成员）
 private:私有
 public:共有
 prtected:受保护的

友元函数是在类中用关键字friend修饰的非成员函数。友元函数可以是一个普通的函数，也可以是其他类的成员函数，虽然它不是本类的成员函数，但是在它的函数体中可以通过对象名访问类的私有和保护成员。
 
#include <iostream>
#include <cmath>

using namespace std;

class Point {
	private:
		int x, y;      // 私有数据成员 
	public:
		Point(int x = 0, int y = 0) : x(x), y(y){}
		
		int getX() {
			return x;
		}
		
		int getY() {
			return y;
		}
		
		friend float dist(Point &p1, Point &p2);  // 友元函数声明
}; 

float dist(Point &p1, Point &p2){
	double x = p1.x - p2.x;
	double y = p1.y - p2.y;
	return static_cast<float>(sqrt(x * x + y * y));  // static_cast是一个c++运算符，功能是把一个表达式转换为float类型。
}

int main(){
	Point *point1 = new Point(1, 1);  // 定义 Point 类的对象 
	Point *point2 = new Point(4, 5);   // 定义 Point 类的对象 
	
	cout << "两点间的距离是:";
	cout << dist(*point1, *point2) << endl;  // 计算两点间的距离 
	
	delete point2;
	delete point1;
	
	return 0;
}
 
注：友元函数不仅可以是一个普通函数，也可以是另一个类的成员函数。友元成员函数的使用和一般友元函数的使用基本相同，只是要通过相应的类或对象名来访问。
 
#include<iostream>

using namespace std;

class girl{
	private:
	    char name;
	    int age;
	    
	public:
	    girl(char n, int d){     //构造函数
	        name = n;
		    age = d;
		}
		
		friend void display(girl &x);  //声明友元函数
};

void display(girl &x){    //类外定义 友元函数
    cout << "姓名:" << x. name << "\n年龄:" << x.age << endl;
    //girl类的友元函数能访问girl类对象的私有成员
}

int main(){
    girl e('z', 18);
    display(e); //调用友元函数
	         
    return 0;
}