C++面向对象(OOP)编程-运算符重载

本文主要介绍C++面向对象编程中的多态的手段之一运算符重载,讲清运算符重载的本质,以及通过代码实现一些常用的运算符重载。

目录

1 运算符重载的本质

2 运算符重载格式

3 运算符重载分类

3.1 重载为类的成员函数

3.1.1 双目运算符重载

3.1.2 单目运算符重载

3.2 重载为类的全局友元函数

3.3 两种重载方式对比

4 运算符重载规则  

5 一些运算符的重载

5.1 输入输出运算符的重载

5.2 关系运算符重载

5.3 赋值运算符的重载

5.4 类型转换运算符重载


1 运算符重载的本质

        运算符重载(operator overload)是对已有的常规运算符赋予多重含义,使用相同的运算符,通过提供操作不同数据类型实现不同的行为。由于运算符的本质是C++封装的类的成员函数,因此运算符重载的本质是函数重载。

        比如 对于运算符+,常规支持一般的int等数据类型,我们可以重载让其两个对象相加,赋予新的含义。

2 运算符重载格式

        

返回类型 operator 运算符(参数列表)

{

    函数体;

}

operator 为关键字,运算符重载只能重载C++允许的运算符。

3 运算符重载分类

3.1 重载为类的成员函数

        根据操作数的多少会分为单目运算符的重载和双目运算符的重载。双目运算符重载为类的成员函数,则它有两个操作数:左操作数是对象本身的数据,右操作数则通过运算符重载函数的参数表来传递。

3.1.1 双目运算符重载

        调用格式为:

                左操作数.运算符重载函数(右操作数)

        以下代码是运算符 - + * << 的重载:

#include 
#include 
class Complex
{
    private:
        double real;
        double imag;

    public:
        Complex(double r, double i) : real(r), imag(i) {}

        // 运算符+重载
        Complex operator+(const Complex &other) const
        {
            double newReal = real + other.real;
            double newImag = imag + other.imag;
            return Complex(newReal, newImag);
        }

        // 运算符-重载
        Complex operator - (const Complex & other) const
        {
            return Complex((real-other.real),(imag-other.imag));

        }

        // 运算符*重载
        Complex operator * (const Complex & other) const
        {
            return Complex((real * other.real),(imag * other.imag));
        }

        // 运算符<<重载,用于输出对象
        friend std::ostream & operator << (std::ostream &os, const Complex &c)
        {
            os << "(" << c.real << ", " << c.imag << ")";
            return os;
        }

};



int main()
{
    Complex a(1.0, 2.0);
    Complex b(3.0, 4.0);
    

    Complex c = a + b; // 使用运算符+进行复杂数相加

    std::cout << "a+b: " << c << std::endl;

    Complex d = a - b;

    std::cout << "a-b: " << d << std::endl;

    Complex f = a - b;

    std::cout << "a*b: " << f << std::endl;


    return 0;
}

运行结果:

3.1.2 单目运算符重载

        如果是单目运算符重载为类的成员函数,则要分为前置(++i)和后置(i++)运算符。

如果是前置运算符,则它的操作数是函数调用者,函数没有参数。

调用格式为:

操作数.运算符重载函数()        

        以下代码是运算符++i和i++的重载:

#include 
#include 
class Complex
{
    private:
        double real;
        double imag;

    public:
        Complex(double r, double i) : real(r), imag(i) {}

        // ++i
        Complex operator ++ ()
        {
            ++(this->real);
            ++(this->imag);
            return *this;
        }

        // i++

        Complex operator ++ (int)
        {
            Complex cpx = *this;
            (this->real)++;
            (this->imag)++;
            return cpx;

        }

        // 运算符<<重载,用于输出对象
        friend std::ostream & operator << (std::ostream &os, const Complex &c)
        {
            os << "(" << c.real << ", " << c.imag << ")";
            return os;
        }

};


int main()
{
    Complex a(1.0, 2.0);
    Complex b(3.0, 4.0);
    

    std::cout << "*************单目运算符重载i++*************" << std::endl;
    std::cout << "a: " << a << " a++: " << a++ << std::endl;
    std::cout << "a: " << a << " (a++): " << (a++) << std::endl;

    std::cout << "*************单目运算符重载++i*************" << std::endl;
    
    std::cout << "a: " << a << " ++a: " << ++a << std::endl;
    std::cout << "a: " << a << " (++a): " << (++a) << std::endl;

    return 0;
}

运行结果:

        实现前置“++”时,数据成员进行自增运算,然后返回当前对象(即this指针所指 向的对象)。实现后置“++”时,创建了一个临时对象来保存当前对象的值,然后再将当前对象自增,最后返回的是保存了初始值的临时对象。

        前置单目运算符和后置单目运算符的最主要区别是函数的形参,后置单目运 算符带一个int型形参,但它只起区分作用

3.2 重载为类的全局友元函数

        相比与重载为类的成员函数,重载为友元函数,只需要在其前面加friend`。

重载函数格式:

friend 返回类型 operator 运算符(参数列表)

{

    函数体;

}

调用格式

        operator 运算符(参数1,参数2)

        以下是运算符-的友元函数的重载:

#include 
#include 
class Complex
{
    private:
        double real;
        double imag;

    public:
        Complex(double r, double i) : real(r), imag(i) {}


        // 运算符<<重载,用于输出对象
        friend std::ostream & operator << (std::ostream &os, const Complex &c);
        // 友元函数 运算符重载-
        friend Complex operator - (const Complex & a, const Complex & b)
        {
            return Complex((a.real-b.real),(a.imag-b.imag));
        } 
};

std::ostream & operator<<(std::ostream &os, const Complex &c)
{
    os << "(" << c.real << ", " << c.imag << ")";
    return os;
}

int main()
{
    {
        Complex a(1.0, 2.0);
        Complex b(3.0, 4.0);

        std::cout << "*************全局函数为友元函数****************" << std::endl;

        Complex d = a - b;

        std::cout << "a-b: " << d << std::endl;
    }
    
    


    return 0;
}

        运行结果:

       

 运算符重载为类的友元函数时,由于没有隐含的this指针,因此,操作数的个数没有变化,所有的操作数都必须通过函数形参进行传递,函数的参数与操作数 自左自右保持一一对应,这是由友元函数的性质决定的。

3.3 两种重载方式对比

        一般运算符重载既可以为类的成员函数,也可以为全局友元函数。

一般原则:

        1,一般,单目运算符最好重载为类的成员函数,双目运算符最好重载为类的友元函数。

        2,若一个运算符的操作需要修改对象的状态,选择重载为成员函数较好。

        3,若运算符的操作数(尤其是第一个操作数)可能有隐式类型转换,则只能选用友元函 数。

        4,具有对称性的运算符可能转换任意一端的运算对象,如:算术(a+b和b+a)、关系运算 符(a>b和b

        5,有4个运算符必须重载为类的成员函数:赋值=、下标[ ]、调用( )、成员访问->。

4 运算符重载规则  

        1,C++中不允许用户定义新的运算符,只能对已有的运算符进行重载,

        2,重载后的运算符的优先级、结合性也应该保持不变,也不能改变其操作个数和语 法结构。

        3,重载后的含义,与操作基本数据类型的运算含义应类似,如加法运算符“+”,重 载后也应完成数据的相加操作。

        4,有5个运算符不可重载:类关系运算符“:”、成员指针运算符“*”、作用域运算 符“::”、sizeof运算符、三目运算符“?:”

        5,运算符重载函数不能有默认参数,否则就改变了运算符操作数的个数,是错误的。

        6,运算符重载函数既可以作为类的成员函数,也可以作为类的友元函数(全局函数)。 

作为全局函数时,一般都需要在类中将该函数声明为友元函数。因为该函数大部分情况下都需要使用类的private成员。作为类的成员函数时,二元运算符的参数只有一个, 一元运算符不需要参数(参数没有任何意义,只是为了区分是前置还是后置形式:带 一个整型参数为后置形式)。因为有个参数(左操作数)是隐含的(隐式访问this指针 所指向的当前对象)。作为全局函数时,二元操作符需要两个参数,一元操作符需要一 个参数,而且其中必须有一个参数是对象,好让编译器区分这是程序员自定义的运算符, 防止程序员修改用于内置类型的运算符的性质。

5 一些运算符的重载

5.1 输入输出运算符的重载

friend istream& operator>>(istream& is, Person& p); // 输入运算符重载

friend ostream& operator<<(ostream& os, const Person& p); // 输出运算符重载

 代码如下:

#include 
using namespace std;

class Person {
public:
    Person() : name(""), age(0) {}
    
    friend istream& operator>>(istream& is, Person& p);
    friend ostream& operator<<(ostream& os, const Person& p);

private:
    string name;
    int age;
};

istream& operator>>(istream& is, Person& p) {
    cout << "Enter name: ";
    is >> p.name;
    cout << "Enter age: ";
    is >> p.age;
    return is;
}

ostream& operator<<(ostream& os, const Person& p) {
    os << "Name: " << p.name << ", Age: " << p.age;
    return os;
}

int main() {
    Person person;
    cin >> person; // 从控制台读取数据
    cout << person << endl; // 输出:Name: John, Age: 25
    return 0;
}

        运行结果:

5.2 关系运算符重载

        关系运算符的重载通常用于实现自定义的数据类型。例如,我们可以为一个类定义一个大于、小于和等于运算符的重载函数。

        (1)关系运算符都要成对的重载。如:重载了“<”运算符,就要重载“>” 运算符,反之亦然。

        (2)“==”运算符应该具有传递性。如:a==b,b==c,则a==c成立。

        (3)当成对出现运算符重载时,可以把一个运算符的工作委托给另一个运算 符。如:重载“!=”运算符是在“==”运算符的基础上,重载“<”运算 符 由重载过的“>”运算符来实现。

代码如下:

#include 
using namespace std;

class Person {
public:
    Person(const string& n, int a) : name(n), age(a) {}
    
    friend bool operator>(const Person& p1, const Person& p2);
    friend bool operator<(const Person& p1, const Person& p2);
    friend bool operator==(const Person& p1, const Person& p2);

private:
    string name;
    int age;
};

bool operator>(const Person& p1, const Person& p2) {
    return p1.age > p2.age;
}

bool operator<(const Person& p1, const Person& p2) {
    return p1.age < p2.age;
}

bool operator==(const Person& p1, const Person& p2) {
    return p1.age == p2.age;
}

int main() {
    Person person1("John", 25);
    Person person2("Jane", 30);
    
    cout << "person1 > person2: " << (person1 > person2) << endl; // 输出:person1 > person2: 1
    cout << "person1 < person2: " << (person1 < person2) << endl; // 输出:person1 < person2: 1
    cout << "person1 == person2: " << (person1 == person2) << endl; // 输出:person1 == person2: 0
    
    return 0;
}

        运行结果:

5.3 赋值运算符的重载

        若类中没有显式定义赋值运算符的重载函数,编译器将自动提供一个默认的重载函 数,完成数据成员的“浅拷贝”。若类中的数据成员上需要附加额 外的信息,比如类中存在指针成员,指针成员指向新开辟的空间,此时需要重载赋值运算符,以实现“深拷贝”。

注意:赋值运算符只能被重载为类的成员函数

        赋值运算符的重载可以实现函数的深拷贝,深拷贝也可以通过深拷贝构造函数实现。

代码实现:

#include 
using namespace std;
 
class A
{
private:
	int x, y;

public:
	A(int x1 = 0, int y1 = 0)
	{
		x = x1;
		y = y1;
	}
    A & operator = (const A & other)
    {
        this->x = other.x;
        this->y = other.y;
        return *this;
    }
        
	void show()
	{
		cout << "x=" << x << "," << "y=" << y << endl;
	}
};
int main()
{
	A a1(66, 2);
    A a2(97,3);
    a1 = a2;
	a1.show();
	return 0;
}

        运行结果:

5.4 类型转换运算符重载

        C++的一般基本的数据类型的强制转换为static_cast(expression)

        重载类型转换运算符的格式:

operator 类型名()

{

        return static_cast<类型名>(expression)

};

        注意:

        (1)通过类型转换函数可以将自定义类型对象转换为基本类型数据。

        (2)类型转换函数被重载的是类型名。在函数名前不能指定函数类型,函数也没 有参数。返回值类型是由函数名中指定的类型名来确定的(如果类型名为double, 则将类型数据转换为double类型返回)。

        (3)因为函数转换的主体是本类的对象,类型转换运算符重载函数只能作为类的 成员函数。

代码如下:

#include 
using namespace std;
 
class A
{
private:
	int x, y;

public:
	A(int x1 = 0, int y1 = 0)
	{
		x = x1;
		y = y1;
	}
	operator char()
	{
		return static_cast(x);
	}
	void show()
	{
		cout << "x=" << x << "," << "y=" << y << endl;
	}
};
int main()
{
	A a1(66, 2);
	a1.show();
	char ch = a1;
	cout << ch << endl;
	return 0;
}

        运行结果:

你可能感兴趣的:(C/C++精进之路,c++,开发语言,算法,重载)