c++进阶篇(一)——运算符重载

简介: c++进阶篇(一)——运算符重载

什么是运算符重载

运算符重载:用同一个运算符完成不同的运算功能。

C++运算符重载的相关规定如下:

1.不能改变运算符的优先级。

2.不能改变运算符的结合性。

3.默认参数不能和重载的运算符一起使用,也就是说,在设计运算符重载成员函数时不能使用默认函数。

4.不能改变运算符的操作数的个数。

5.不能创建新的运算符,只有已有运算符可以被重载

6.运算符作用于C++内部提供的数据类型时,原来含义保持不变

相关代码

  • 关系运算符重载
#include <iostream>
using namespace std;
class Girl
{
private:
    int age;
    int figure;
    int yanzhi;
public:
    Girl(int a,int b,int c):age(a),figure(b),yanzhi(c)
    {}
    int Sum(const Girl& g1)
    {
        return age+figure+yanzhi;
    }
    bool operator < (const Girl& g1)
    {
        if(Sum(g1)<Sum(*this))
        {
            return true;
        }
        return false;
    }
    bool operator == (const Girl& g1)
    {
        if(Sum(g1)==Sum(*this))
        {
            return true;
        }
        return false;
    }
    bool operator >(const Girl& g1)
    {
        if(Sum(g1)>Sum(*this))
        {
            return true;
        }
        return false;
    }
};
int main()
{
    Girl g1(18,90,80),g2(17,80,80);
    if(g1<g2)
    {
        cout<<"g1 is better"<<endl;
    }
    if(g1==g2)
    {
        cout<<"g1 is equal to g2"<<endl;
    }
    if(g1>g2)
    {
        cout<<"g1 is better"<<endl;
    }
    return 0;
}
  • 左移运算符
    注意::左移运算符的重载函数不能作为成员函数,如果想调用类的私有成员需要使用友元函数
#include <iostream>
using namespace std;
class Girl
{
private:
    int age;
    string sex;
    string name;
public:
    Girl(int a,string b,string c):age(a),sex(b),name(c)
    {}
    friend ostream& operator <<(ostream& os,const Girl& g);//重载左移运算符
};
ostream& operator <<(ostream& os,const Girl& g)
{
    cout<<g.age<<g.sex<<g.name;
    return os;
} 
int main()
{
    Girl g(18,"女","小美");
    cout<<g<<endl;
    return 0;
}
  • 下标运算符
#include <iostream>
#include <vector>
using namespace std;
class girl
{
private:
    int age;
    string sex;
    string name;
    vector<string> boys;
public:
    girl(int a,string s,string n,vector<string> b)
    {
        age=a;
        sex=s;
        name=n;
        boys=b;
    }
    void operator[](int i)
    {
        if(i>boys.size()-1)
        {
            cout<<"error"<<endl;
            return;
        }
        cout<<boys[i]<<endl;
    }
};
int main()
{
    girl g(18,"girl","xiaohong",{"xiaoming","xiaohong"});
    g[0];
    g[1];
    g[2];//error
    return 0;
}
  • 赋值运算符
    注意: 系统自带的默认赋值函数是浅拷贝,如果类中成员有使用了堆区内存则需要自己重载赋值运算符
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class Girl
{
public:
    int age;
    string sex;
    string name;
    int* m_ptr;
    Girl()
    {
        m_ptr = nullptr;
    }
    //重载赋值运算符
    Girl& operator=(const Girl& g)
    {
        if(this==&g)
        {
            return *this;
        }
        if(g.m_ptr==nullptr)
        {
            if(m_ptr!=nullptr)
            {
                delete m_ptr;
                m_ptr = nullptr;
            }
        }
        else
        {
            if(m_ptr==nullptr)
            {
                m_ptr = new int;
            }
            memcpy(g.m_ptr, m_ptr, sizeof(int));
        }
        age=g.age;
        sex=g.sex;
        name=g.name;
        return *this;
    }
    void print()
    {
        cout<<"age:"<<age<<endl;
        cout<<"sex:"<<sex<<endl;
        cout<<"name:"<<name<<endl;
        cout<<"*m_ptr:"<<*m_ptr<<endl;
        cout<<"m_ptr:"<<m_ptr<<endl;
        cout<<endl;
    }
};
int main()
{
    Girl g1;
    g1.age=18;
    g1.sex="girl";
    g1.name="xiaohong";
    g1.m_ptr = new int(100);
    g1.print();
    Girl g2;
    g2=g1;
    g2.print();
    return 0;
}
  • 內存分配符(new和delete)
    注意:这里虽然没有使用static关键字,但是这里对newdelete的重载函数属于类的静态成员函数,它并不能访问类的非静态成员。
#include <iostream>
using namespace std;
class girl
{
private:
    int age;
    int bh;
public:
    girl(int a, int b) : age(a), bh(b)
    {
        cout << "构造函数" << endl;
    }
    ~girl()
    {
        cout << "析构函数" << endl;
    }
    void *operator new(size_t size)
    {
        cout << "operator new" << endl;
        return malloc(size);
    }
    void operator delete(void *p)
    {
        cout << "operator delete" << endl;
        free(p);
    }
};
int main()
{
    girl *p = new girl(18, 170);
    delete p;
    return 0;
}
相关文章
|
5月前
|
编译器 C++
C++进阶之路:何为运算符重载、赋值运算符重载与前后置++重载(类与对象_中篇)
C++进阶之路:何为运算符重载、赋值运算符重载与前后置++重载(类与对象_中篇)
46 1
|
6月前
|
程序员 编译器 C++
C++中的运算符重载(Operator Overloading)
C++中的运算符重载(Operator Overloading)
57 1
|
2月前
|
C++
C++(十五) 运算符重载
C++中的运算符重载允许对已有运算符的功能进行重新定义,从而扩展语言功能、简化代码并提升效率。重载遵循特定语法,如 `friend 类名 operator 运算符(参数)`。重载时需注意不可新增或改变运算符数量、语义、优先级、结合性和返回类型。常见示例包括双目运算符 `+=` 和单目运算符 `-` 及 `++`。输入输出流运算符 `&lt;&lt;` 和 `&gt;&gt;` 也可重载。部分运算符只能作为成员函数重载。
|
5月前
|
存储 Linux C语言
c++进阶篇——初窥多线程(二) 基于C语言实现的多线程编写
本文介绍了C++中使用C语言的pthread库实现多线程编程。`pthread_create`用于创建新线程,`pthread_self`返回当前线程ID。示例展示了如何创建线程并打印线程ID,强调了线程同步的重要性,如使用`sleep`防止主线程提前结束导致子线程未执行完。`pthread_exit`用于线程退出,`pthread_join`用来等待并回收子线程,`pthread_detach`则分离线程。文中还提到了线程取消功能,通过`pthread_cancel`实现。这些基本操作是理解和使用C/C++多线程的关键。
|
5月前
|
存储 编译器 C++
【C++】:拷贝构造函数和赋值运算符重载
【C++】:拷贝构造函数和赋值运算符重载
29 1
|
5月前
|
C++ 索引
C++核心技术要点《运算符重载》
C++核心技术要点《运算符重载》
53 2
|
4月前
|
自然语言处理 程序员 C++
C++基础知识(五:运算符重载)
运算符重载是C++中的一项强大特性,它允许程序员为自定义类型(如类或结构体)重新定义标准运算符的行为,使得这些运算符能够适用于自定义类型的操作。这样做可以增强代码的可读性和表达力,使得代码更接近自然语言,同时保持了面向对象编程的封装性。
|
4月前
|
Java 程序员 C++
|
4月前
|
编译器 C++
【C++】详解运算符重载,赋值运算符重载,++运算符重载
【C++】详解运算符重载,赋值运算符重载,++运算符重载
|
5月前
|
编译器 C++
【C++】类和对象③(类的默认成员函数:赋值运算符重载)
在C++中,运算符重载允许为用户定义的类型扩展运算符功能,但不能创建新运算符如`operator@`。重载的运算符必须至少有一个类类型参数,且不能改变内置类型运算符的含义。`.*::sizeof?`不可重载。赋值运算符`=`通常作为成员函数重载,确保封装性,如`Date`类的`operator==`。赋值运算符应返回引用并检查自我赋值。当未显式重载时,编译器提供默认实现,但这可能不足以处理资源管理。拷贝构造和赋值运算符在对象复制中有不同用途,需根据类需求定制实现。正确实现它们对避免数据错误和内存问题至关重要。接下来将探讨更多操作符重载和默认成员函数。