类3(友元)

一、友元介绍

我们知道，类的成员函数可以访问同类的其他成员函数，包括公有、私有和保护成员。而类的外部函数只能访问类的公有成员。

友元是一种允许非类成员函数访问类的非公有成员的一种机制。
可以把一个函数指定为类的友元，也可以把整个类指定为另一个类的友元。

友元函数
友元类

二、友元函数
友元函数在类作用域外定义，但它需要在类体中进行说明
为了与该类的成员函数加以区别，定义的方式是在类中用关键字friend说明该函数，格式如下：

friend  类型 友元函数名(参数表);
友元的作用在于提高程序的运行效率

友元函数注意事项：
1、友元函数不是类的成员函数，在函数体中访问对象的成员，必须用对象名加运算符“.”加对象成员名。但友元函数可以访问类中的所有成员（公有的、私有的、保护的），一般函数只能访问类中的公有成员。

2、友元函数不受类中的访问权限关键字限制，可以把它放在类的公有、私有、保护部分，但结果一样。

3、某类的友元函数的作用域并非该类作用域。如果该友元函数是另一类的成员函数，则其作用域为另一类的作用域，否则与一般函数相同。

4、友元函数破坏了面向对象程序设计类的封装性，所以友元函数如不是必须使用，则尽可能少用。或者用其他手段保证封装性。

就如我们在上一篇博客中的 Sales_data 类，如果将其中的数据成员修改成 private，则还需要将 add，read，print 这三个函数声明成 Sales_data 类的友元函数，因为我们在这三个函数中直接访问了 Sales_data 类的私有数据成员：

#include <iostream>
using namespace std;

class Sales_data{

//友元声明
friend Sales_data add(const Sales_data&, const Sales_data&);
friend std::istream &read(std::istream&, Sales_data&);
friend std::ostream &print(std::ostream&, const Sales_data&);
    
    //数据成员
private:
    std::string book_no;
    unsigned units_sold = 1;
    double revenue = 1.0;

public:
    Sales_data() = default;//不接受任何实参，默认构造函数
    Sales_data(const std::string &s): book_no(s){}//除了book_no外其他成员将被编译器赋予默认值
    Sales_data(const std::string &s, unsigned n, double p): book_no(s), units_sold(n), revenue(p * n){}
    Sales_data(std::istream&);

    std::string isbn() const {
        return book_no;
        // return this->book_no;//等价语句
    }
    Sales_data& combine(const Sales_data&);
    double avg_price() const;
};

// Sales_data的非成员函数声明
Sales_data add(const Sales_data&, const Sales_data&);
std::ostream &print(std::ostream&, const Sales_data&);
std::istream &read(std::istream&, Sales_data&);

Sales_data::Sales_data(std::istream &is){
    read(is, *this);//read 函数的作用是从 is 中读取一条信息然后存入 this 中
}

double Sales_data::avg_price() const{
    if(units_sold) return revenue / units_sold;
    return 0;
}

Sales_data& Sales_data::combine(const Sales_data &rhs){
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;
}

istream &read(istream &is, Sales_data &item){//从给定流中将数据读到给定的对象里
    double price = 0;
    is >> item.book_no >> item.units_sold >> price;
    item.revenue = price * item.units_sold;
    return is;
}

ostream &print(ostream &os, const Sales_data &item){//将给定对象的内容打印到给定的流中
    os << item.isbn() << " " << item.units_sold << " " << item.revenue << " " << item.avg_price();
    //print 函数不负责换行。一般来说执行输出的函数应该尽量减少对格式的控制，这样可以确保由用户代码来决定是否换行
    return os;
}

Sales_data add(const Sales_data &lhs, const Sales_data &rhs){
    Sales_data sum = lhs;//默认情况下拷贝的是数据成员
    sum.combine(rhs);//把 rhs 的数据成员加到 sum 中
    return sum;//返回 sum 的副本
}

int main(void){
    Sales_data total(cin), x;
    // print(cout, x);
    // read(cin, total);
    while(read(cin, x)){
        total = add(total, x);
        print(cout, total);
        cout << endl;
    }
    return 0;
}

还需要注意的一点是：友元的声明仅仅指定了访问的权限，而非一个通常意义上的函数声明。如果我们希望类的用户能够调用某个友元函数，那么我们就必须在友元声明之外再专门对函数进行一次声明：

#include <iostream>
using namespace std;

class gel{
    // friend void f(gel&){}//友元函数可以定义在内的内部,然而好像这并没啥用,要是成员函数还用啥友元声明啊
    friend void f(gel&);//友元函数声明只是声明了访问权限,并不能当成一般的函数声明来用
    
public:
    // gel(){//错误,f函数还没声明
    //     f(*this);
    // }
    void lou();
    void ting();

private:
    int x;
};

// void gel::lou(){
//     f(*this);//错误,f函数还没声明
// }

void f(gel &it);//声明f函数

void gel::ting(){//正确
    f(*this);
}

void f(gel &it){
    it.x += 1;
}

int main(void){

}

 

三、友元类
如果某类B的成员函数会频繁的存取另一个类A的数据成员, 而A的数据成员的Private/Protectd限制造成B存取的麻烦, B只能通过A的Public的成员函数进行间接存取
把B做成A类的友元类,即A类向B类开放其Private/Protectd内容, 让B直接存取

友元类：一个类可以作另一个类的友元
友元类的所有成员函数都是另一个类的友元函数

友元类的声明：
friend class 类名;

友元类注意事项：
1、友元关系是单向的
2、友元关系不能被传递
3、友元关系不能被继承

#include <iostream>
#include <vector>
using namespace std;

class Screen{
    
friend class window_mgr;//将window_mgr类声明成Screen的友元类

public:
    typedef std::string::size_type pos;
    Screen() = default;
    //cursor为默认值0
    Screen(pos ht, pos wd, char c): height(ht), width(wd), contents(ht * wd, c){};
    char get() const{
        return contents[cursor];
    }

private:
    pos cursor = 0;
    pos height = 0, width = 0;
    std::string contents;
};


class window_mgr{
    
public:
    // window_mgr();
    // ~window_mgr();
    using screen_index = std::vector<Screen>::size_type;
    void clear(screen_index);

private:
    std::vector<Screen> screen{Screen(24, 80, ' ')};
    
};

void window_mgr::clear(screen_index i){
    Screen &s = screen[i];
    s.contents = std::string(s.height * s.width, ' ');
    //因为window_mgr是Screen类的友元类，所以可以直接访问Screen类中的private对象contents,height,width
}

int main(void){

}

上面的代码中，我们在 Screen 类中定义了 window_mgr 类为其友元类，所以 window_mgr 类的成员函数可以直接访问 Screen 类中的所有数据成员，包括 private 类型的成员。

除了令整个 window_mgr 类作为 Screen 类的友元之外，还可以只声明 window_mgr 类中的某个函数为 Screen 类的友元函数。当把一个成员函数声明成友元时，必须明确指出该成员函数属于哪个类：

#include <iostream>
#include <vector>
using namespace std;

class Screen;//下面的window_mgr需要用Screen作形参，所以我们需要先声明一下Screen类

class window_mgr{
    
public:
    // window_mgr();
    // ~window_mgr();
    void clear(int i);

private:
    std::vector<Screen> screen;

};

class Screen{

// friend class window_mgr;//将window_mgr类声明成Screen的友元类
friend void window_mgr::clear(int);//将window::clear定义成Screen的友元函数
// friend void clear(int);//没有指明clear所属的类,只样声明的clear友元函数和window_mgr类里的clear成员函数半毛钱关系都没有


public:
    typedef std::string::size_type pos;
    Screen() = default;
    //cursor为默认值0
    Screen(pos ht, pos wd, char c): height(ht), width(wd), contents(ht * wd, c){};
    char get() const{
        return contents[cursor];
    }

private:
    pos cursor = 0;
    pos height = 0, width = 0;
    std::string contents;
};


void window_mgr::clear(int i){
    Screen &s = screen[i];
    s.contents = std::string(s.height * s.width, ' ');
}

int main(void){

}

然而我们发现想要令某个成员函数作为友元，我们必须自信组织程序的结构以满足声明和定义的彼此依赖关系。这相当麻烦，在整个例子中：

1.首先定义 window_mgr 类，其中声明 clear 函数，但是不能定义它。在使用 Screen 的成员之前还必须声明 Screen 类

2.接下来定义 Screen，包括 clear 的友元声明

3.定义 clear，此时它才可以使用 Screen 的成员

4.尽管重载函数的名字相同，但它们仍然是不同的函数。因此一个类想把一组重载函数声明成它的友元，它需要对这组函数中的每个函数都单独声明成友元函数

以上内容大部分摘自：http://www.jb51.net/article/41328.htm