精华内容
下载资源
问答
  • 友元函数作为重载运算符的方式重载运算符+ 下面例子来自于课本 #include using namespace std; class Complex { public: Complex() { real = 0; imag = 0; } Complex(double

    以友元函数作为重载运算符的方式重载运算符+

    下面的例子来自于课本

    #include <iostream>
    using namespace std;
    
    class Complex
    {
        public:
            Complex()
            {
                real = 0;
                imag = 0;
            }
            Complex(double r, double i)
            {
                real  = r;
                imag = i;
            }
            friend Complex operator + (Complex &c1, Complex &c2); //声明重载运算符
            void display();
    
        private:
            double real;
            double imag;
    };
    
    Complex operator +(Complex &c1,Complex &c2)
    {
        return Complex(c1.real + c2.real, c1.imag + c2.imag);
    }
    
    void Complex::display()
    {
        cout<<"("<<real<<","<<imag<<"i)"<<endl; //输出复数形式
    }
    
    int main()
    {
        Complex c1(3,4), c2(5,-10), c3;
        c3 = c1 + c2; //运算符+ 用于复数运算
    
        cout<<"c1= ";
        c1.display();
    
        cout<<"c2= ";
        c2.display();
    
        cout<<"c1+c2= ";
        c3.display();
    
        return 0;
    }
    

    此主函数中执行c3 = c1 + c2调用了重载运算符operator +;

    并且此重载运算符函数是Complex的友元函数。

    必须是Complex对象相加才可以。

    运行结果:



    读者可以自行对比一下友元函数为重载运算符函数和成员函数作为重载运算符函数的区别:http://blog.csdn.net/z_dream_st/article/details/78044481


    展开全文
  • #ifndef IPANDA_H #define IPANDA_H // 不能将模板成员函数放在单独的实现文件, // 因为模板不是函数,不能单独编译 ...// 所以此处是友元函数的模板函数的声明,并且要在模板类之前声明, // 所以是<t...
    #ifndef IPANDA_H
    #define IPANDA_H
    // 不能将模板成员函数放在单独的实现文件,
    // 因为模板不是函数,不能单独编译
    #include <string>
    #include <iostream>
    // 模板类的约束模板友元函数,因为友元函数是模板函数,
    // 所以此处是友元函数的模板函数的声明,并且要在模板类之前声明,
    // 所以是<typename t>,而不是<typename type>
    template <typename t>int operator+(t&,t&);
    template <typename type>
    class panda
    {
    private:
     std::string _name;
     std::string name_;
     std::string _name_;
     int a;
     type k;
    public:
     panda();
     panda(const std::string &name1, const std::string &name2,const std::string &name3,int,type );
     ~panda();
     const char* str(std::string _name) { return _name.c_str(); }
     // 按值传递则会创建对象副本
     friend int operator-(panda<type>& d,panda<type> &e);
     friend int operator+<>(panda<type>&, panda<type>&);
     operator int(); // 转换函数没有返回类型,没有参数
     panda<type>& operator=(panda<type>& );
     template<typename T> friend std::ostream& operator <<(std::ostream&,panda<T>&);
     template<typename TT>friend void show(TT&);
    };
    template <typename type>
    panda<type>::panda()
    {
     _name = "a";
     name_ = "b";
     _name_ = "c";
     a = 2;
    }
    
    template <typename type>
    panda<type>::panda(const std::string& name1, const std::string& name2, const std::string& name3, int b, type K)
    {
     _name_ = name2;
     _name = name1;
     name_ = name3;
     a = b;
     k = K;
    }
    
    template<typename type>
    panda<type>::~panda()
    {
     std::cout << "the destructor is called" << std::endl;
     std::cout << std::endl;
    }
    
    // 模板类也可以有友元函数,分为三类。
    // 第一类:模板类的非模板友元函数
    int operator-(panda<double>& d, panda<double>& e)
    {             
     return d.a - e.a;
    }
    
    // 第二类:模板类的约束模板友元函数,友元函数是模板函数
    // 此处是模板友元函数的实例化,因此要与模板函数的声明保持一致
    template<typename t>
    int operator+(t& d, t&e)
    {
     return d.a + e.a;
    }
    
    template <typename type>
    panda<type>::operator int()
    {
     return (*this).a;
    }
    
    template <typename type>
    //目的是说明panda是一个类模板,没有此说明,则panda<type>会报错
    panda<type>& panda<type>::operator =(panda<type>& z)
    {                    // panda<type>目的是说明panda类有一个type类型
     (*this).a = z.a;
     this->_name = z._name;
     this->name_ = z.name_;
     this->_name_ = z._name_;
     this->k = z.k;
     return *this;
    }
    
    //template<typename T> std::ostream& operator<<(std::ostream& os,T&c)
    // 此种定义编译出错,
    // 推测:原因是编译器直接根据第一个形参std::ostream& os进行模板函数实例化。
    
    //template<typename T> std::ostream& operator<<(T& c, std::ostream& os)
     函数调用需形如:love<<cout .
    //{
    // using std::endl;
    // os << c._name << endl;
    // os << c.name_ << endl;
    // os << c._name_ << endl;
    // os << c.a << endl;
    // return os;
    //}
    
    // 第三类:模板类的非约束模板友元函数
    //template <typename T> std::ostream& operator<<(std::ostream& os,T&c) 为什么会编译出错?(show()函数)
    template <typename T> std::ostream& operator<<(std::ostream& os,panda<T>&c)
    {
     using std::endl;
     os << c._name << endl;
     os << c.name_ << endl;
     os << c._name_ << endl;
     os << c.a << endl;
     return os;
    }
    
    template<typename TT> void show(TT& p)
    {
     std::cout << p._name<<std::endl;
    }
    #endif
    #include <iostream>
    #include "ipanda.h"
    int main()
    {
     using std::cin;
     using std::cout;
     using std::endl;
     //const char*不能指向string 引用,但可以指向const string 引用
     //const char*可以指向string 对象
     panda<double> panda1("A", "B", "C", 5, 5.66);
     panda<double> panda2;// 隐式调用构造函数时不需要加圆括号
     panda<double> panda3;
     cout << "重载减法运算符(模板类的非模板友元函数):\npanda1-panda2;\n";
     cout << (panda1 - panda2) << endl;
     cout << "重载加法运算符(模板类的约束模板友元函数):\npanda1+panda2;\n";
     cout << (panda1 + panda2) << endl;
     panda3=panda2=panda1;
     cout << "重载<<运算符(模板类的非约束模板友元函数):\n";
     cout << "panda1:\n"<<panda1 << endl;
     cout << "panda2\n"<<panda2 << endl;
     cout << "panda3\n"<<panda3<<endl;
     show(panda1);
     cout << int(panda2)<<endl;
     cout << panda3.operator int()<<endl;//转换函数应避免隐式转换 
     return 0;
    }

    在这里插入图片描述

    展开全文
  • 上机目的:练习友元函数重载运算符程序: /* * 程序版权和版本声明部分: * 作 者:烟台大学计算机学院学生:段元晋 * 完成日期:2013年4月19日 * 版 本 号:vc++6.0 * 对任务及求解方法描述部分: * ...

    上机目的:练习友元函数,重载运算符

    我的程序:

    /*  
    * 程序的版权和版本声明部分:   
    * 作    者:烟台大学计算机学院学生:段元晋
    * 完成日期:2013年4月19日
    * 版 本 号:vc++6.0
    * 对任务及求解方法的描述部分: 
    * 输入描述:无
    * 问题描述:略
    * 程序输出:略
    * 问题分析:略 
    * 算法设计:略  
    */    
    #include<iostream.h>
    class Complex  
    {
    public:  
    	Complex(){real=0;imag=0;}  
    	Complex(double r,double i){real=r;imag=i;}  
    	friend Complex operator+(Complex &c1,Complex &c2);  
    	friend Complex operator-(Complex &c1,Complex &c2);  
    	friend Complex operator*(Complex &c1,Complex &c2);  
    	friend Complex operator/(Complex &c1,Complex &c2);  
    	void display();  
    private:  
        double real;  
        double imag;  
    };
    Complex operator+(Complex &c1,Complex &c2)
    {
    	return Complex(c1.real+c2.real,c1.imag+c2.imag);
    }
    Complex operator-(Complex &c1,Complex &c2)
    {
    	return Complex(c1.real-c2.real,c1.imag-c2.imag);
    }
    Complex operator*(Complex &c1,Complex &c2)
    {
    	return Complex(c1.real*c2.real,c1.imag*c2.imag);
    }
    Complex operator/(Complex &c1,Complex &c2)
    {
    	return Complex(c1.real/c2.real,c1.imag/c2.imag);
    }
    
    void Complex::display()
    {
    	cout<<"("<<real<<","<<imag<<"i)"<<endl;
    }
    int main()  
    {  
        Complex c1(3,4),c2(5,-10),c3;  
        cout<<"c1=";  
        c1.display();  
        cout<<"c2=";  
        c2.display();  
        c3=c1+c2;  
        cout<<"c1+c2=";  
        c3.display();  
        c3=c1-c2;  
        cout<<"c1-c2=";  
        c3.display();  
        c3=c1*c2;  
        cout<<"c1*c2=";  
        c3.display();  
        c3=c1/c2;  
        cout<<"c1/c2=";  
        c3.display();  
        return 0;  
    }
    运行结果:



    展开全文
  • 一:使用友元函数的原因: 实现了类之间的共享,减少开销,提高系统的效率;(缺点是:破坏了类的封装性,能不用尽量不用)二:使用时机: 一般是:运算符的重载,数据的共享;三:使用方法 因为友元函数没有...

    http://blog.csdn.net/insistgogo/article/details/6608672

    一:使用友元函数的原因:
    实现了类之间的共享,减少开销,提高系统的效率;

    (缺点是:破坏了类的封装性,能不用尽量不用)

    二:使用时机:
    一般是:运算符的重载,数据的共享;

    三:使用方法
    因为友元函数没有this指针,则参数要有三种情况:

       1、  要访问非static成员时,需要`对象`做参数;--常用(友元函数常含有参数)
    
       2、  要访问static成员或全局变量时,则不需要对象做参数
    
       3、  如果做参数的对象是全局对象,则不需要对象做参数
    

    四:友元函数的分类:

    一:普通友元函数:使普通函数能够访问类的的友元。

    语法:声明位置:共有私有都可以;
    声明:friend + 普通函数声明;
    实现位置:可以在类外或者类中;
    实现代码:与普通代码相同(不过不用加friend和类::)
    调用:类似普通函数直接调用;

    class Student
    {
    public:
        friend void show();
    };
    
    void show()
    {
    cout<<"hello world"<<endl;
    }
    

    二:类Y 中的所欲成员函数都为类X中的一友元类

    目的:使用单个声明使得Y类中的所有函数成为类X的友元;

    声明:friend + 类名;
    
    class girl;
    
    class boy
    {
    private:
        char *name;
        int age;
    public:
        boy();
        void display(girl &);
    };
    
    void boy::display(girl &x)//函数是boy的成员函数,也是girl中的友元函数
    {
    }
    
    class giel
    {
    private:
    char name;
    int age;
    friend boy;//声明boy 是girl的友元
    public:
    girl();
    };
    
    void    main()
    {
    boy b;
    girl g;
    b.dis(g);
    }
    

    三:类Y的一个成员函数为类X的友元函数

    声明:friend +成员函数声明;

    友元函数和类的区别:友元函数没有this指针,类有,所以友元函数需要表明成员的出处;

    展开全文
  • 1.对双目运算符而言,成员函数重载运算符的函数参数表中只有一个参数,而用友元函数重载运算符函数参数表中含有两个参数。  对单木运算符来说,成员函数重载运算符的函数参数表中没有参数,而用友元函数重载运算符...
  • 问题及代码: /*。 ...*All right reserved, *文件名:test.cpp ...*问题描述:请用类的友元函数,定义复数类重载运算符+、-、*、/,使之能用于复数加减乘除 *输入描述: *程序输出: */ #include &lt;iost...
  • /*用友元成员函数重载运算符,实现+-的重载使之适用复数计算 */ #include<iostream> using namespace std; class complex{ private: double real,virt; public: complex(){} complex(double r,double v){ ...
  • 使用友元函数实现一元运算符的重载 实现一元运算符的前置重载 即++a;#include using namespace std;class Complex { private: int a; int b; public: Complex(int a= 0,int b = 0) { this->a = a; t
  • 使用友元函数重载运算符

    千次阅读 2018-10-05 21:41:01
    2. 为什么要用友元函数重载运算符?  首先如果是在类内重载运算符函数,都默认有一个 *this 指针,所以此时对二元运算符重载话只能放一个形参。  比如:  int A =0;  A = B * 5; // B是一个自定义...
  •  运算符重载允许把标准运算符(如+、—、*、/、等)应用于自定义数据类型对象,这样我们在用自己数据类型进行运算时,写出代码更直观易读。比如我们定义了了复数类Complex,重载了+-运算符之后我们就可以直接...
  • 大多数情况下,成员函数重载友元函数重载效果并无差别。例如这里我们以复数加法为例: #include using namespace std; class Complex { public:  Complex():real_(0),imag_(0){}  Complex...
  • 用成员函数重载运算符 1.当一元运算符操作数,或者二元运算符左操作数是类对象时,定义重载算符函数为成员函数。 2. 二元运算符op 如果要重载op 为类成员函数,使之能够实现表达式oprd1 op oprd2,其中...
  • 问题是在看C++primer plus 私有继承部分出现,按照书上代码,在VS2015中发现编译不通过,提示为无法访问类私有成员,该错误是在重载>>运算符时出现,而其他友元函数访问私有成员未出现错误。 解决方法:将>...
  • 我们知道,在运算符重载,友元函数运算符重载函数与成员运算符重载函数的区别是:友元函数没有this指针,而成员函数有,因此,在两个操作数的重载友元函数有两个参数,而成员函数只有一个。 因此...
  • 用成员函数和友元函数重载运算符

    千次阅读 2019-05-20 10:25:04
    友元函数和成员函数选择 1.当无法修改左操作数类时,使用...用友元函数重载<<、>>操作符 ostream& operator<<(ostream &out, Complex &c) istream& operator>>(istr...
  • +运算符的重载 : 加号运算符使用全局函数和成员函数都可以进行重载 左移运算符重载: 首先成员函数不可以做函数重载,只有成员函数才可以做左移<<运算符重载,其次是左移重载的时候传递两个...
  • /* ...*All rights reserved. *作者:王至超 *完成日期:2014年04月19 *版本号:v1.0 *问题描述: ...*问题分析:用简单方法,学会活学活用 */ #include using namespace std; class Complex { public: C
  • 友元函数重载运算符

    千次阅读 2013-09-05 13:57:02
    不知道你有没有看过iostream头文件,在iostream中,>>和操作符重载的时候就非常特殊,因为它们本身是一个类,你在重载了以后就必须是用友元函数来调用访问,这里就有一个问题了,一个类里面是可以定义另一个类...
  • 今天在写单向链表实现线性表时候打算重载输出运算符用来将线性表输出,结果无奈又遇到了问题。 大致代码如下 template class chainList : public linearList ...//友元函数实现实现 template
  • 编译器:VS2015问题:当我使用友元函数重载运算符 << 时,编译器报错不能访问私有成员,使用友元函数对其他运算符重载时则没有这样的问题,如图:上网查资料后发现有两种解决办法。第一种是将运算符重载函数的...
  • 重载 重载运算符目的:使对象操作...一类:成员函数重载运算符 显式调用一个参数,隐式调用一个参数 Time Time::operator+(const Time& b); 二类:非成员函数重载运算符 显式调用两个个参数 Time operator+(...
  • c++知识点----友元函数重载运算符

    千次阅读 2017-09-29 21:09:45
    友元函数重载运算符“+”,使两个对象real相加,imag相加。输出相加后对象值加以验证 使用到文件 main.cpp #include using namespace std; #include "class.h" int main() { complex
  • /* * 程序的版权和版本声明部分 ... * All rightsreserved. * 文件名称: array.cpp * 作 者: 刘江 ...* 完成日期:2013年4月15日 ...* 问题描述:运算符的重载,用类的友元函数 */ #include using nam

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,241
精华内容 896
关键字:

友元函数的重载运算符