2 C++ 运算符重载

最新推荐文章于 2022-07-06 19:53:15 发布
最新推荐文章于 2022-07-06 19:53:15 发布
阅读量145 收藏
点赞数
分类专栏： C++

1运算符重载：（本质：函数调用）

全局函数重载：二元 若需要调用私有成员变量 友元函数

//全局函数 重载+运算符 在类中友元函数
friend Complex operator+(Complex &c1, Complex &c2);

// 友元函数
Complex operator+(Complex &c1, Complex &c2)
{
    Complex tmp(c1.a + c2.a, c1.b+ c2.b);
    return tmp; //
}

Complex c4 = c1 + c2;

成员函数重载：如果成员函数重载运算符，那么+号的左边是this,参数是+号的右边

//成员函数法 实现 -运算符重载
Complex operator-(Complex &c2)
    {
        Complex tmp(this->a - c2.a, this->b - c2.b);
        return tmp;
    }

Complex c4 = c1 - c2;

2运算符重载的步骤：
1.要承认运算符重载是一个函数，写出函数名
2.根据操作数，写出函数参数
3.根据业务需要完善返回值（引用（当左值），指针，元素）

前置++操作符 用全局函数实现
++c1;

//前置++ 访问私有成员  友元函数
    friend Complex& operator++(Complex &c1);
//前置++
Complex& operator++(Complex &c1)
{
    c1.a++;
    c1.b++;
    return c1;
}

前置–操作符 成员函数方法
–c1;

 //前置--
    Complex& operator--()
    {
        this->a --;
        this->b --;
        return *this;
    }

后置++操作符 用全局函数实现
函数返回值不是函数重载的必要条件

//后置++ 访问私有成员  友元函数
friend Complex operator++(Complex &c1, int);
//后置++
Complex operator++(Complex &c1, int)、、占位参数
{
    //先使用 在让c1加加
    Complex tmp = c1;
    //return c1;
    c1.a ++;
    c1.b ++;
    return tmp;
}

后置–操作符 用成员函数实现

    //后置--
    Complex operator--(int)
    {
        Complex tmp = *this;
        this->a--;
        this->b--;
        return tmp;
    }

#include <iostream>
using namespace std;

class Complex
{
private:
    int a;
    int b;
    //全局函数 重载+运算符
    friend Complex operator+(Complex &c1, Complex &c2);
    //重载 前置++
    friend Complex& operator++(Complex &c1);
    friend Complex operator++(Complex &c1, int);
public:
    Complex(int a=0, int b=0)
    {
        this->a = a;
        this->b = b;
    }
    void printCom()
    {
        cout<<a<<" + " << b << "i" <<endl;
    }
public:

    //成员函数法 实现 -运算符重载
     Complex operator-(Complex &c2)
    {
        Complex tmp(this->a - c2.a, this->b - c2.b);
        return tmp;
    }

     //前置--
    Complex& operator--()
    {
        this->a --;
        this->b --;
        return *this;
    }

    //后置--
    Complex operator--(int)
    {
        Complex tmp = *this;
        this->a--;
        this->b--;
        return tmp;
    }
};

//全局函数法 实现 + 运算符重载
Complex operator+(Complex &c1, Complex &c2)
{
    Complex tmp(c1.a + c2.a, c1.b + c2.b);
    return tmp;
}

//前置++
Complex& operator++(Complex &c1)
{
    c1.a++;
    c1.b++;
    return c1;
}

//后置++
Complex operator++(Complex &c1, int)
{
    //先使用 在让c1加加
    Complex tmp = c1;
    //return c1;
    c1.a ++;
    c1.b ++;
    return tmp;
}

/*
全局函数、类成员函数方法实现运算符重载步骤
    1）要承认操作符重载是一个函数，写出函数名称
    2）根据操作数，写出函数参数 
    3）根据业务，完善函数返回值(看函数是返回引用 还是指针 元素)，及实现函数业务
*/
void main()
{
    Complex c1(1, 2), c2(3, 4);


    //1 全局函数法 实现 + 运算符重载
    // Complex operator+(Complex &c1, Complex &c2);
    Complex c3 = c1 + c2;
    c3.printCom();

    //2 成员函数 法 实现 -运算符重载
    //c1.operator-(c2);
    //Complex operator-(Complex &c2)
    Complex c4 = c1 - c2;
    c4.printCom();

    //前置++操作符 用全局函数实现
    ++c1;
    c1.printCom();

    //前置--操作符 成员函数方法
    --c1;
    c1.printCom();
    //Complex& operator++(Complex &c1)
    //c1.operator--();

    //后置++操作符 用全局函数实现
    c1++;
    c1.printCom();

    //后置--操作符 用成员函数实现
    c1--;
    c1.printCom();
    //c1.operator--()

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

成员函数 运算符重载


#include <iostream>
using namespace std;

class Complex
{
private:
    int a;
    int b;
public:
    Complex(int a=0, int b=0)
    {
        this->a = a;
        this->b = b;
    }
    void printCom()
    {
        cout<<a<<" + " << b << "i" <<endl;
    }
public:

    //实现 + 运算符重载
    Complex operator+(Complex &c2)
    {
        Complex tmp(a + c2.a, b + c2.b);
        return tmp;
    }

    //前置++
    Complex& operator++()
    {
        a++;
        b++;
        return *this;
    }

    //后置++
    Complex operator++(int)
    {
        //先使用 在让c1加加
        Complex tmp = *this;
        //return c1;
        this->a ++;
        this->b ++;
        return tmp;
    }
    //成员函数法 实现 -运算符重载
     Complex operator-(Complex &c2)
    {
        Complex tmp(this->a - c2.a, this->b - c2.b);
        return tmp;
    }

     //前置--
    Complex& operator--()
    {
        this->a --;
        this->b --;
        return *this;
    }

    //后置--
    Complex operator--(int)
    {
        Complex tmp = *this;
        this->a--;
        this->b--;
        return tmp;
    }
};


void main()
{
    Complex c1(1, 2), c2(3, 4);

    //1 全局函数法 实现 + 运算符重载
    // Complex operator+(Complex &c1, Complex &c2);
    Complex c3 = c1 + c2;
    c3.printCom();

    //2 成员函数 法 实现 -运算符重载
    //c1.operator-(c2);
    //Complex operator-(Complex &c2)
    Complex c4 = c1 - c2;
    c4.printCom();

    //前置++操作符 用全局函数实现
    ++c1;
    c1.printCom();

    //前置--操作符 成员函数方法
    --c1;
    c1.printCom();
    //Complex& operator++(Complex &c1)
    //c1.operator--();

    //后置++操作符 用全局函数实现
    c1++;
    c1.printCom();

    //后置--操作符 用成员函数实现
    c1--;
    c1.printCom();
    //c1.operator--()

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

运算符重载 友元函数的使用

//2 函数返回值当左值 需要返回一个引用

friend ostream& operator<<(ostream &out, Complex &c1);

ostream& operator<<(ostream &out, Complex &c1)
{

    out<<c1.a << " + " << c1.b << "i" << endl;
    return out;
}
//2 函数返回值当左值 需要返回一个引用
    cout << c1  << "aaddddd";

友元函数重载操作符使用注意点
a）友员函数重载运算符常用于运算符的左右操作数类型不同的情况
这里写图片描述
在第一个参数需要隐式转换的情形下，使用友员函数重载运算符是正确的选择
友员函数没有 this 指针，所需操作数都必须在参数表显式声明，很容易实现类型的隐式转换
 C++中不能用友员函数重载的运算符有
= （） ［］ －>

=号操作符重载


#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>
using namespace std;

//

class  Name
{
public:
    Name(const char *myp)
    {
        m_len = strlen(myp);
        m_p =(char *) malloc(m_len + 1); //
        strcpy(m_p, myp);
    }

    //Name obj2 = obj1;
    //解决方案: 手工的编写拷贝构造函数 使用深copy
    Name(const Name& obj1)
    {
        m_len = obj1.m_len;
        m_p = (char *)malloc(m_len + 1);
        strcpy(m_p, obj1.m_p);
    }

    //obj3 = obj1;  // C++编译器提供的 等号操作 也属 浅拷贝
    //obj3.operator=(obj1)

    Name& operator=(Name &obj1)
    {
        //先释放旧的内存
        if (this->m_p != NULL)
        {
            delete[] m_p;
            m_len = 0;
        }
        //2 根据obj1分配内存大小
        this->m_len = obj1.m_len;
        this->m_p = new char [m_len+1];

        //把obj1赋值
        strcpy(m_p, obj1.m_p);
        return *this;
    }

    ~Name()
    {
        if (m_p != NULL)
        {
            free(m_p);
            m_p = NULL;
            m_len = 0;
        }
    }
protected:
private:
    char *m_p ;
    int m_len; 
};

//对象析构的时候 出现coredump
void objplaymain()
{
    Name obj1("abcdefg");
    Name obj2 = obj1;  //C++编译器提供的 默认的copy构造函数  浅拷贝
    Name obj3("obj3");

    obj3 = obj1;  // C++编译器提供的 等号操作 也属 浅拷贝
    //obj3.operator=(obj1)
    //operato=(Name &obj1)

    obj1 = obj2 = obj3;
    //obj2.operator=(obj3);
    //obj1 = void;
}

void main()
{
    objplaymain();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

【】

int& Array::operator[](int i)
{
    return m_space[i];
}

=

//a3 = a1;
Array& Array::operator=(Array &a1)
{
    //1 释放原来的内存空间
    if (this->m_space != NULL)
    {
        delete [] m_space;
        m_length = 0;
    }
    //2 根据a1大小 分配内存 
    m_length = a1.m_length;
    m_space = new int[m_length];

    //3 copy数据
    for (int i=0; i<m_length; i++)
    {
        //m_space[i] = a1.m_space[i];
        m_space[i] = a1[i];
    }

    return *this;
}

==

//if (a3 == a1)
bool Array::operator==(Array &a1)
{
    if (this->m_length !=  a1.m_length)
    {
        return false;
    }

    for (int i=0; i<m_length; i++)
    {
        if (this->m_space[i] != a1[i])
        {
            return false;
        }
    }
    return true;
}
沉城
关注
专栏目录
c++运算符重载
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-15 380
1概念 什么是运算符重载 所谓重载，就是重新赋予新的含义。函数重载就是对一个已有的函数赋予新的含义，使之实现新功能，因此，一个函数名就可以用来代表不同功能的函数，也就是”一名多用”。 运算符也可以重载。实际上，我们已经在不知不觉之中使用了运算符重载。例如，大 家都已习惯于用加法运算符”+”对整数、单精度数和双精度数进行加法运算，如5+8， 5.8 +3.67等，其实计算机对整数、单精度数和双精度数的加法操作过程是很不相同的， 但由于C++已经对运算符”+”进行了重载，所以就能适用于int, float,
C++运算符重载总结
最新发布
wo_ai_luo_的博客
11-10 1294
一定要自定义一个拷贝构造函数，这样在重载运算符返回对象副本的时候，编译器会自动调用拷贝构造函数，否则会出现结果错误。把‘=’运算符重载为类成员变量，并且将返回值设计成为该类的引用。除了‘=’运算符以外，其他的运算符重载最好设计成为友元函数。这就是我们今天要讲的运算符重载的总结.友元关系不会被派生类继承。
构造函数和一般函数（2）重载
北京小辉
11-05 486
重载 （1） 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。（2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。（3） 重载的时候，方法名要一样，但
+操作符重载（2）
weixin_33730836的博客
12-09 63
2019独角兽企业重金招聘Python工程师标准>>> ...
运算符重载知识点
xmy1994224的博客
05-27 320
知识点可重载运算符/不可重载运算符下面是可重载的运算符列表：双目算术运算符     + (加)，-(减)，*(乘)，/(除)，% (取模)关系运算符     ==(等于)，!= (不等于)，&lt; (小于)，&gt; (大于&gt;，&lt;=(小于等于)，&gt;=(大于等于)逻辑运算符     ||(逻辑或)，&amp;&amp;(逻辑与)，!(逻辑非)单目运算符     + (正)，-(负...
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
C++运算符重载
m0_66444993的博客
07-06 3101
目录一、运算符重载的概念 二、成员函数重载三、友元函数重载四、 特殊符号型的重载-- > 输入和输出流一般作为友元重载，不能作为成员函数重载1、是什么运算符重载指的是重载系统内部的运算符函数，是实现类静态多态性的方式之一。它本质上是函数重载。2、为什么我们平常常见的算术运算符、逻辑运算符等运算符都是系统库函数里面已经存在的，所以运算符可以直接用于我们常用的数据类型。然而对于我们自定义的类实例化的对象，系统没有与之相关的运算符可以操作，但是为了使我们编写程序时更加便捷，C++提供了一种方式——运算符重...
C++运算符重载 成员函数与友元函数详解
12-31
代码如下:#include<iostream>using namespace std;class A{ int x,y; public: A(int xx,int yy):x(xx),y(yy){} A(){x=0;y=0;} A operator+(const A&b) //不加const限定，也可以 { return A(x+b.x,y+b.y);...
C++ 学习笔记二 重载
u012122838的博客
10-22 84
1.实质是用同样的名字再定义一个有着不同参数但有着同样用途的函数。（可以是参数个数上的不同，也可以是参数数据类型上的不同） 注：对函数进行重载，可以简化编程工作和提高代码可读性。 2.重载不是一个真正的面向对象的特征，它只是可以简化编程工作的一种方案。（而简化工作正是C++语言的全部追求！） 注：函数即方法，变量即属性 3.对函数进行重载的目的是为了方便对不同数据类型进行同样的处理。（对函...
【C++】5.2 运算符重载（二）——"++"和“--”的重载
Alvin的博客
09-23 308
5.2 运算符重载 5.2.5 "++"和"--"的重载 1、使用成员函数以前缀方式和后缀方式重载运算符“--” 【示例】 #include<iostream> using namespace std; class Three{ public: Three(int I1=0,int I2=0,int I3=0); //声明构造函数 void print(); ...
运算符重载
weixin_46027560的博客
02-07 129
一.基本运算符重载 1.不能重载的运算符：. :: ?: sizeof 2.返回值类型 operator+(){} 3.因为这个运算符重载是在类中，this指针要占一个参数 4."+"重载 int operator+() { #include <iostream> using namespace std; class student { int a; public: student...
++和--的重载
qq_42644428的博客
09-10 454
#include<iostream> using namespace std; class Three { private: int m_a1; int m_a2; int m_a3; public: Three(int a1 = 0, int a2 = 0, int a3 = 0) //缺省构造函数 { m_a1 = a1; m_a2 = a2; m_a3 ...
++重载、--重载实例
Cristina的博客
11-26 291
#include<iostream> using namespace std; class MyClass { friend ostream& operator<<(ostream&cout, MyClass a); public: MyClass(); //前置++ //返回引用是为了一直对一个数据进行递增操作 MyClass& operator++() { num++; return *this; } //后置++ //in
C++进阶2：重载原理分析
weixin_42278523的博客
07-17 525
1. 基本原理知识 函数重载：在相同作用域中的多个函数，具有相同的名字而形参表不同。 不能仅仅基于不同的返回类型而实现函数重载。返回值是不影响函数签名的。 C++函数重载底层实现原理是C++利用name mangling(倾轧)技术，来改名函数名，区分参数不同的同名函数。 编译器通过函数名和其参数类型识别重载函数。为了保证类型安全的连接（type-safe linkage），编译器用参数个数和参数类型对每一个函数标识符进行专门编码，这个过程有时称为“名字改编”（name mangling）或“名字修饰”（n
关于C++前置++及后置++重载的问题
River的博客
03-09 2718
先了解一些名词的实质意义： 临时变量：True temporary objects in C++ are invisible — they don't appear in your source code. They arise whenever a non-heap object is created but not named.--《More Effective C++》 真正的临时变量是...
C++---运算符重载（2） 前置++重载 后置++重载
D_Mr
03-19 1089
前置++重载 直接上代码 #include <iostream> #include <string> using namespace std; class MyAdd{ friend ostream & operator<<(ostream &cout, MyAdd a); public: MyAdd() ...
C++二元运算符重载
成长日记的博客
03-23 947
主要演示<<,+,[]运算符的重载 这个地方涉及到不同的数据类型~就要讨论一下友元函数重载和成员函数重载的区别~ 1、+运算符成员函数方式重载 #include<iostream> using namespace std; class Coordinate { public: Coordinate(int x,int y) { m_iX=x; m_...
C++运算符重载详解
C++中的运算符重载是编程中一个重要的概念，它允许程序员根据需要为自定义数据类型扩展运算符的功能。在C++中，运算符重载是通过定义特定的成员函数或友元函数来实现的，目的是使得用户定义的类型能够像内置类型一样...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值