重载运算符（operator）

最新推荐文章于 2024-11-18 10:01:18 发布
最新推荐文章于 2024-11-18 10:01:18 发布
阅读量1.6k 收藏 3
点赞数
分类专栏： C\C++基础 文章标签： c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34791632/article/details/90318738
版权

什么是运算符重载

重载我们分析过了，就是对一个已有的函数，使其参数的个数，类型不同来赋予新的含义，实现新的功能。那么运算符也可以被重载赋予新的含义和功能。这就运算符重载。

为什么会用运算符重载机制

我们在开发中都使用过运算符，一般情况下我们接触最多的就是加减乘除，还有new，delete这些运算法，直接使用他们只能对单一类型的数据进行操作。例如我们想对自定义类型进行运算操作时，该怎么办呢？重载运算符就显得极其重要了。

#pragma warning(disable : 4996)
#include <iostream>
using namespace std;

class Complex
{
    friend Complex Add(Complex &c1, Complex &c2);
    friend Complex operator+(Complex &c1, Complex &c2);
public:
    Complex(int a, int b)
    {
        this->m_a = a;
        this->m_b = b;
    }
    //成员函数(在类的内部完成两个数据的和)
    int GetAdd()
    {
        return m_a + m_b;
    }
    //成员函数(在类的内部完成两个类的数据的和)
    Complex GetAdd(Complex &c1)
    {
        Complex temp = Complex(this->m_a + c1.m_a, this->m_b + c1.m_b);
        return temp;
    }
private:
    int m_a, m_b;
};

//全局函数（要访问类的私有成员可以使用友元friend）
Complex Add(Complex &c1,Complex &c2)
{
    Complex temp = Complex(c1.m_a + c2.m_a, c1.m_b + c2.m_b);
    return temp;
}

//重载“+”运算法
Complex operator+(Complex &c1, Complex &c2)
{
    Complex temp = Complex(c1.m_a + c2.m_a, c1.m_b + c2.m_b);
    return temp;
}

int main()
{
    //使用成员函数
    Complex c1(1, 2), c2(3, 4);
    int a1 = c1.GetAdd();
    int a2 = c2.GetAdd();
    int a3 = a1 + a2;
    cout << "c1与c2的和 = " << a3 << endl;

    //使用成员函数
    Complex c3 = c1.GetAdd(c2);
    int a4 = c3.GetAdd();
    cout << "c1与c2的和 = " << a4 << endl;

    //使用友元函数
    Complex c4 = Add(c1, c2);
    int a5 = c4.GetAdd();
    cout << "c1与c2的和 = " << a5 << endl;

    //使用"operator+"重载运算符
    Complex c5 = c1 + c2;
    int a6 = c5.GetAdd();
    cout << "c1与c2的和 = " << a5 << endl;
    system("pause");
    return 0;
}

看上面的例子，如果我们想对同一类型的两个对象的数据成员进行加法运算时，可以用很多种方式达到其目的，有成员函数，友元函数，同样可以重载运算符达到其目的。

 Complex c5 = c1 + c2

原因Complex是用户自定义类型，编译器根本不知道如何进行相加。可是编译器给我们提供了一种机制，让我们自己去完成自定义类型的相加操作，而这一机制就是运算符重载机制。

运算符重载的限制

可以重载的运算符

+     -     *     /     %     ^     &     |     ~

!     =     <     >     +=    -=    *=    /=    %=

^=    &=    |=    <<    >>    >>=   <<=   ==    !=

<=    >=    &&    ||    ++    --    ->*    ‘    ->

[]    ()    new   delete     new[]     delete[]

不能重载的运算符

.	::	 .*	 ?:	 sizeof

重载运算符函数可以对运算符做出新的解释，但原有基本语义不变

  • 不改变运算符的优先级
  • 不改变运算符的结合性
  • 不改变运算符所需的操作数
  • 不能创建新的运算符

运算符重载规则

运算符函数是一种特殊的成员函数或友元函数（运算符重载的本质是一个函数）

类型 类名 :: operator  op(参数表){}
返回值       关键字    函数名(操作数)

全局函数、类成员函数方法实现运算符重载步骤

  1. 要承认操作符重载是一个函数，写出函数名称operator op ()
  2. 根据操作数，写出函数参数
  3. 根据业务，完善函数返回值(看函数是返回引用 还是指针 元素)，及实现函数业务

运算符重载的两种方法

用成员或友元函数重载

  • 运算符函数可以重载为成员函数或友元函数
  • 关键区别在于成员函数具有this指针，友元函数没有this指针
  • 不管使用成员函数或友元函数重载运算符，其使用方法相同，但传递参数的方式不同，实现代码不同，应用场合不同

例:字符串类的封装以及业务实现

// MyString.h

#pragma once
#include <iostream>
using namespace std;
#pragma warning(disable : 4996)

class MyString
{
	friend ostream & operator<<(ostream &out, MyString &s);
	friend istream & operator>>(istream &input, MyString &s);
public:
	MyString(const char *s );
	MyString(int len = 0);
	MyString(const MyString &obj);
	void MyPrint();
	~MyString();
public:
	MyString & operator=(const MyString &obj);
	MyString & operator=(const char *s);
	char &operator[](int index)const;

public:
	bool operator==(const char *str)const;
	bool operator!=( const char *str)const;
	bool operator==(const MyString &s)const;
	bool operator!=(const MyString &s)const;

	/*bool operator<(const char *str)const;
	bool operator>(const char *str)const;
	bool operator<(const MyString &s)const;
	bool operator>(const MyString &s)const;*/

public:
	char * Str();
	const char *c_Str();
	int Length();
	

private:
	char *str;
	int m_len;
};

//MyString.cpp

#include "MyString.h"

MyString::MyString(const char *s)
{
	if (s == NULL)
	{
		this->m_len = 0;
		this->str = new char[m_len + 1];
		strcpy(str, "");
	}
	else
	{
		this->m_len = strlen(s);
		cout << m_len << endl;
		this->str = new char[m_len + 1];
		strcpy(str, s);
	}
}

MyString::MyString(int len)
{
	if (len == 0)
	{
		this->m_len = 0;
		this->str = new char[m_len + 1];
		strcpy(str, "");
	}
	else
	{
		this->m_len = len;
		this->str = new char[m_len + 1];
		memset(this->str, 0, m_len);
	}
}

MyString::MyString(const MyString & obj)
{
	this->m_len = obj.m_len;
	this->str = new char[m_len + 1]; 
	strcpy(str, obj.str);
}

void MyString::MyPrint()
{
	cout << str << endl;
}


MyString::~MyString()
{
	if (this->str != NULL)
		delete[] str;
	this->m_len = 0;
}

MyString & MyString::operator=(const MyString &obj)
{
	if (this->str != NULL)
	{
		delete[] str;
		m_len = 0;
	}
	this->m_len = obj.m_len;
	this->str = new char[m_len+1];
	strcpy(str, obj.str);
	return *this;
}

MyString& MyString::operator=( const char *s)
{
	if (this->str != NULL)
	{
		delete[] str;
		m_len = 0;
	}
	if (s == NULL)
	{
		m_len = 0;
		str = new char[m_len + 1];
		strcpy(str, "");
	}
	else
	{
		m_len = strlen(s);
		str = new char[m_len + 1];
		strcpy(str, s);
	}
	return *this;
}

char & MyString::operator[](int index) const
{
	return str[index];
}

bool MyString::operator==(const char * str)const
{
	if (str == NULL)
	{
		if (this->m_len == 0)
			return true;
		else
			return false;
	}
	else
	{
		if (this->m_len == strlen(str))
		{
			 return !strcmp(this->str, str);
		}
		else
		{
			return false;
		}
	}
}

bool MyString::operator!=(const char * str)const
{
	return !(*this == str);
}

bool MyString::operator==(const MyString & s)const
{
	if (m_len != s.m_len)
		return false;
	else
	{
		return !strcmp(this->str, s.str);
	}
}

bool MyString::operator!=(const MyString & s)const
{
	return !(*this == s);
}

char * MyString::Str()
{
	return this->str;
}

const char * MyString::c_Str()
{
	return this->str;
}

int MyString::Length()
{
	return this->m_len;
}

//bool MyString::operator<(const char * str) const
//{
//	return strcmp(this->str, str );
//}
//
//bool MyString::operator>(const char * str) const
//{
//	return strcmp(str, this->str);
//}
//
//bool MyString::operator<(const MyString & s) const
//{
//	return strcmp(this->str, s.str);
//}
//
//bool MyString::operator>(const MyString & s) const
//{
//	return strcmp(s.str, this->str);
//}

ostream & operator<<(ostream & out, MyString & s)
{
	return out << s.str;
}

istream & operator>>(istream & input, MyString & s)
{
	return input >> s.str;
}

总结

1、对于自定义类型进行运算时，我们会使用到运算符重载

2、成员函数和友元函数都可以重载运算符，其参数，代码实现，应用场景不同

3、运算符的重载符合运算符的优先级，结合性，操作数。

 

C#重载运算符详解
01-20
C#中的重载运算符是面向对象编程的一个关键特性，它允许程序员为自定义类型定义特定的运算行为。本文将深入探讨如何在C#中实现运算符重载，以及注意事项和示例。 首先，理解为什么要重载运算符。在C#中，标准运算符...
operator重载运算符
努力的八戒
09-25 3183
C++已经为基本类型和标注库中的数据类型提供了运算符操作，我们自定义数据类型的话有时就需要重载运算符实现自定义函数来实现类似功能了，此时可以把operator ==、operator=、operator*等操作符整体看作一个函数名。 一、单目运算符++/--（以++为例） 1、重载为类的成员函数 假设obj表示对象，func为成员函数，那么func的前置重载形式 func obj 相当于 obj.operator func()，无形参。前置++运算符表示先自增1然后返回对象本身，那么针对前置++就是+
C++ operator重载运算符详解
Janus
10-04 2万+
文章目录Chapter XIV前置拓展 Chapter XIV 前置拓展 C++ operator 重载运算符的作用: 主要是代替成员函数的方式为自建类型完成基本任务 当然, 用成员函数完全可以代替operator的功能, 但是使用起来绝对没有operator方便 operator 重载运算符方式: 既然是用于自建类型的运算, 则其可以有两种定义方式: 作为自建类型的成员函数, 定义在类的内部...
C++重载-＞运算符
最新发布
henry747647的专栏
11-18 1572
为了这样做，它使用了 `const_cast` 去掉 `const` 限制，并调用非 `const` 版本的 `operator->()`。- `const_cast(*this)` 将 `*this` 转换为非 `const` 类型，以便调用非 `const` 版本的 `operator->()`。- 使用 `const_cast` 将 `*this` 转换为非 `const`，然后委托给非 `const` 重载版本。这两个 `->` 运算符的重载写法是**正确的**，没有问题。
重载运算符operator详解
Rudy1124的博客
08-25 1743
用好重载运算符可以简化代码，所以一定要用清楚！拜拜~~~
运算符重载函数operator的简单用法与常用案例
weixin_74292291的博客
07-06 5108
operator运算符重载参数解释 + 案例：1. 重载+号，返回值类型的使用，2. 重载
PL/SQL 运算符（Operator）
千里之行始于足下
01-25 2349
-- Start 赋值运算符（Assignment Operator） DECLARE X INT := 1; -- 赋值运算符 := BEGIN DBMS_OUTPUT.put_line(X); END; / 算术运算符（Arithmetic Operator） DECLARE X INT := 2; Y INT := 3; Z INT; BEGI
重载赋值运算符
01-20
赋值运算符重载用于对象数据的复制  operator= 必须重载为成员函数 重载函数原型为：  类型 & 类名 :: operator= ( const 类名 & ) ; 案例：完善Name类，支持=号操作。     具体看如下代码： #define _...
c++运算符重载，重载运算符
01-04
### C++运算符重载详解 #### 一、前言 C++允许用户自定义类或...通过适当地重载运算符，可以使代码更加直观和易于理解，提高程序的可读性和可维护性。在实际开发中，合理地使用运算符重载可以极大地提高编程效率。
详解C++ 重载运算符和重载函数
08-18
C++ 重载运算符和重载函数 C++ 编程语言中，重载运算符和重载函数是两个非常重要的概念。它们允许在同一个作用域中，指定多个定义，分别称为函数重载和运算符重载。 函数重载是指在同一个作用域内，声明多个同名...
C++编程语言中重载运算符（operator）介绍
热门推荐
liitdar的博客
06-11 21万+
operator是C++的一个关键字，它和运算符（如“=”）一起使用，表示一个运算符重载函数，在理解时可将operator和待重载的运算符整体（如“operator=”）视为一个函数名。使用operator重载运算符，是C++扩展运算符功能的方法。使重载后的运算符的使用方法与重载前一致；扩展运算符的功能只能通过函数的方式实现。（实际上，C++中各种“功能”都是通过函数实现的）
第六章 C++运算符重载（operator）
qq_40632679的博客
04-02 2739
以下是本人整理的C++基础知识点，内容并不包含全面的C++知识，只是对C++重点内容、特点进行整理和归纳。 6.1 C++运算符重载介绍 运算符重载介绍 功能 运算符在不同情况下有不同的功能，在不同情况下执行不同的操作 格式 返回值类型 operator运算符名称(形参表列){...} operator 关键字，用于定义重载运算符的函数 可以将【operator 运算符名称】这一部分看做函数名
运算符重载(operator overloading)
sinat_39591298的博客
03-18 1872
运算符重载(operator overloading) 运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。 在C++中，可以定义一个处理类的新运算符。这种定义很像一个普通的函数定义，只是函数的名字由关键字 operator 及其紧跟的运算符组成，差别仅此而已。它像任何其他函数一样也是一个函数，当编译器遇到适当的模式时，就会调用这个函数。 1. 加号运算符重载 如果想让自定义数据类型 进行+运算 需要重载 + 运算符 在成员...
oracle中的operator,Oracle Spatial中的Operator操作子 详细说明
weixin_42339759的博客
04-04 287
SDO_FILTER格式：SDO_FILTER(geometry1, geometry2, params);描述：通过空间索引，根据给定的几何要素检索出具有空间相互关系的空间对象。这里的空间关系是指两个几何不分离，即Non-disjoint。【disjoint：表示两个几何的边和内部都不相交】这个Sdo_Filter执行只是初始的空间过滤操作；二次的过滤操作将由SDO_RELATE操作子完成，它能...
operator运算符重载
wang2279的博客
09-05 1196
operator操作符重载
运算符重载（operator overloading）
sdausxc的专栏
05-28 3740
运算符重载(operator overloading)只是一种语法上的方便，也就说他只是另一种函数的调用方式。 在C++中，可以定义一个处理类的新运算符。这种定义很像一个普通函数的定义，只是函数的名字由关键字operator及其后紧跟的运算符组成。差别仅此而已。他像任何其他函数一样也是一个函数，当编译器遇到适当的模式时，就会调用这个函数。 对于运算符重载首先它是一个有趣的工具。但是，它仅仅只是
oracle中operator的创建与查询
JAVA
06-26 1085
定义：   CREATE OR REPLACE OPERATOR "SDE"."ST_MINY" BINDING ("SDE"."ST_GEOMETRY") RETURN NUMBER    USING "SDE"."ST_GEOMETRY_OPERATORS"."ST_MINY_F" 查询： SELECT dbms_metadata.get_ddl('OPER
oracle数据库 符,Oracle数据库之Oracle All运算符
weixin_34229622的博客
04-03 453
本文主要向大家介绍了Oracle数据库之Oracle All运算符，通过具体的内容向大家展现，希望对大家学习Oracle数据库有所帮助。在本教程中，您将学习如何使用OracleALL运算符将值与列表或子查询进行比较。OracleALL操作符简介OracleALL操作符用于将值与子查询返回的值列表或结果集进行比较。以下显示了与列表或子查询一起使用的ALL运算符的语法：operatorALL...
重载运算符函数 operator<<
04-06
重载运算符函数 operator用于向流中插入对象的值。它通常用于输出对象的值，比如在控制台上输出、输出到文件中等。 以下是一个重载运算符函数 operator的示例： ``` #include class Point { public: Point(int ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值
>