C++学习笔记（四）：类与对象--友元与继承

友元函数

类的友元函数一般定义在类外部，可以是定义在全局的函数，也可以是其他类的成员函数，但他们有权访问类的所有私有（private）成员和保护（protected）成员。
尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

• 友元定义在全局的函数

//类声明
class example_A
{
private:            //私有成员
    int a;          //成员
    int b;          //成员
    friend void Frend_A(example_A* p);//声明友元函数（不作为其成员函数）
public:             //公有成员
    example_A(int x , int y);    //构造函数
    ~example_A();   //析构函数
protected:          //保护成员
};
//函数声明
void Frend_A(example_A *p);	//此处注意，函数声明必须放在类定义声明之后
//函数定义
void Frend_A(example_A* p)
{
    int c = p->a + p->b;    //a,b作为私有成员正常的外部函数是不可以直接调用的
    cout << c << endl;
}

• 友元其他类的成员函数

class example_A
{
private:            //私有成员
    int a;          //成员
    int b;          //成员
    friend void example_B::see_b(example_A* p);//声明友元函数
public:             //公有成员
    example_A(int x , int y);    //构造函数
    ~example_A();   //析构函数
protected:          //保护成员
};
class example_B
{
private:            //私有成员
    int x;          //成员
public:             //公有成员
    void see_b(example_A *p) 
    {
        int c = (p->a) + (p->b);    //a,b作为私有成员正常的其他类的函数是不可以直接调用的
        cout << c << endl;
    }
    example_B(int y) :x(y) { }    //构造函数
    ~example_B();   //析构函数
protected:          //保护成员
};

友元类

同理下的友元类，A与B是两个不同的类，类 A 可以将类 B 声明为自己的友元，类 B 的所有成员函数就都可以获得访问类 A 对象的私有成员的权限。

• 将刚写过的友元其他类的成员稍作修改得到友元类

class example_A
{
private:            //私有成员
    int a;          //成员
    int b;          //成员
    friend class example_B;//声明友元类
public:             //公有成员
    example_A(int x , int y);    //构造函数
    ~example_A();   //析构函数
protected:          //保护成员
};
class example_B
{
private:            //私有成员
    int x;          //成员
public:             //公有成员
    void see_b(example_A *p) 
    {
        int c = (p->a) + (p->b);    //a,b作为私有成员正常的其他类的成员函数是不可以直接调用的
        cout << c << endl;
    }
    example_B(int y) :x(y) { }    //构造函数
    ~example_B();   //析构函数
protected:          //保护成员
};

友元的优缺点

• 优点：
  使用友元后，因为友元对象可以直接调用类里的私有函数，从而可以提高调用的效率，使语句表达显得简单、清晰。友元一般使用在运算符重载的某些场合下（后续运算符重载中会讲），还可以用在两个需要共享数据的类之间。
• 缺点：
  友元一种破坏数据封装和数据隐藏的机制。建议尽量不使用或少使用友元，除非不得已的情况下才使用友元函数。

友元还有一个注意点就是，如果A->B友元，B->C友元，A和C并不是友元，C++中朋友的朋友不会是朋友。

继承

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，他允许程序员在保持原有类的特性上进行功能拓展，还不会对原有类产生影响，同时达到了重用代码功能和提高执行效率的效果。

基类 ——派生类

在我们对一个类进行继承时候，作为依据的这个已有的类称为基类，同时依据基类产生的新的的类称为派生类。通常我们称基类为父类，派生类为子类。

class example_A
{
private:            //私有成员
    int a;          //成员
    int b;          //成员
public:             //公有成员
    example_A(int x , int y);    //构造函数
    ~example_A();   //析构函数
protected:          //保护成员
};
class example_B : public example_A//继承
{
private:            //私有成员
    int x;          //成员
public:             //公有成员
    example_B(int y) :x(y) { }    //构造函数
    ~example_B();   //析构函数
};

继承类型及继承访问限制

任何继承下，保护成员都是不可继承的，就像继承家产时，父亲的不部分物品属于他私人的，不可继承给孩子一样
公有继承（public）： 子类可以继承父类的公有成员和私有成员，父类的公有成员/私有成员在子类中依旧以公有成员/私有成员存在，也就是说，依旧需要成员函数才能做到对父类继承过来的私有成员的访问。
**保护继承（protected）：**父类的公有成员和私有成员都被以公有成员的形式继承到子类中去。
**私有继承（private）：**同理于保护继承，父类的公有私有成员都以私有成员的形式，存在于子类中；

• 用代码形式展现

class example_A
{
private:            //私有成员
    int a;          //成员变量
    int b;          //成员变量
public:             //公有成员
    char c;			//成员变量
    example_A(int x , int y);    //构造函数
    ~example_A();   //析构函数
protected:          //保护成员
    float l;
};
class example_B : public example_A//公有继承
{
public:
    example_B();    //构造函数
    ~example_B();   //析构函数
};
class example_C : protected example_A//保护继承
{
public:             //公有成员
	example_C();   	//构造函数
    ~example_C();   //析构函数
};
class example_D :private example_A//私有继承
{
public:             //公有成员
    example_D();   //构造函数
    ~example_D();   //析构函数
};

• 公有继承后的example_B相当于

class example_B : 
{
private:            //私有成员
    int a;          //成员变量
    int b;          //成员变量
public:             //公有成员
    char c;			//成员变量
    example_B();    //构造函数
    ~example_B();   //析构函数
};

• 保护继承后的example_C相当于

class example_C :
{
public:             //公有成员
	int a;          //成员变量
    int b;          //成员变量
	char c;			//成员变量
	example_C();   	//构造函数
    ~example_C();   //析构函数
};

• 私有继承后的example_D相当于

class example_D :
{
private:            //私有成员
    int a;          //成员变量
    int b;          //成员变量
    char c;			//成员变量
public:             //公有成员
    example_D();   //构造函数
    ~example_D();   //析构函数
};

多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。（就是一个儿子可以有很多爸爸）

class example_A 
{
   public:
      void Width(int w)
      {
         width = w;
      }
      void Height(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 基类 PaintCost
class example_B 
{
   public:
      int getC(int area)
      {
         return area * 70;
      }
};
 
// 派生类
class example_C: public example_A, protected: example_B
{
   public:
      int getA()
      { 
         return (width * height); 
      }
};