关键字-friend使用

1.什么时候使用？

   当非成员函数需要访问类的私有成员时，我们可以把它声明为该类的友元。

2.有什么利弊？

   利：友元可以“工作在类的内部”，像类的成员一样访问类的所有数据和函数。

   弊：使用不慎，可能会破坏类的封装性。

3.具体的使用场景举例

   友元分为友元函数（非成员函数和其他类的成员函数）和友元类

class Sales_data {
	//类别1：非成员函数
friend Sales_data add(const Sales_data&, const Sales_data&);  //场景1：相同的类型之间进行+,-,*，
friend std::ostream &print(std::ostream&, const Sales_data&); //场景2：单独类进行进行输入或输出 
friend std::istream &read(std::istream&, Sales_data&);
	//类别2：其他类的某个成员为友元函数
friend void		Person::read(Slaes_data&);
	//类别3：某个类的多个成员函数均需要访问，可以声明为友元类
friend class    Acount;
public:
	// constructors
	Sales_data() = default;
	Sales_data(const std::string &s): bookNo(s) { }
	Sales_data(const std::string &s, unsigned n, double p):
	           bookNo(s), units_sold(n), revenue(p*n) { }
	Sales_data(std::istream &);

	// operations on Sales_data objects
	std::string isbn() const { return bookNo; }
	Sales_data& combine(const Sales_data&);
	double avg_price() const;
private:
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;
};


//与该类相关的友元函数一般需要在头文件进行声明Interface
Sales_data add(const Sales_data&, const Sales_data&);
std::ostream &print(std::ostream&, const Sales_data&);
std::istream &read(std::istream&, Sales_data&);

4.友元声明与作用域

   1）非成员函数友元声明顺序：先在类内进行友元声明，再在类的.h后面中声明该友元函数，最后在.c文件进行实现，这样可让类的其他声明在.h的内联函数使用该友元函数。

struct X {
	//友元函数可以定义在类的内部，
	friend void f() { cout << __FUNCTION__ << endl; }
	X() { f(); }	//错误：f还没有被声明	
	void g();
	void h();
};

//注意：即使在类中定义f,也必须在外部提供相应声明  
void X::g() { return f(); }		//错误：f还没有被声明 
void f();
void X::h() { return f(); }		//正确：现在f声明在作用域中 

   2）友元类的定义顺序：

//1.声明友元类 
class Name{
	friend class People;
public:
	Name(const string& n = ""):name(n) {}
private:
	string name;		
};

//2.定义友元类 
class People{
public:
	void print() {cout<<name.name<<endl;}
	People(const Name& n):name(n) {}
private:
	Name name;
};

int main(int argc, char** argv) {
	Name name("CSND");
	People people(name);
	people.print();		//打印CSND 
	return 0;
}

3.类A的成员函数A.f()定义成类B的友元函数

a)定义类A,声明A.f(),但不能实现A.f()

b)定义类B,并声明A.f()

c)定义A.f()
 

//Step:1
class Title;

//Step:2
class Wind{
public:
	void clear(Title& title);
};

//Step:3
class Title{
friend void Wind::clear(Title&);
	
public:
	Title(const string& s):label(s) {}
private:
	string label;
}; 

//Step:4
inline
void Wind::clear(Title& title){
	cout<< title.label << endl;
}

int main(int argc, char** argv) {
	Title title("Hello World!");
	Wind wind;
	wind.clear(title);	//打印Hello World!
	return 0;
}

5.注意事项

1.友元不是类的成员也不受它所在区域的访问控制级别的约束，因此，最好在类定义开始处声明友元函数，如上述示例。

2.重载函数虽然名字相同，但它们仍然是不同的函数，如果想要把一组重载函数声明成它的友元，需要对每一个重载函数依次声明成友元。