友元函数有啥作用,它主要用在哪些情况下?

Posted 2023-04-04

友元函数的作用就是提供直接访问对象的私有成员的接口。通过友元，一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。

使用情况：

1）必须在类的说明中说明友元函数，说明时以关键字friend开头，后跟友元函数的函数原型，友元函数的说明可以出现在类的任何地方，包括在private和public部分；

2）注意友元函数不是类的成员函数，所以友元函数的实现和普通函数一样，在实现时不用"::"指示属于哪个类，只有成员函数才使用"::"作用域符号；

3）友元函数不能直接访问类的成员，只能访问对象成员；

4）友元函数可以访问对象的私有成员，但普通函数不行；

5）调用友元函数时，在实际参数中需要指出要访问的对象；

6）类与类之间的友元关系不能继承；

7）一个类的成员函数也可以作为另一个类的友元，但必须先定义这个类。

扩展资料：

友元函数的成员函数：

假设f是想正确声明的函数，c是和它相关的类；

1、虚函数必须是成员函数。如果f必须是虚函数，就让它成为c的成员函数。

2、operator>>;和operator<<;决不能是成员函数。如果f是operator>>;或operator<<;，让f成为非成员函数。如果f还需要访问c的非公有成员，让f成为c的友元函数；

3、只有非成员函数对最左边的参数进行类型转换。如果f需要对最左边的参数进行类型转换，让f成为非成员函数。如果f还需要访问c的非公有成员，让f成为c的友元函数；

4、其它情况下都声明为成员函数；

5、如果以上情况都不是，让f成为c的成员函数。

参考资料来源：百度百科-友元函数

参考技术A 友元函数的作用就是提供直接访问对象的私有成员的接口。友元函数是可以直接访问类的私有成员的非成员函数。类授予它的友元特别的访问权。通常同一个开发者会出于技术和非技术的原因，控制类的友元和成员函数（否则当你想更新你的类时，还要征得其它部分的拥有者的同意）。
形式：
friend <返回类型> <函数名> (<参数列表>);
然后在类体外对友元函数进行定义，定义的格式和普通函数相同，但可以通过对象作为参数直接访问对象的私有成员。
注意：
1）必须在类的说明中说明友元函数，说明时以关键字friend开头，后跟友元函数的函数原型，友元函数的说明可以出现在类的任何地方，包括在private和public部分；
2）注意友元函数不是类的成员函数，所以友元函数的实现和普通函数一样，在实现时不用"::"指示属于哪个类，只有成员函数才使用"::"作用域符号；
3）友元函数不能直接访问类的成员，只能访问对象成员，
4）友元函数可以访问对象的私有成员，但普通函数不行；
5）调用友元函数时，在实际参数中需要指出要访问的对象，
6）类与类之间的友元关系不能继承。
7）一个类的成员函数也可以作为另一个类的友元，但必须先定义这个类。
实例：
#include <iostream>
#include <math.h>
using namespace std;
class Point

public:
Point(double xx, double yy) x=xx; y=yy;
void Getxy();
friend double Distance(Point &a, Point &b);
private:
double x, y;
;
void Point::Getxy()

cout<<"("<<x<<","<<y<<")"<<endl;

double Distance(Point &a, Point &b)

double dx = a.x - b.x;
double dy = a.y - b.y;
return sqrt(dx*dx+dy*dy);

void main()

Point p1(3.0, 4.0), p2(6.0, 8.0);
p1.Getxy();
p2.Getxy();
double d = Distance(p1, p2);
cout<<"Distance is "<<d<<endl;
参考技术B 友元函数

友元函数的特点是能够访问类中的私有成员的非成员函数。友元函数从语法上看，它与普通函数一样，即在定义上和调用上与普通函数一样。下面举一例子说明友元函数的应用。

class Point
public:
Point(double xx, double yy)

x=xx;
y=yy;

void Getxy();
friend double Distance(Point &a, Point &b);
private:
double x, y;
;
void Point::Getxy()

cout<<"("<<<","<<Y<<")"<<endl;

double Distance(Point &a, Point &b)

double dx = a.x - b.x;
double dy = a.y - b.y;
return sqrt(dx*dx+dy*dy);

void main()

Point p1(3.0, 4.0), p2(6.0, 8.0);
p1.Getxy(); p2.Getxy();
double d = Distance(p1, p2);
cout<<"Distance is"<< d<<endl;

说明：在该程序中的Point类中说明了一个友元函数Distance()，它在说明时前边加friend关键字，标识它不是成员函数，而是友元函数。它的定义方法与普通函数定义一样，而不同于成员函数的定义，因为它不需要指出所属的类。但是，它可以引用类中的私有成员，函数体中 a.x，b.x，a.y，b.y都是类的私有成员，它们是通过对象引用的。在调用友元函数时，也是同普通函数的调用一样，不要像成员函数那样调用。 参考技术C 友元是为了解决运行效率和封装性而设立的概念。
设想一个问题：输入两个（x,y）坐标，输出两点间距离。（用面向对象方法编写程序）
首先建立类Point。
class Point
private:
double x,y;
public:
Point(double xx,double yy)x=xx;y=yy; //构造函数
...

然后，我们要计算两点间的距离。
把这个函数叫Distance（，），参数是Point类的两个对象；Distance（）要计算距离，就必须访问对象里的私有变量x,y。如下：
Distance(Point &a, Point &b)
　　double dx = a.x - b.x;
　　double dy = a.y - b.y;
　　return sqrt(dx*dx+dy*dy);

这个函数可能是三种情况之一：独立于类Point的全局函数，类Point的成员函数，类Point的友元函数。1）非类Point成员函数首先被排除，因为Distance（，）需要访问类Point对象的Private变量，这是不允许的。2）类Point的成员函数，理论上被允许，但调用Distace（，）则必须通过对象，增加了程序的复杂度，许多成员需要被反复调用。
3）友元函数应运而生，加上friend，它可以访问类内的private变量，而调用时不必增加而外开销。
完整程序：
#include <iostream>
#include <math.h>
using namespace std;

class Point
private:
double x,y;
public:
Point(double xx,double yy)x=xx;y=yy; //构造函数
void Getxy(); //获取输入的（x,y）坐标并显示
friend double Distance( Point &a,Point &b );//友元函数Distance（，）用于计算两点间距离
;
void Point::Getxy()
cout<<"("<<x<<","<<y<<")"<<endl;

double Distance( Point &a,Point &b )
double dx = a.x - b.x ;
double dy = a.y - b.y ;
return sqrt( dx*dx + dy*dy );


int main()
cout<<"输入两点坐标：";
double a,b,c,d;
cin>>a>>b>>c>>d;
Point p1(a,b);
Point p2(c,d);
p1.Getxy();
p2.Getxy();
double re = Distance(p1,p2);
cout<<"两点间距离是："<<re<<endl;
return 0；


当然，另外的方法是友元类；把Distance（，）放在这个友元类里。这个问题友元函数就可以解决了，较大的系统里可以使用友元类，涉及设计模式时比较常用的方法。 参考技术D 定义格式（c++）：
　　friend <返回类型> <函数名> (<参数列表>);
分清成员函数，非成员函数和友元函数
　　成员函数和非成员函数最大的区别在于成员函数可以是虚拟的而非成员函数不行。所以，如果有个函数必须进行动态绑定（见条款38），就要采用虚拟函数，而虚拟函数必定是某个类的成员函数。关于这一点就这么简单。如果函数不必是虚拟的，情况就稍微复杂一点。 （条款38: 决不要重新定义继承而来的缺省参数值）
举例
　　看下面表示有理数的一个类：
　　class rational
　　public:
　　rational(int numerator = 0, int denominator = 1);
　　int numerator() const;
　　int denominator() const;
　　private:
　　...
　　;
　　这是一个没有一点用处的类。（用条款18的术语来说，接口的确最小，但远不够完整。）所以，要对它增加加，减，乘等算术操作支持，但是，该用成员函数还是非成员函数，或者，非成员的友元函数来实现呢？
　　当拿不定主意的时候，用面向对象的方法来考虑！有理数的乘法是和rational类相联系的，所以，写一个成员函数把这个操作包到类中。
　　class rational
　　public:
　　...
　　const rational operator*(const rational& rhs) const;
　　;
　　（如果你不明白为什么这个函数以这种方式声明——返回一个const值而取一个const的引用作为它的参数——参考条款21-23。）
　　条款21: 尽可能使用const
　　条款22: 尽量用“传引用”而不用“传值”
　　条款23: 必须返回一个对象时不要试图返回一个引用
　　现在可以很容易地对有理数进行乘法操作：
　　rational oneeighth(1, 8);
　　rational onehalf(1, 2);
　　rational result = onehalf * oneeighth; // 运行良好
　　result = result * oneeighth; // 运行良好
　　但不要满足，还要支持混合类型操作，比如，rational要能和int相乘。但当写下下面的代码时，只有一半工作：
　　result = onehalf * 2; // 运行良好
　　result = 2 * onehalf; // 出错!
　　这是一个不好的苗头。记得吗？乘法要满足交换律。
　　如果用下面的等价函数形式重写上面的两个例子，问题的原因就很明显了：
　　result = onehalf.operator*(2); // 运行良好
　　result = 2.operator*(onehalf); // 出错!
　　对象onehalf是一个包含operator*函数的类的实例，所以编译器调用了那个函数。而整数2没有相应的类，所以没有operator*成员函数。编译器还会去搜索一个可以象下面这样调用的非成员的operator*函数（即，在某个可见的名字空间里的operator*函数或全局的operator*函数）：
　　result = operator*(2, onehalf); // 错误!
　　但没有这样一个参数为int和rational的非成员operator*函数，所以搜索失败。
　　再看看那个成功的调用。它的第二参数是整数2，然而rational::operator*期望的参数却是rational对象。怎么回事？为什么2在一个地方可以工作而另一个地方不行？
　　秘密在于隐式类型转换。编译器知道传的值是int而函数需要的是rational，但它也同时知道调用rational的构造函数将int转换成一个合适的rational，所以才有上面成功的调用（见条款m19）。换句话说，编译器处理这个调用时的情形类似下面这样：
　　const rational temp(2); // 从2产生一个临时
　　// rational对象
　　result = onehalf * temp; // 同onehalf.operator*(temp);
　　当然，只有所涉及的构造函数没有声明为explicit的情况下才会这样，因为explicit构造函数不能用于隐式转换，这正是explicit的含义。如果rational象下面这样定义：
　　class rational
　　public:
　　explicit rational(int numerator = 0, // 此构造函数为
　　int denominator = 1); // explicit
　　...
　　const rational operator*(const rational& rhs) const;
　　...
　　;
　　那么，下面的语句都不能通过编译：
　　result = onehalf * 2; // 错误!
　　result = 2 * onehalf; // 错误!
　　这不会为混合运算提供支持，但至少两条语句的行为一致了。
例子结论
　　然而，我们刚才研究的这个类是要设计成可以允许固定类型到rational的隐式转换的——这就是为什么rational的构造函数没有声明为explicit的原因。这样，编译器将执行必要的隐式转换使上面result的第一个赋值语句通过编译。实际上，如果需要的话，编译器会对每个函数的每个参数执行这种隐式类型转换。但它只对函数参数表中列出的参数进行转换，决不会对成员函数所在的对象（即，成员函数中的*this指针所对应的对象）进行转换。这就是为什么这个语句可以工作：
　　result = onehalf.operator*(2); // converts int -> rational
　　而这个语句不行：
　　result = 2.operator*(onehalf); // 不会转换
　　// int -> rational
　　第一种情形操作的是列在函数声明中的一个参数，而第二种情形不是。
　　尽管如此，你可能还是想支持混合型的算术操作，而实现的方法现在应该清楚了：使operator*成为一个非成员函数，从而允许编译器对所有的参数执行隐式类型转换：
　　class rational
　　... // contains no operator*
　　;
　　// 在全局或某一名字空间声明，
　　// 参见条款m20了解为什么要这么做
　　const rational operator*(const rational& lhs,
　　const rational& rhs)
　　
　　return rational(lhs.numerator() * rhs.numerator(),
　　lhs.denominator() * rhs.denominator());
　　
　　rational onefourth(1, 4);
　　rational result;
　　result = onefourth * 2; // 工作良好
　　result = 2 * onefourth; // 万岁, 它也工作了!
　　这当然是一个完美的结局，但还有一个担心：operator*应该成为rational类的友元吗？
　　这种情况下，答案是不必要。因为operator*可以完全通过类的公有（public）接口来实现。上面的代码就是这么做的。只要能避免使用友元函数就要避免，因为，和现实生活中差不多，友元（朋友）带来的麻烦往往比它（他/她）对你的帮助多。
成员的函数与类接口
　　然而，很多情况下，不是成员的函数从概念上说也可能是类接口的一部分，它们需要访问类的非公有成员的情况也不少。
　　让我们回头再来看看本书那个主要的例子，string类。如果想重载operator>>和operator<<来读写string对象，你会很快发现它们不能是成员函数。如果是成员函数的话，调用它们时就必须把string对象放在它们的左边：
　　// 一个不正确地将operator>>和
　　// operator<<作为成员函数的类
　　class string
　　public:
　　string(const char *value);
　　...
　　istream& operator>>(istream& input);
　　ostream& operator<<(ostream& output);
　　private:
　　char *data;
　　;
　　string s;
　　s >> cin; // 合法, 但
　　// 有违常规
　　s << cout; // 同上
　　这会把别人弄糊涂。所以这些函数不能是成员函数。注意这种情况和前面的不同。这里的目标是自然的调用语法，前面关心的是隐式类型转换。
正确用法
　　istream& operator>>(istream& input, string& string)
　　
　　delete [] string.data;
　　read from input into some memory, and make string.data
　　point to it
　　return input;
　　
　　ostream& operator<<(ostream& output,
　　const string& string)
　　
　　return output << string.data;
　　
　　注意上面两个函数都要访问string类的data成员，而这个成员是私有（private）的。但我们已经知道，这个函数一定要是非成员函数。这样，就别无选择了：需要访问非公有成员的非成员函数只能是类的友元函数。
本条款得出的结论
　　假设f是想正确声明的函数，c是和它相关的类：
　　·虚函数必须是成员函数。如果f必须是虚函数，就让它成为c的成员函数。
　　·operator>>和operator<<决不能是成员函数。如果f是operator>>或operator<<，让f成为非成员函数。如果f还需要访问c的非公有成员，让f成为c的友元函数。
　　·只有非成员函数对最左边的参数进行类型转换。如果f需要对最左边的参数进行类型转换，让f成为非成员函数。如果f还需要访问c的非公有成员，让f成为c的友元函数。
　　·其它情况下都声明为成员函数。如果以上情况都不是，让f成为c的成员函数。

摘自百度百科：http://baike.baidu.com/view/534170.htm

*（星号）符号在函数参数附近有啥作用以及如何在其他情况下使用它？

【中文标题】*（星号）符号在函数参数附近有啥作用以及如何在其他情况下使用它？

【英文标题】：What does the * (asterisk) symbol do near a function argument and how to use that in others scenarios?*（星号）符号在函数参数附近有什么作用以及如何在其他情况下使用它？

【发布时间】：2011-07-12 07:58:07

【问题描述】：

我正在使用 Ruby on Rails 3，我想知道在函数参数附近存在 * 运算符意味着什么，并了解它在其他场景中的用法。

示例场景（此方法来自 Ruby on Rails 3 框架）：

def find(*args)
  return to_a.find  |*block_args| yield(*block_args)  if block_given?

  options = args.extract_options!

  if options.present?
    apply_finder_options(options).find(*args)
  else
    case args.first
    when :first, :last, :all
      send(args.first)
    else
      find_with_ids(*args)
    end
  end
end

【参考方案1】：

这是 splat 运算符，它来自 ruby​​（因此不是特定于 rails 的）。根据使用的地方，它可以通过两种方式应用：

将多个参数“打包”到一个数组中 将数组拆分为参数列表

在您的函数中，您会看到函数定义中使用的 splat 运算符。结果是该函数接受任意数量的参数。完整的参数列表将作为数组放入args。

def foo(*args)
  args.each_with_index |arg, i| puts "#i+1. #arg" 
end

foo("a", "b", "c")
# 1. a   <== this is the output
# 2. b
# 3. c

第二种变体是当您考虑以下方法时：

def bar(a, b, c)
  a + b + c
end

它只需要三个参数。你现在可以像下面这样调用这个方法

my_array = [1, 2, 3]
bar(*my_array)
# returns 6

在这种情况下应用于数组的 splat 将拆分它并将数组的每个元素作为单独的参数传递给方法。你甚至可以调用foo：

foo(*my_array)
# 1. 1   <== this is the output
# 2. 2
# 3. 3

正如您在示例方法中看到的那样，这些规则确实以相同的方式应用于块参数。

【参考方案2】：

这是一个 splat 参数，这基本上意味着传递给该方法的任何“额外”参数都将分配给 *args。