0821，友元函数，运算符重载（好好好，

已于 2024-08-23 14:09:59 修改
阅读量880 收藏 16
点赞数 19
分类专栏： 我爱学习 文章标签： c++ 开发语言
于 2024-08-21 16:56:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51583806/article/details/141393558
版权

目录

001_friend.cc

002_friend.cc

003_friend.cc

004_complex.cc     Complex pt3=operator+(pt1,pt2)

005_complec.cc     Complex pt3=pt1.operator+(pt2)

006_operator_=.cc

007_operator=.cc

008_operator++.cc

作业：

01 关于友元的描述中，(  )是错误A

02 下面对于友元函数描述正确的是（   ） C

03 友元的作用是（   ） A

04 如果类A被声明成类B的友元，则（      ）。(多选题)       BDE

05 写出下列程序的结果    33 88

06 什么是友元？友元的存在形式有？友元有何特点？

07 运算符重载的原则是什么？有哪些规则？不能重载的运算符有哪几个？

08 用运算符重载方式实现Complex类对象的+、-、+=、-=、自增、自减操作

09 编写Base类使下列代码输出为1，提示：本题考查的其实就是运算符重载的知识点。

001_friend.cc

#include <iostream>
#include <math.h>
using std::cout;
using std::endl;

class Point{
public:
    Point(int x,int y)
        :_ix(x),_iy(y)
    {}
    friend double distance(const Point & p1,const Point & p2);
private:
    int _ix;int _iy;
};


double distance(const Point & p1,const Point & p2){
    return sqrt(pow(p1._ix-p2._ix,2)+
                pow(p1._iy-p2._iy,2));
}

void test(){
    Point pt1(0,0);
    Point pt2(3,4);
    cout<<distance(pt1,pt2)<<endl;
}

int main(void)
{
    test();
    return 0;
}

002_friend.cc

#include <iostream>
#include <math.h>
using std::cout;
using std::endl;

class Point;//前向声明
            //可以利用POint引用或者point指针

class Line{
    public:
        double distance(const Point & p1,const Point & p2);
        void setPoint(Point & p1);
        /* double distance(const Point & p1,const Point & p2){ */
        /*     return sqrt(pow(p1._ix-p2._ix,2)+ */
        /*             pow(p1._iy-p2._iy,2)); */
        /* }//坏，报错,不知道具体实现喵 */
};

class Point{
public:
    Point(int x,int y)
        :_ix(x),_iy(y)
    {}
    friend double Line::distance(const Point & p1,const Point & p2);
    friend void Line::setPoint(Point & p1);
private:
    int _ix;int _iy;
};


double Line::distance(const Point & p1,const Point & p2){
    return sqrt(pow(p1._ix-p2._ix,2)+
                pow(p1._iy-p2._iy,2));
}
void Line::setPoint(Point & p1){
    p1._ix=100;
}

void test(){
    Point pt1(0,0);
    Point pt2(3,4);
    Line ll;
    cout<<ll.distance(pt1,pt2)<<endl;
    ll.setPoint(pt1);
    cout<<ll.distance(pt1,pt2)<<endl;
}

int main(void)
{
    test();
    return 0;
}

003_friend.cc

#include <iostream>
#include <math.h>
using std::cout;
using std::endl;

class Point;//前向声明

class Line{
    public:
        double distance(const Point & p1,const Point & p2);
        void setPoint(Point & p1);
};

class Point{
public:
    Point(int x,int y)
        :_ix(x),_iy(y)
    {}
    friend class Line;//友元类
private:
    int _ix;int _iy;
    //坏 将Point 用C语言的方式强转指针，理解为两个int类型的数组
};


double Line::distance(const Point & p1,const Point & p2){
    return sqrt(pow(p1._ix-p2._ix,2)+
                pow(p1._iy-p2._iy,2));
}
void Line::setPoint(Point & p1){
    p1._ix=100;
    p1._iy=100;
}

void test(){
    Point pt1(0,0);
    Point pt2(3,4);
    Line ll;
    cout<<ll.distance(pt1,pt2)<<endl;
    ll.setPoint(pt1);
    cout<<ll.distance(pt1,pt2)<<endl;
}

int main(void)
{
    test();
    return 0;
}

004_complex.cc     Complex pt3=operator+(pt1,pt2)

#include <iostream>
using std::cout;
using std::endl;

class Complex{
public:
    Complex(int real,int image)
        :_real(real),_image(image)
    {}
    void print(){
        cout<<_real<<"+"<<_image<<"i"<<endl;
    }
    /* int getImage()const{return _image;} */
    /* int getReal()const{return _real;} */
    friend Complex operator+(const Complex & c1,const Complex & c2);
private:
    int _real;int _image;
};
//友元函数形式实现
//ababa  别用  抽风小辉   aaaaaaaa可以用
Complex operator+(const Complex & c1,const Complex & c2){
    return Complex(c1._real+c2._real,c1._image+c2._image); 
}
//普通函数实现
/* Complex operator+(const Complex & c1,const Complex & c2){ */
/*     return Complex(c1.getReal()+c2.getReal(),c1.getImage()+c2.getImage()); */ 
/* }//破坏性更强喵！ */
void test(){
    Complex c1(3,4);
    Complex c2(6,1);
    c1.print();c2.print();
    Complex c3=c1+c2;
    c3.print();
}

int main(void)
{
    test();
    return 0;
}

005_complec.cc     Complex pt3=pt1.operator+(pt2)

#include <iostream>
using std::cout;
using std::endl;

class Complex{
public:
    Complex(int real,int image)
        :_real(real),_image(image)
    {}
    void print(){
        cout<<_real<<"+"<<_image<<"i"<<endl;
    }
    //成员函数形式实现
    //成员函数  一个参数， 其他多个
    Complex operator+(const Complex & c1){
        return Complex(c1._real+_real,c1._image+_image); 
    }
private:
    int _real;int _image;
};
void test(){
    Complex c1(3,4);
    Complex c2(6,9);
    c1.print();c2.print();
    Complex c3=c1+c2;
    c3.print();
}

int main(void)
{
    test();
    return 0;
}

006_operator_=.cc

#include <iostream>
using std::cout;
using std::endl;

class Complex{
public:
    Complex(int real,int image)
        :_real(real),_image(image)
    {}
    void print(){
        cout<<_real<<"+"<<_image<<"i"<<endl;
    }
    Complex operator+(const Complex & c1){
        return Complex(c1._real+_real,c1._image+_image); 
    }
    //不修改操作数的--》友元   修改操作数的--》成员
    //希望自定义类型在操作时和内置类型一样
    Complex & operator +=(const Complex & c1){
        this->_real+=c1._real;
        this->_image+=c1._image;
        return *this;
    }
private:
    int _real;int _image;
};
void test(){
    Complex c1(3,4);
    Complex c2(6,9);
    c1.print();c2.print();
    Complex c3=c1+c2;
    c3.print();

    c1+=c3;
    c1.print();
}

int main(void)
{
    test();
    return 0;
}

007_operator=.cc

#include <iostream>
using std::cout;
using std::endl;

class Complex{
public:
    Complex(int real,int image)
        :_real(real),_image(image)
    {}
    void print(){
        cout<<_real<<"+"<<_image<<"i"<<endl;
    }
    Complex operator+(const Complex & c1){
        return Complex(c1._real+_real,c1._image+_image); 
    }
    Complex & operator +=(const Complex & c1){
        this->_real+=c1._real;
        this->_image+=c1._image;
        return *this;
    }
    Complex & operator =(const Complex & c1){
        this->_real=c1._real;
        this->_image=c1._image;
        return *this;
    }
    //重载
    Complex & operator =(int c1){
        this->_real=c1;
        this->_image=c1;
        return *this;
    }
private:
    int _real;int _image;
};
void test(){
    Complex c1(3,4);
    Complex c2(6,9);
    c1.print();c2.print();
    Complex c3=c1+c2;
    c3.print();

    c1+=c3;
    c1.print();
    c3=c1;
    c3.print();
    c3=250;
    c3.print();
}

int main(void)
{
    test();
    return 0;
}

008_operator++.cc

#include <iostream>
using std::cout;
using std::endl;
class B 
{  
    int y;
public:
    friend class  A;
};

class A
{ 
    int x;
public:  
    A(int a,B &rrrr, int b)  
    {
	x=a; 
	rrrr.y=b;
    } 
     
    void Display( B & ); 
};

void A::Display(B &rrrr)
{
    cout<<x<<" "<<rrrr.y<<endl;
}

int main( )
{   
    B Obj2;
    
    A Obj1(33, Obj2, 88);
    //x=33,y=88
    
    Obj1.Display(Obj2);
    //33 88
    return 0;
}

作业：

01 关于友元的描述中，(  )是错误A

  • A友元函数是成员函数，它被说明在类体内

  • B友元函数可直接访问类中的私有成员

  • C友元函数破坏封装性，使用时尽量少用

  • D友元类中的所有成员函数都是友元函数

02 下面对于友元函数描述正确的是（   ） C

  • A友元函数的实现必须在类的内部定义 ×

  • B友元函数是类的成员 ×

  • C友元函数破坏了类的封装性和隐藏性

  • D友元函数不能访问类的私有成员 ×

03 友元的作用是（   ） A

  • A提高程序的运行效率

  • B加强类的封装性

  • C实现数据的隐蔽

  • D加成员函数的种类

04 如果类A被声明成类B的友元，则（      ）。(多选题)       BDE(坏，DE

  • A类A的成员即类B的成员     （不对，B不能访问A,坏！，给我看晕了

  • B类B的成员即类A的成员   （对

  • C类A的成员函数不能访问类B的成员   （能

  • D类A的成员函数可以访问类B的成员     （是哒

  • E类B不一定是类A的友元    （对！

05 写出下列程序的结果    33 88

class B 
{  
    int y;
public:
    friend class  A;
};
class A
{ 
    int x;
public:  
    A(int a,B &r, int b)  
    {
	x=a; 
	r.y=b;
    } 
     
    void Display( B & ); 
};
void A::Display(B &r)
{
    cout<<x<<" "<<r.y<<endl;
}

int main( )
{   
    B Obj2;
    
    A Obj1(33, Obj2, 88);
    
    Obj1.Display(Obj2);
    return 0;
}

06 什么是友元？友元的存在形式有？友元有何特点？

1，将其他类/函数这是为一个类的友元，那么友元类/函数就可以在前一个类的类定义之外访问其私有成员了

2，普通函数形式，成员函数形式，友元类

3，特点
——友元不受类中访问权限的限制（可以访问私有
——破坏了类的封装性
——不能滥用
——单向的（A有B的钥匙，B没有A的钥匙
——不传递
——不继承

07 运算符重载的原则是什么？有哪些规则？不能重载的运算符有哪几个？

1，原则
希望自定义类型在操作时和内置类型保持一致

2，规则
01，操作数类型，必须要有自定义类型或枚举类型，不能全是内置类型
02，优先级结合性，不变
03，操作数个数，不变
04，参数，不能设置默认参数（设置默认值，就是改变了操作数个数
05，逻辑与&& 逻辑或|| 不再具备短路求值特性，进入函数体之前必须完成所有函数参数得计算，不推荐重载
06，不能重载内置不存在的运算符

3，带点的+sizeof
.成员访问运算符
.*成员指针访问运算符
？：三目运算符
：：作用域限定符
sizeof长度运算符

08 用运算符重载方式实现Complex类对象的+、-、+=、-=、自增、自减操作

#include <iostream>
using std::cout;
using std::endl;

class Complex{
public:
    Complex(int real,int image)
        :_real(real),_image(image)
    {}
    void print(){
        cout<<_real<<"+"<<_image<<"i"<<endl;
    }
    Complex operator+(const Complex & c1){
        return Complex(c1._real+_real,c1._image+_image); 
    }
    Complex operator-(const Complex & c1){
        return Complex(_real-c1._real,_image-c1._image); 
    }
    Complex & operator +=(const Complex & c1){
        this->_real+=c1._real;
        this->_image+=c1._image;
        return *this;
    }
    Complex & operator -=(const Complex & c1){
        this->_real-=c1._real;
        this->_image-=c1._image;
        return *this;
    }
    Complex & operator =(const Complex & c1){
        this->_real=c1._real;
        this->_image=c1._image;
        return *this;
    }
    Complex & operator =(int c1){
        this->_real=c1;
        this->_image=c1;
        return *this;
    }
    Complex & operator++(){
        cout<<"<<<<<<<<++complex"<<endl;
        this->_real++;
        this->_image++;
        return *this;
    }
    Complex  operator++(int){
        cout<<"<<<<<<complex++"<<endl;
        Complex cx(_real,_image);
        this->_real++;
        this->_image++;
        return cx;
    }
    Complex & operator--(){
        cout<<"<<<<<<<<   --complex"<<endl;
        this->_real--;
        this->_image--;
        return *this;
    }
    Complex  operator--(int){
        cout<<"<<<<<<    complex--"<<endl;
        Complex cx(_real,_image);
        this->_real--;
        this->_image--;
        return cx;
    }
private:
    int _real;int _image;
};
void test(){
    Complex c1(3,4);
    Complex c2(6,9);
    c1.print();c2.print();
    Complex c3=c1+c2;
    c3.print();
    //c2.operator-(c1)
    c3=c2-c1;
    c3.print();

    cout<<endl;
    c1+=c3;
    c1.print();
    c1-=c3;
    c1.print();


    cout<<endl;
    c3=c1;
    c3.print();
    c3=250;
    c3.print();

    cout<<endl;
    (++c3).print();
    (c3++).print();
    c3.print();

    cout<<endl;
    (--c3).print();
    (c3--).print();
    c3.print();
}

int main(void)
{
    test();
    return 0;
}

09 编写Base类使下列代码输出为1，提示：本题考查的其实就是运算符重载的知识点。

int i=2;
int j=7;

Base x(i);
Base y(j);
cout << (x+y == j - i) << endl;
#include <iostream>
using std::cout;
using std::endl;
/* 编写Base类使下列代码输出为1 */

class Base{
public:
    Base(int b)
        :_b(b)
    {}
    Base operator+(const Base & b){
        return Base(b._b-_b);
    }
    bool operator==(int num){
        return _b==num;
    }
private:
    int _b;
};
void test(){

    int i=2;
    int j=7;

    Base x(i);
    Base y(j);
    //x+y =  i+j?? -x+y 
    cout << (x+y == j - i) << endl;
}

int main(void)
{
    test();
    return 0;
}

qq_51583806 彩雷王
关注
  • 19
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
运算符重载之友元运算符重载
aaqian1的博客
01-05 9963
友元可以参考：https://blog.csdn.net/aaqian1/article/details/84427884 友元运算符重载函数： 把运算符重载函数定义为某个类的友元函数。 1、定义友元运算符重载函数的语法形式 （1）在类的内部，定义友元运算符重载函数的格式如下： friend 函数类型 operator 运算符(形参表) { 函数体 } （2）友元运算符重载函数也可以在类中声明...
C++运算符重载 成员函数与友元函数详解
09-05
成员函数和友元函数是两种不同的方法，可以用来实现运算符重载。 **成员函数重载** 成员函数重载是指将运算符作为类的一个成员函数来实现。这样，运算符的操作数之一通常是当前对象（`this`指针）。例如，在上述...
友元函数的运算符重载
m0_68738982的博客
05-21 578
友元函数用于运算符重载时，可以访问类的私有和保护成员。这在一些情况下非常有用，特别是当需要访问多个类的私有成员时。例如，实现两个类对象之间的加法运算，或者实现全局运算符函数。
C++ 友元函数重载运算符 ＜＜
既然选择了远方 便只顾风雨兼程 - 永强
07-14 978
C++ 友元函数重载运算符
C++基础篇 第三天 友元和运算符重载
southernbrid的博客
05-05 364
友元函数是一种特殊类型的函数，它能够访问类的私有成员和保护成员。这意味着，即使这些成员被声明为私有或保护的，友元函数也可以在类外部直接访问它们。友元函数的作用主要有以下几个方面：提高程序的效率：如果某个函数需要频繁地访问类的私有成员或保护成员，将其声明为友元函数可以避免通过类的公共接口来访问这些成员，从而提高程序的效率。增加代码的灵活性：友元函数可以访问类的私有成员和保护成员，这使得在某些情况下可以更方便地实现某些功能。
友元函数和运算符重载
kerela的博客
04-30 1545
友元：非类成员函数可以访问类的非公有成员（protected,private） 工程作用：提高程序运行效率（省去了函数调用返回等一系列时间） 友元的种类分为：友元函数，友元类（不传递，不继承，单向的），友元成员函数 类前置声明必须将类的成员函数类外实现（A放在Test上面） 含有友元成员函数的类必须在代码最前 运算符重载实际上就是函数的重载 运算符重载的特点：直观自然，提高程序的可读性 运算符重载规则： 1.特殊运算符：如果没有重载，且没有移动拷贝构造函数，系统会默认重载；必须以成员函数重载 2.注意：默认
C++运算符重载函数作为友元函数
LC的专栏
10-25 2277
如果将运算符重载函数作为成员函数，它可以通过 this 指针自由地访问本类的成员变量，因此，可以少写一个函数的参数，但是，必须要求运算表达式的第一个参数（即运算符左侧的操作数）是一个类对象，而且，与运算符函数的类型相同。实际上，运算符重载函数有两个参数，由于重载函数是my_string类中的成员函数，所以，有一个参数是隐含的，运算符函数是用this指针隐式地访问类对象的成员，可以看到，重载函数operator + ();访问了两个对象中的成员，一个是this指针指向的对象中的成员，一个是形参对象中的成员。
C++友元和运算符重载
nnan77的博客
03-11 1743
C++友元和运算符重载
运算符重载和友元函数
tyq20010606的博客
03-12 344
运算符重载与友元函数
【C++ | 重载运算符】一文弄懂C++运算符重载，怎样声明、定义运算符，重载为友元函数
wkd_007的博客
06-21 2774
👉本文主要介绍了为什么需要重载运算符，重载运算符有哪些限制，怎样声明、定义运算符函数，怎样将运算符重载为友元函数。
（B站黑马C++）友元 + 运算符重载
IT OR 考公？
05-31 905
C++语法糖，黑马C++，1.5倍速跟着敲
3.2+友元函数实现运算符重载1
08-03
本文将深入探讨如何使用成员函数和友元函数来实现运算符重载，特别是在面向对象方法与C++程序设计中。 首先，当我们谈论运算符重载时，目标是使运算符能作用于我们自定义的数据类型，如类的对象。在给定的描述中，...
c++ demo，重载运算符，友元函数的实现
01-24
总结来说，C++的运算符重载提供了定制运算符行为的能力，而友元函数则允许非成员函数访问类的私有和受保护成员，两者结合使用能更好地实现面向对象的设计。在实际编程中，正确使用这两个特性可以增强代码的表达力，...
解析C++中不能重载为友元函数的四个运算符
09-05
在C++编程语言中，运算符重载是一种强大的特性，允许程序员为自定义类型赋予特定的行为，使得这些类型能够按照类似内置类型的方式进行操作。然而，并非所有的运算符都可以通过友元函数进行重载。本篇文章将深入探讨...
C++匿名函数lamba简介
yao_tao11的博客
08-18 663
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
C++(11)类语法分析(2)
Once_day的回忆
08-17 1221
Author：Once Day Date：2024年8月17日漫漫长路，才刚刚开始…全系列文章请查看专栏: 源码分析_Once-Day的博客-CSDN博客参考文档:基础类的介绍请参考文章：C++(10)类语法分析(1)-CSDN博客运算符重载是C++的一个强大特性，它允许为用户定义的类型自定义运算符的行为。通过运算符重载，我们可以使自定义类型的对象支持各种运算符，如算术运算符、比较运算符、输入输出运算符等，从而提高代码的可读性和表现力。运算符重载的语法，运算符重载的实现方式是定义一个特殊的成员函数或全局函数
C语言：文件（写入，读取）
最新发布
2301_80311224的博客
08-21 579
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
C语言——函数递归
2406_83392683的博客
08-18 399
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
Linux--C语言之动态内存分配
2201_75773226的博客
08-18 1149
void：是空类型，是数据类型的一种void*：是指针类型，是指针类型的一种，可以匹配任意类型的指针，类似于通配符。
为什么使用友元函数运算符重载
12-23
使用友元函数运算符重载的原因是为了能够访问类的私有成员。运算符函数需要访问类对象中的成员，如果运算符函数不是类的友元函数，它就没有权限访问类的私有成员。因此，将运算符函数定义为友元函数可以解决这个问题。 另外，友元函数的使用确实会破坏类的封装性，因为它可以直接访问类的私有成员。为了保持类的封装性，一般将单目运算符重载为成员函数，将双目运算符重载为友元函数。这样可以在一定程度上限制对类的私有成员的访问。 总结起来，使用友元函数运算符重载的主要原因是为了能够访问类的私有成员，但同时也需要注意保持类的封装性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值