从零开始学C++（4）----运算符重载

沥川同学

已于 2024-03-30 14:56:38 修改

阅读量598

点赞数 28

分类专栏： C++ 文章标签： c++ 开发语言

于 2024-03-25 20:11:21 首次发布

本文链接：https://blog.csdn.net/lys20221113242/article/details/137018159

版权

C++ 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

5.智能指针----重载“*”和“->”运算符

1.运算符重载

在C++中，运算符的操作对象可以是基本的数据类型，也可以是类中重新定义的运算符，赋予运算符新的功能，对类对象进行相关操作，被称为运算符重载。

1.运算符重载的语法

在C++中，使用operator关键字定义运算符重载。

返回值 operator 运算符（参数列表）
{
      ....
}

下面是+，-运算符的重载演示：

#include <iostream>
using namespace std;
class A
{
private:
    int _x;
    int _y;
public:
    A(int x=0,int y=0):_x(x),_y(y){}
    void show() const;
    A operator+(const A& a) const;
    A operator-(const A& a) const;
};
void A::show() const
{
    cout<<"(_x,_y)="<<"("<<_x<<","<<_y<<")"<<endl;
}
A A::operator+(const A &a) const
{
    return A(_x+a._x,_y+a._y);
}
A A::operator-(const A &a) const
{
    return A(_x-a._x,_y-a._y);
}
int main()
{
    A a1(1,2);
    A a2(4,5);
    A a;
    cout<<"a1:";
    a1.show();
    cout<<"a2:";
    a2.show();
    a=a1+a2;
    cout<<"a:";
    a.show();
    a=a1-a2;
    cout<<"a:";
    a.show();
    return 0;
}

2.运算符重载的规则

只能重载C++中已有的运算符，且不能创建新的运算符。
重载后运算符不能改变优先级和结合性，也不能改变操作数和语法结构。
运算符重载要保持原有运算符的语义。
":",".",".*","?:",sizeof,typeid等运算符不能重载。

3.运算符重载的形式

1.重载为类的成员函数

之前重载+，-运算符为类的成员函数，可以自由的访问本类的成员，运算的操作数以调用者或参数的形式表示。双目运算符重载为类的成员函数那么，左操作数是对象本身的数据，由this指针指出，右操作数则通过运算符重载函数的参数列表传递，其调用格式如下：

左操作数.运算符重载函数（右操作数）；

单目运算符要确定他是前置运算符还是后置运算符，如果是前置，则它的操作数是函数调用者，函数没有参数格式如下：

操作数.运算符重载函数（）；

如果是后置，函数中要带一个整形参数int，它仅仅表示后置运算，无其他意义。

#include <iostream>
using namespace std;
class A
{
private:
    int _x;
    int _y;
public:
    A(int x=0,int y=0):_x(x),_y(y){}
    void show() const;
    A operator++();//前置++
    A operator++(int);//后置++
};
void A::show() const
{
    cout<<"(_x,_y)="<<"("<<_x<<","<<_y<<")"<<endl;
}
A A::operator++()
{
    ++_x;
    ++_y;
    return *this;
}
A A::operator++(int)
{
    A a=*this;
    ++(*this);
    return a;
}
int main()
{
    A a1(1,2),a2(3,4);
    (a1++).show();
    (++a2).show();
    return 0;
}

(_x,_y)=(1,2)
(_x,_y)=(4,5)

前置++中，类的成员变量进行自增运算，然后返回当前对象，就是this指针指向的对象，后置++中，创建了一个临时对象保存当前对象的值，然后再将当前对象自增，最后返回保存初始值的临时对象。

2.重载为类的友元函数

friend 返回值类型 operator 运算符（参数列表）
{
    ...
}

重载为类的友元函数时，由于没有隐含的this指针，因此操作数的个数没有变化，所有的操作数都必须通过函数的参数进行传递，函数的参数与操作数自左至右保持一致。

#include <iostream>
using namespace std;
class A
{
private:
    int _x;
    int _y;
public:
    A(int x=0,int y=0):_x(x),_y(y){}
    void show() const;
    friend A operator+(const A& a1,const A& a2);
    friend A operator-(const A& a1,const A& a2);
};
void A::show() const
{
    cout<<"(_x,_y)="<<"("<<_x<<","<<_y<<")"<<endl;
}
A operator+(const A& a1,const A& a2)
{
    return A(a1._x+a2._x,a1._y+a2._x);
}
A operator-(const A& a1,const A& a2)
{
    return A(a1._x-a2._x,a1._y-a2._y);
}
int main()
{
    A a1(1,2);
    A a2(4,5);
    A a;
    cout<<"a1:";
    a1.show();
    cout<<"a2:";
    a2.show();
    a=a1+a2;
    cout<<"a:";
    a.show();
    a=a1-a2;
    cout<<"a:";
    a.show();
    return 0;
}

a1:(_x,_y)=(1,2)
a2:(_x,_y)=(4,5)
a:(_x,_y)=(5,6)
a:(_x,_y)=(-3,-3)

2.常用的运算符重载

1.输入\输出运算符重载

想要对类对象进行输入输出，则需要在类中重载<<,>>这两个运算符，它们只能重载成类的友元函数，格式如下

ostream& operator<<(ostream&,const 类对象引用);
istream& operator>>(istream&,类对象引用);

输出运算符<<重载的第一个参数是ostream对象引用，该对象引用不能使用const修饰，第二个参数时输出对象的const引用，输入运算符>>重载的第一个参数时istream对象引用，第二个参数是要向其中存入数据的对象，不能用const修饰。

#include <iostream>
using namespace std;
class A
{
private:
    int _x;
    int _y;
public:
    A(int x=0,int y=0):_x(x),_y(y){}
    friend ostream& operator<<(ostream& os,const A& a);
    friend istream& operator>>(istream& is,A& a);
};
ostream& operator<<(ostream& os,const A& a)
{
    os<<"("<<a._x<<","<<a._y<<")";
    return os;
}
istream& operator>>(istream& is,A& a)
{
    is>>a._x>>a._y;
    return is;
}
int main()
{
    A a1(1,2);
    cout<<"a1:"<<a1<<endl;
    cout<<"请重新为a1对象输入数据："<<endl;
    cin>>a1;
    cout<<"重新输入后a1:"<<a1<<endl;
    return 0;
}

a1:(1,2)
请重新为a1对象输入数据：
3 4
重新输入后a1:(3,4)

2.关系运算符重载

关系运算符的重载函数返回值一般定义为bool类型，关系运算符常用于条件判断中。

#include <iostream>
using namespace std;
class Student
{
private:
    int _id;
    double _score;
public:
    Student(int id,double score):_id(id),_score(score){}
    void dis()
    {
        cout<<"学号"<<_id<<"成绩"<<_score<<endl;
    }
    friend bool operator==(const Student& st1,const Student& st2);
    friend bool operator!=(const Student& st1,const Student& st2);
    friend bool operator>(const Student& st1,const Student& st2);
    friend bool operator<(const Student& st1,const Student& st2);
};
bool operator==(const Student& st1,const Student& st2)
{
    return st1._score==st2._score;
}
bool operator!=(const Student& st1,const Student& st2)
{
    return st1._score != st2._score;
}
bool operator>(const Student& st1,const Student& st2)
{
    return st1._score>st2._score;
}
bool operator<(const Student& st1,const Student& st2)
{
    return st1._score<st2._score;
}
int main()
{
    Student st1(1001,96),st2(1002,105);
    cout<<"比较两名学生的成绩："<<endl;
    if(st1>st2)
        st1.dis();
    else if(st1<st2)
        st2.dis();
    else
        cout<<"两名学生成绩相同"<<endl;
    return 0;
}

比较两名学生的成绩：
学号1002成绩105

3.赋值运算符重载

对于赋值运算符来说，如果不重载，类会提供一个赋值运算符，它和默认的拷贝构造函数一样，实现浅拷贝，若成员含有指针，则需要重载赋值运算符实现深拷贝。

#include <iostream>
#include <string.h>
using namespace std;
class Assign
{
public:
    char* name;
    char* url;
public:
    Assign(const char* name,const char* url);
    Assign(const Assign& temp);
    ~Assign()
    {
        delete []name;
        delete []url;
    }
    Assign& operator=(Assign& temp);
};
Assign::Assign(const char *name, const char *url)
{
    this->name=new char[strlen(name)+1];
    this->url=new char[strlen(url)+1];
    if(name)
        strcpy(this->name,name);
    if(url)
        strcpy(this->url,url);
}
Assign::Assign(const Assign &temp)
{
    this->name=new char[strlen(temp.name)+1];
    this->url=new char[strlen(temp.url)+1];
    if(name)
        strcpy(this->name,temp.name);
    if(url)
        strcpy(this->url,temp.url);
}

Assign& Assign::operator=(Assign &temp)
{
    delete []name;
    delete []url;
    this->name=new char[strlen(temp.name)+1];
    this->url=new char[strlen(temp.url)+1];
    if(name)
        strcpy(this->name,temp.name);
    if(url)
        strcpy(this->url,temp.url);
    return *this;
}
int main()
{
    Assign a("百度","https://www.baidu.com/");
    cout<<"a对象："<<a.name<<" "<<a.url<<endl;
    Assign b(a);
    cout<<"b对象："<<b.name<<" "<<b.url<<endl;
    Assign c("b站","https://www.bilibili.com/");
    cout<<"c对象："<<c.name<<" "<<c.url<<endl;
    b=c;
    cout<<"b对象："<<b.name<<" "<<b.url<<endl;
    return 0;
}

a对象：百度 https://www.baidu.com/
b对象：百度 https://www.baidu.com/
c对象：b站 https://www.bilibili.com/
b对象：b站 https://www.bilibili.com/

4.下标运算符重载

重载[]运算符可以表示对象[],也可以对下标进行越界检查。格式如下：

返回值类型 operator[](参数列表)
{
    ...
}

[]运算符重载函数有且只有一个整形参数，表示下标值，返回值一般指定为一个引用。

#include <iostream>
#include <cstring>
using namespace std;
class Tag
{
private:
    int size;
    char* buf;
public:
    Tag(int n);
    Tag(const char *src);
    ~Tag()
    {
        delete []buf;
    }
    char& operator[](int n);
    void show()
    {
        for(int i=0;i<size;i++)
            cout<<buf[i];
        cout<<endl;
    }
};
Tag::Tag(int n)
{
    size=n;
    buf=new char[size+1];
    *(buf+size)='\0';
}
Tag::Tag(const char *src)
{
    buf=new char[strlen(src)+1];
    strcpy(buf,src);
    size= strlen(src);
}
char& Tag::operator[](int n)
{
    static char ch=0;
    if(n>size||n<0)
    {
        cout<<"越界"<<endl;
        return ch;
    }
    else
        return *(buf+n);
}
int main()
{
    Tag arr1(20);
    for(int i=0;i<20;i++)
        arr1[i]=65+i;
    arr1.show();
    Tag arr2("bilibili!");
    cout<<arr2[8]<<endl;
    arr2[8]='A';
    arr2.show();
    return 0;
}

3.类型转换

1.类型转换函数

类型转换函数也称为类型转换运算符重载函数，格式如下:

operator 数据类型()
{
    ...
}

不能指定返回值类型，由重载的数据类型名确定，且没有参数，只能重载为类的成员函数。

#include <iostream>
#include <cstring>
using namespace std;
class Student
{
private:
    string _id;
    char* _name;
public:
    Student(string id,const char* name):_id(id)
    {
        _name=new char[strlen(name)+1];
        strcpy(_name,name);
    }
    operator char*()
    {
        return _name;
    }
    void show()
    {
        cout<<"ID:"<<_id<<","<<"name:"<<_name<<endl;
    }
};
int main()
{
    Student s1("1001","小明");
    cout<<"s1:";
    s1.show();
    char *ch=s1;
    cout<<ch<<endl;
    return 0;
}

2.转换构造函数

转换构造函数指的是构造函数只有一个参数，且参数不是本类的const引用，不仅可以将一个标准类型数据转换为类对象，也可以将另一个类的对象转换为转换构造函数所在的类对象。格式如下：

class A
{
    A(const B& b)
    {
        //从b到a的转换
    }
}

#include <iostream>
using namespace std;
class Solid
{
public:
    Solid(int x,int y,int z):_x(x),_y(y),_z(z){}
    void show()
    {
        cout<<"三维坐标"<<_x<<","<<_y<<","<<_z<<endl;
    }
    friend class Point;
private:
    int _x,_y,_z;
};
class Point
{
private:
    int _x,_y;
public:
    Point(int x,int y):_x(x),_y(y){}
    Point(const Solid &another)
    {
        this->_x=another._x;
        this->_y=another._y;
    }
    void show()
    {
        cout<<"平面坐标"<<_x<<","<<_y<<endl;
    }
};
int main()
{
    cout<<"原始坐标"<<endl;
    Point p(1,2);
    p.show();
    Solid s(3,4,5);
    s.show();
    cout<<"三维转换平面坐标"<<endl;
    p=s;
    p.show();
    return 0;
}

原始坐标
平面坐标1,2
三维坐标3,4,5
三维转换平面坐标
平面坐标3,4

4.仿函数----重载“（）”运算符

类重载（）后，这个类的对象也可以像函数一样使用。

#include <iostream>
using namespace std;
class Show
{
public:
    void operator()(const string str)
    {
        cout<<str<<endl;
    }
    float operator()(const float num)
    {
        return num*num;
    }
};
int main()
{
    Show s;
    s("abcdef");
    cout<<s(4)<<endl;
    return 0;
}

abcdef
16

仿函数还可以实现类中信息的传递，如根据仿函数的运算结果修改成员变量的值。

5.智能指针----重载“*”和“->”运算符

设想一种场景，三个指针同时指向一块对象内存空间，若释放第一个指针指向的对象，2,3指针无法访问资源，成为悬空指针。为了解决这个问题，C++引入了引用计数的概念，引用计数用于存储计算机资源的引用，指针或者句柄的数量，当计数为0时自动释放资源，可以跟踪堆中对象的分配和自动释放堆内存资源。

#include <iostream>
#include <string>
using namespace std;
class Data
{
public:
    Data(string str):_str(str)
    {
        cout<<"Data类构造函数"<<endl;
    }
    ~Data()
    {
        cout<<"Data类析构函数"<<endl;
    }
    void dis()
    {
        cout<<_str<<endl;
    }
private:
    string _str;
};
class Count
{
public:
    friend class SmartPtr;
    Count(Data *pdata):_pdata(pdata),_count(1)
    {
        cout<<"Count类构造函数"<<endl;
    }
    ~Count()
    {
        cout<<"Count类析构函数"<<endl;
        delete _pdata;
    }
private:
    Data *_pdata;
    int _count;
};
class SmartPtr
{
public:
    SmartPtr(Data* pdata):_reNum(new Count(pdata))
    {
        cout<<"创建基类对象"<<endl;
    }
    SmartPtr(const SmartPtr& another):_reNum(another._reNum)
    {
        ++_reNum->_count;
        cout<<"SmartPtr类复制构造函数"<<endl;
    }
    ~SmartPtr()
    {
        if(--_reNum->_count==0)
        {
            delete _reNum;
            cout<<"SmartPtr类析构函数"<<endl;
        }
    }
    Data *operator->()
    {
        return _reNum->_pdata;
    }
    Data &operator*()
    {
        return *_reNum->_pdata;
    }
    int disCount()
    {
        return _reNum->_count;
    }
private:
    Count *_reNum;
};
int main()
{
    Data *pstr1=new Data("I Love China!");
    SmartPtr pstr2=pstr1;
    (*pstr1).dis();
    SmartPtr pstr3=pstr2;
    pstr2->dis();
    cout<<"使用基类对象的指针数量："<<pstr2.disCount()<<endl;
    return 0;
}

Data类构造函数
Count类构造函数
创建基类对象
I Love China!
SmartPtr类复制构造函数
I Love China!
使用基类对象的指针数量：2
Count类析构函数
Data类析构函数
SmartPtr类析构函数

沥川同学

关注

28
点赞
踩
17

收藏

觉得还不错? 一键收藏
3
评论
从零开始学C++（4）----运算符重载

在C++中，运算符的操作对象可以是基本的数据类型，也可以是类中重新定义的运算符，赋予运算符新的功能，对类对象进行相关操作，被称为运算符重载。
复制链接

扫一扫

专栏目录

从零开始学C++（4）----运算符重载

1.运算符重载

1.运算符重载的语法

2.运算符重载的规则

3.运算符重载的形式

1.重载为类的成员函数

2.重载为类的友元函数

2.常用的运算符重载

1.输入\输出运算符重载

2.关系运算符重载

3.赋值运算符重载

4.下标运算符重载

3.类型转换

1.类型转换函数

2.转换构造函数

4.仿函数----重载“（）”运算符

5.智能指针----重载“*”和“->”运算符

“相关推荐”对你有帮助么？