C++ 操作符重载、友元、类型转换操作符、五种类型转换、函数操作符(二)

五、成员和友元

当双目操作符的两个操作数不是同一类型时，往往需要把操作符函数定义为调用对象（左操作数）类型的成员，同时也是参数对象（右操作数）类型的友元。

C++中提供三种友元关系的实现方式，友元函数、友元成员函数、友元类。

先谈谈废话: C++ 程序的设计一切是为了运行效率

1、我们已知道类具备封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程式中的其他函数是无法访问私有成员的。非成员函数能够访问类中的公有成员，但是假如将数据成员都定义为公有的，这又破坏了隐藏的特性。另外，应该看到在某些情况下，特别是在对某些成员函数多次调用时，由于参数传递，类型检查和安全性检查等都需要时间开销，而影响程式的运行效率。
2、为了解决上述问题，提出一种使用友元的方案。友元是一种定义在类外部的普通函数，但他需要在类体内进行说明，为了和该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是他能够访问类中的私有成员。友元的作用在于提高程式的运行效率，但是，他破坏了类的封装性和隐藏性，使得非成员函数能够访问类的私有成员。

3、怎么使用友元函数：

友元函数的参数：

因为友元函数没有this指针，则参数要有三种情况：

1、 要访问非static成员时，需要对象做参数；–常用(友元函数常含有参数)

2、 要访问static成员或全局变量时，则不需要对象做参数

3、 如果做参数的对象是全局对象，则不需要对象做参数

友元函数的位置：

因为友元函数是类外的函数，所以它的声明可以放在类的私有段或公有段且没有区别。

友元函数的调用：

可以直接调用友元函数，不需要通过对象或指针

4、运算符重载时需要友元 、关联两个或者两个以上类的内部数据成员需要友元

5、友元的作用是提高了程序的运行效率（即减少了类型检查和安全性检查等都需要时间开销），但它破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。

说明：

1、友元函数

      友元函数的特点是能够访问类中的私有成员的非成员函数。友元函数从语法上看，他和普通函数相同，即在定义上和调用上和普通函数相同

      friend 函数类型 函数名(形参列表)  {......函数体..}
实例:

/*友元*/
#include <iostream>
using namespace std;
class Rect{
public:
    Rect(int width=0,int length=0):m_width(width),m_length(length){}
private:
    int m_width;
    int m_length;
    friend int Area(Rect&rect);
};
int Area(Rect&rect)
{
    return rect.m_width*rect.m_length;
}
int main(void)
{
    Rect rect(10,50);
    cout<<Area(rect)<<endl;

    return 0;
}

 

2、友元类

友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。       
      当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。定义友元类的语句格式如下：
      friend class 类名;
      其中：friend和class是关键字，类名必须是程序中的一个已定义过的类。
 例如，以下语句说明类B是类A的友元类：
      class A
      {
             …
      public:
             friend class B;
             …
      };
      经过以上说明后，类B的所有成员函数都是类A的友元函数，能存取类A的私有成员和保护成员。
      使用友元类时注意：
            (1) 友元关系不能被继承。
            (2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
            (3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明

注意事项：

1.友元可以访问类的私有成员。

2.只能出现在类定义内部，友元声明可以在类中的任何地方，一般放在类定义的开始或结尾。

3.友元可以是普通的非成员函数，或前面定义的其他类的成员函数，或整个类。

4.类必须将重载函数集中每一个希望设为友元的函数都声明为友元。

5.友元关系不能继承，基类的友元对派生类的成员没有特殊的访问权限。如果基类被授予友元关系，则只有基类具有特殊的访问权限。该基类的派生类不能访问授予友元关系的类。

实例：

/* 友元类 */
#include <iostream>
using namespace std;

class B;
class A{
public:
    A(int n=0,double f=0.0,char ch='A'):m_n(n),m_f(f),m_ch(ch){}
    int m_n;
protected:
    double m_f;
private:
    char m_ch;
    friend class B;
};
class B{
public:
    B(){}
    void B_f1(A&a){
        a.m_n++;
        a.m_ch++;
    }   
    void B_print(A&a){
        cout<<a.m_n<<","<<a.m_f<<","<<a.m_ch<<endl;
    }   
};
int main(void)
{
    A a(10,3.14,'B');
    B b;
    b.B_print(a);
    b.B_f1(a);
    b.B_print(a);
    return 0;
}

3、友元成员函数：类外其他类的成员函数为友元函数

建议：将友元类放在前面

实例：

/*友元成员函数*/
#include <iostream>
using namespace std;
class A;
class B{
public:
    B(){}
    void B_foo(A&a);
};
class A{
public:
    A(int n,double f,char ch='A'):m_n(n),m_f(f),m_ch(ch){}
    int m_n;
protected:
    double m_f;
private:
    char m_ch;
    friend void B::B_foo(A&a);
};
void B::B_foo(A&a)
{
    a.m_n += 10; 
    a.m_ch++;
    cout<<a.m_n<<","<<a.m_f<<","<<a.m_ch<<endl;
}
int main(void)
{
    A a(100,3.14,'D');
    B b;
    b.B_foo(a);
    return 0;
}

4、在模板类中使用友元 operator<<  (对 << 运算符的重载)

a)使用方法

     在模板类中声明：

    friend ostream& operator<< <>(ostream& cout,const MGraph<VexType,ArcType>& G);
   在模板类中定义：

   template<class VexType,class ArcType>
   ostream& operator<<(ostream& cout,const MGraph<VexType,ArcType>& G)
  {
   //函数定义
   }
b)注意：

  把函数声明非模板函数：

  friend ostream& operator<< (ostream& cout,const MGraph& G);
  把函数声明为模板函数：

  friend ostream& operator<< <>(ostream& cout,const MGraph<VexType,ArcType>& G);  或：

   friend ostream& operator<< <VexType,ArcType>(ostream& cout,const MGraph<VexType,ArcType>& G);
说明：
在函数声明中加入operator<< <>：是将operator<<函数定义为函数模板，将函数模板申明为类模板的友员时,是一对一绑定的
实际的声明函数：这里模板参数可以省略，但是尖括号不可以省略

friend ostream& operator<< <VexType,ArcType>(ostream& cout,const MGraph<VexType,ArcType>& G);

六、不是所有的操作符都能重载

eg:

            ::            
            .*/->*
            .
           ?: