精华内容
下载资源
问答
  • 以下是对C++运算符重载 成员函数友元函数进行了介绍,需要的朋友可以过来参考下
  • 1.友元函数调用类成员变量要先定义类对象,然后通过对象调用,并且可以...2.友元函数和成员函数的定义方式不同,友元函数有个friend修饰 3.定义友元函数,不需要加类名 4.调用友元函数不需要通过,类对象 ...

    1.友元函数调用类成员变量要先定义类对象,然后通过对象调用,并且可以访问任何成员,成员函数就不需要定义类对象,可以直接使用数据成员,

    2.友元函数和成员函数的定义方式不同,友元函数有个friend修饰

    3.定义友元函数,不需要加类名

    4.调用友元函数不需要通过,类对象

     

     

    展开全文
  • 友元函数和成员函数

    千次阅读 2018-03-21 21:10:40
    C++中的友元函数:功能:可以直接访问类的私有成员,同样成员函数也可以访问,而普通非成员函数不可以。并且友元函数不受类的控制,无论是放到public,protected或者private中,都是一样的。下面是访问私有成员的两...

    C++中的 友元函数:
    功能:可以直接访问类的私有成员,同样成员函数也可以访问,而普通非成员函数不可以。并且友元函数不受类的控制,无论是放到public,protected或者private中,都是一样的。

    下面是访问私有成员的两种方法,分别是编写的成员函数以及友元函数
    //成员函数访问类的私有成员

    #include<iostream>
    using namespace std;
    class Int;
    class Int
    {
    public:
    	Int(int i = 0) : m_i(i)
    	{
    	}
    	int GETI()//创建一个成员函数返回类的私有成员
    	{
    		return  m_i;
    	}
    private:
    	int m_i;
    };
    void main()
    {
    	Int a(6);
    	cout<<a.GETI()<<endl;//调用成员函数访问私有成员
    }


    //友元函数访问私有成员
    #include<iostream>
    using namespace std;
    class Int;
    class Int
    {
    	friend void show(Int &);//友元函数
    public:
    	Int(int i = 0) : m_i(i)
    	{
    	}
    private:
    	int m_i;
    };
    void show(Int &i)//友元函数的实现
    {
    	cout<<i.m_i<<endl;
    }
    void main()
    {
    	Int a(6);
    	show(a);//调动友元函数访问私有成员
    }

    展开全文
  • 1.不能被重载的运算符有五个,分别是 . .* :: ?: sizeof 有两个运算符系统提供默认重载版本: ...2.运算符函数可以重载为成员函数友元函数和普通函数。使用非成员,非友元的普通函数重载访问private,...

    1.不能被重载的运算符有五个,分别是 . .* :: ?: sizeof
    有两个运算符系统提供默认重载版本:
    (1.)赋值运算符“=”,系统默认重载为对象数据成员的复制。
    (2.)地址运算符“&”,系统默认重载为返回任何类对象的地址。
    2.运算符函数可以重载为成员函数,友元函数和普通函数。使用非成员,非友元的普通函数重载访问private,protect数据成员时,必须通过public接口提供的函数实现,增加程序开销。所以重载运算符用成员函数或友元函数。他们的关键区别在于,成员函数有this指针,而友元函数没有this指针。
    (1.) 一元运算符(无论前置还是后置,都要求有一个操作数)
    Object op 或 op Object
    <1> 当重载为成员函数,编译器解析为:
    Object.operator op()
    操作数由对象Object通过this指针隐含传递,所以参数表为空。
    <2>当重载为友元函数时,编译器解析为:
    operator op(Object)
    函数operator op所需的操作数由参数表Object提供。
    (2.)二元运算符(要求有左、右操作数)
    ObjectL op ObjectR
    <1>当重载为成员函数,编译器解析为:
    ObjectL.operator op (ObjectR)
    左操作数ObjectL通过this指针传递,右操作数由参数ObjectR传递。
    <2>重载为友元函数时,编译器解析为:
    operator op(ObjectL,ObjectR)
    左、右操作数都由参数传递。
    (1.)用成员函数重载运算符(当一元运算符的操作数,或者二元运算符的左操作数是该类的一个对象时,重载运算符函数一般定义为成员函数)

    #include<iostream>
    using namespace std;
    class TriCoor    ///描述3维坐标的类 TriCoor,
    {
    public:
    	TriCoor(int mx = 0, int my = 0, int mz = 0)
    	{
    		x = mx;
    		y = my;
    		z = mz;
    	}
    	TriCoor operator + (TriCoor t)
    	{
    		TriCoor temp;
    		temp.x = x + t.x;
    		temp.y = y + t.y;
    		temp.z = z + t.z;
    		return temp;
    	}
    	TriCoor operator = (TriCoor t)
    	{
    		x = t.x;
    		y = t.y;
    		z = t.z;
    		return *this;
    	}
    	TriCoor operator ++ ()
    	{
    		x++;
    		y++;
    		z++;
    		return *this;
    	}
    	void show()
    	{
    		cout << x << " , " << y << " , " << z << "\n";
    	}
    	void assign(int mx, int my, int mz)
    	{
    		x = mx;
    		y = my;
    		z = mz;
    	}
    private:
    	int x, y, z;	// 3_d coordinates
    };
    
    int main()
    {
    	TriCoor a(1, 2, 3), b, c;
    	a.show();
    	b.show();
    	c.show();
    	for (int i = 0; i < 5; i++)
    		++b;
    	b.show();
    	c.assign(3, 3, 3);
    	c = a + b + c;
    	c.show();
    	c = b = a;
    	c.show();
    }
    
    

    程序中,*this是引起调用函数的对象,他是运算符的左操作数。例如,表达式:a+b激活函数的是对象b,运算符右边的对象被作为参数传递给函数。因此,该表达式解析为:a.operator+(b)。
    程序中,重载“++”和“=”运算符函数返回类类型的引用TriCoor &。“++”和“=”的运算可以作为左值表达式函数返回类引用既符合原来的语义,有减少函数返回时对匿名对象数据复制的开销。
    用友元函数重载运算符
    ##不能用友元函数重载的运算符有 = () 【】 -> 四个

    当运算符左右操作数类型不用时,用成员函数重载运算符会碰到麻烦。
    例如:

    class Complex
    {
    public:
    	Complex(int a)
    	{
    		Real = a;
    		Image = 0;
    	}
    	Complex(int a,int b)
    	{
    		Real = a;
    		Image = b;
    	}
    	Complex operator+(Complex);
    private:
    	int Real;
    	int Image;
    	//......
    };
    
    int main()
    {
    	Complex z1(1, 1), z2(2, 2);
    	z1 = z1 + 1;  //正确
    	//z1 = 1 + z1;//错误
    
    }
    

    上述代码中,z1+1被解析为z.operator(1),他引起调用重载运算符的是左操作数z1,右操作数1通过Complex类型参数调用类的构造函数Complex(int a )建立临时对象执行函数。
    但1+z1被解析为系统预定义版本时,z1无法装换成基本类型,而是被解析为重载版本:
    1.operator+(z1),但整型值1不是Complex的对象,无法驱动函数运行。在此成员函数重载的+运算符不具备交换性。
    因此,可以用友元函数重载运算符,左右参数都由参数传递,则C++语言通过构造函数实现数据的隐式转换。
    既重载形式为:friend Complex operator+(Complex,Complex)
    则上述问题得以解决。

    
    #include<iostream>
    using namespace std;
    class Complex
    {
    public:
    	Complex(double r = 0, double i = 0)
    	{
    		Real = r;
    		Image = i;
    	}
    	Complex(int a)
    	{
    		Real = a; 
    		Image = 0; 
    	}
    	void print() const;
    	friend Complex operator+ (const Complex & c1, const Complex & c2);
    	friend Complex operator- (const Complex & c1, const Complex & c2);
    	friend Complex operator- (const Complex & c);
    private:
    	double  Real, Image;
    };
    Complex operator + (const Complex & c1, const Complex & c2)
    {
    	double r = c1.Real + c2.Real;  double i = c1.Image + c2.Image;
    	return Complex(r, i);
    }
    Complex operator - (const Complex & c1, const Complex & c2)
    {
    	double r = c1.Real - c2.Real;  double i = c1.Image - c2.Image;
    	return Complex(r, i);
    }
    Complex operator- (const Complex & c)
    {
    	return Complex(-c.Real, -c.Image);
    }
    void Complex::print() const
    {
    	cout << '(' << Real << " , " << Image << ')' << endl;
    }
    
    int main()
    {
    	Complex  c1(2.5, 3.7), c2(4.2, 6.5);
    	Complex c;
    	c = c1 - c2;	// operator-(c1,c2)
    	c.print();
    	c = 25 + c2;	// operator+(25,c2)
    	c.print();
    	c = c2 + 25;	// operator+(c2,52)
    	c.print();
    	c = -c1;	// operator-(c1)
    	c.print();
    }
    
    

    如果希望运算符操作数(尤其第一个)有隐式转换,则重载运算符必须用友元函数(或则普通函数)。

    展开全文
  • 写的很好的c++PPT
  • 在c++中,经常会定义类。...非成员函数作为友元函数。 使用友元函数将百分制学生的成绩转换成相应的分数等级。 #include<iostream> using namespace std; #include<iomanip> #include<string.h>

    在c++中,经常会定义类。类有一个特点就是数据封装数据隐藏,也就是该类的私有成员以及保护成员只有通过它的成员才能访问。通过中的友元机制则解决了这一问题。友元既可以是独立的一个非成员函数,也可以是其他类中的成员函数,还可以一个独立的其他类。
    一.非成员函数作为友元函数。
    使用友元函数将百分制学生的成绩转换成相应的分数等级。

    #include<iostream>
    using namespace std;
    #include<iomanip>
    #include<string.h>
    class student{
    	private:
    		char name[20];
    		int score;
    		char level[10];
    		public:
    			student(char na[],int sc);//构造函数
    			friend void trans(student &s);
    			void print()
    			{
    				cout<<setw(10)<<name<<setw(8)<<score<<setw(6)<<level<<endl;
    			}
    		
    }; 
    
    student::student(char na[],int sc)//构造函数 
    {
        strcpy(name,na);
    	score=sc;
    }
    void trans(student &s);
    int main()
    {
    	student stu[]={student("小红",78),student("王华",86),student("李明",98),student("孙强",62)};
    	cout<<"输出结果:"<<endl;
    	cout<<setw(10)<<"姓名"<<setw(8)<<"成绩"<<setw(6)<<"等级"<<endl; 
    	for(int i=0;i<4;i++)
    	{
    		 trans(stu[i]);
    		 stu[i].print();
    	}
    	return 0;
     } 
     void trans(student &s)
     {
     	if(s.score>90)
     	strcpy(s.level,"优");
    	 else if(s.score>=80)
    	 strcpy(s.level,"良");
    	 else if(s.score>=70)
    	 strcpy(s.level,"中");
    	 else if(s.score>=60)
    	 strcpy(s.level,"及格") ;
    	 else
    	 strcpy(s.level,"不及格"); 
     }
     
     
    

    strcpy为字符串复制函数,需定义在头文件 string.h 中。
    注意:
    1.非成员函数作为类的友元函数在类外定义,不能在函数名外加"类名::函数名"
    2.非成员函数作为类的友元函数,没有this指针

    展开全文
  • 搬运自:... ... 友元包括友元函数、友元类 友元函数: 个人理解为在类中声明的可以外部访问类的内部成员变量的一个函数,这个函数并不是类的成员函数,只是在类中声明,而定义在类外。换...
  • 有些情况下,允许特定的非成员函数访问一个类的私有成员,同时仍阻止一般的访问,这是很方便做到的。例如被重载的操作符,如输入或输出操作符,经常需要访问类的私有数据成员。 友元(frend)机制允许一个类将对其非...
  • 当声明了友元函数或者友元类之后,该函数或者类可以访问类的所有成员,包括private成员,当然访问过程需要通过类的对象进行。例如声明一个友元函数,有两种情况: ①该函数是普通的全局函数 一般情况下,使用一个...
  • 类有成员变量和成员函数。而函数中,不是任何一个类的成员的函数,就是非成员函数。例如: class A{ public:  void f1(){}; // 这个就是成员函数。  void f2(); // 这个也是成员函数声明,其实现在类的...
  • 现在先说说赋值运算符“=”的重载C++规定赋值运算符“=”只能重载为类的非静态成员函数,而不可以重载为类的友元函数。不能重载为类的静态成员应该比较容易理解,因为静态成员函数是属于整个类的,不是属于某个对象...
  • 友元函数 友元类 友元成员函数

    千次阅读 2018-05-07 22:34:40
    友元 一般来说,类内的私有数据是对外不可见的,但在有些情况下,我们需要在类外对该类的私有数据进行访问,这就需要用到一种新技术——友元(friend),即在声明前...友元函数是指某些非类成员函数,但可以访问类...
  • 一、友元介绍我们知道,类的成员函数可以访问同类的其他成员函数,包括公有、私有保护成员。而类的外部函数只能访问类的公有成员。友元是一种允许非类成员函数访问类的非公有成员的一种机制。可以把一个函数指定为...
  • 友元函数成员函数的一点区别

    千次阅读 2018-01-27 15:53:46
    例如,在友元函数中,无法直接操作成员变量。必须要现有一个类的对象,再通过这个对象使用圆点操作符 class class A { pubic:  classA(); private: int x; } //此处使用了传引用调用,传递一个类的对象进来,并且...
  • 文章目录022普通函数做类友元函数023友元类024友元成员函数 022普通函数做类友元函数 #include<iostream> #include<cstdlib> #include<string> #include<vector> using namespace std; ...
  • 私有成员只能在类的成员函数内部访问,如果想在别处访问对象的私有成员,只能通过类提供的接口(成员函数)间接地进行。这固然能够带来数据隐藏的好处,利于将来程序的扩充,但也会增加程序书写的麻烦。
  • 在一个类中,可以利用关键字friend将其他的函数或类声明为友元,如果友元是一般函数或者类的成员函数,称为友元函数,如果友元是一个类,则成为友元类,友元类的所有成员函数都自动成为友元函数友元函数友元...
  • C++笔记--关于友元函数和静态成员函数 今天在写程序时用到了好多静态成员函数,然后突然想到了友元函数,有些思考。 首先,两者都可以读写对象的成员变量。基于此可以认为静态函数和友元函数都具有访问类内部数据的...
  • //成员函数友元函数: #include<iostream> #include<string> using namespace std; class Building; class goodGay { public: goodGay(); void visit1(); void visit2(); private: Building *...
  • xxx xxxxx 目 录 页 C++语言程序设计 绪 论 大连理工大学出版社 地址大连市软件园路80号 E-mail : dutp@ URLhttp://www.dutp,cn 友元函数和友元友元函数和友元类 类具有封装性和隐藏性只有类的成员函数才能访问该...
  • C++ friend 友元函数,友元类,友元成员函数看这里友元函数友元类友元成员函数 友元函数 友元函数:是个函数。 三种访问权限:public,protected,private。 把函数成为类的友元函数,函数就能访问类的所有成员...
  • 友元类,成员函数友元函数

    千次阅读 2017-04-23 21:59:36
    在C++中,可以把某个类中的成员函数或者整个类声明为友元。 class person; class friendly1 { public: void printperson(person& per); }; class friendly2 { public: void setperson(person& per); }; class ...
  •  讲友元之前先讲普通的成员函数的函数指针  <code class=sourceCode>class Std_interface {  public:  virtual void suspend() = 0;  };  // define the pointer of function  typedef void (Std_...
  • 若想要类外函数能够访问类的protectedprivate成员,则需要将类外函数在类中再次声明为友元函数。此友元函数的声明位置不受访问权限限制。 若想要一个类的成员函数均能访问另一个类的成员,则需要将此类声明为另一...
  • 友元分为友元函数、友元成员友元类三种,友元声明可以放在类的公有、私有或保护,结果都一样的。 一.友元函数 友元函数是一种说明在类定义体内的非成员函数。说明友元函数的方法如下: friend 返回值类型 函数名...
  • 1、友元函数 2、友元类 3、友元成员函数 友元小结: 参考资料: 有些情况下,允许特定的非成员函数访问一个类的私有成员,同时仍阻止一般的访问,这是很方便做到的。例如被重载的操作符,如输入或输出操作符,...
  • C++----类成员函数友元函数

    千次阅读 2018-12-13 21:21:40
    //成员函数友元函数: //只让visit1做building的好朋友(只有visit1能访问building的私有属性) class Building; class goodGay { public: goodGay(); void visit1(); void visit2(); private: Building * ...
  • 当运算符重载函数作为成员函数实现:最左边的操作数必须是运算符的一个类对象或者是对该类对象的一个引用。 当运算符重载函数作为友元函数实现:当访问类的private或protected数据成员时必须指定为友元函数。 ....
  • #include using namespace std; class Time ...//成员函数直接访问私有数据  aaa2(b1,b2);//友元函数也可以直接访问私有函数  aaa3(b1,b2);//普通函数只能通过外部接口  return 0; }

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,841
精华内容 15,536
关键字:

友元函数和成员函数的联系