当前位置：首页 > news >正文

c++介绍运算符重载九

news 来源：原创 2025/8/20 22:58:57

这段代码中我们可以看到同样是运算符，它的作用是不同的a=a<<3;是c++内置的移位运算符。

cout<<"hello world"中<<它的作用是插入运算符。将字符串传递给cout对象，从而将字符输出到终端上。这种功能是如何实现的？其实就是将运算符作为一个函数，对函数进行重载。

#include<iostream>
#include<vector>
using namespace std;
int main()
{vector<int>numbers{ 1,2,3,5,7,9 };cout << numbers << endl;int a = 3;a = a << 3;
}

编译错误
error C2679: 二元“<<”: 没有找到接受“std::vector<int,std::allocator<int>>”类型的右操作数的运算符(或没有可接受的转换)

其实就是找不到对应参数类型的重载函数。为了让上述代码工作，我们需要重写一个重载函数，用来实现整形向量传递给字符串输出对象。

下面实现对整形向量的重载代码

#include<iostream>
#include<vector>
using namespace std;ostream& operator<<(ostream& o, const vector<int>& numbers)
{o << "[";unsigned int last = numbers.size();for (int i = 0; i < last; i++){o << numbers[i];if (i != last - 1)o << ",";}o << "]";return o;
}
int main()
{vector<int>numbers{ 1,2,3,5,7,9 };cout << numbers << endl;int a = 3;a = a << 3;
}

打印结果

上面是类外非成员函数进行重载。也可以对类内成员函数进行重载。

下面是同样两个类型的对象相加，并输出结果

#include<iostream>
#include<vector>
using namespace std;//ostream& operator<<(ostream& o, const vector<int>& numbers)
//{
//	o << "[";
//	unsigned int last = numbers.size();
//	for (int i = 0; i < last; i++)
//	{
//		o << numbers[i];
//		if (i != last - 1)
//			o << ",";
//	}
//	o << "]";
//	return o;
//}
//int main()
//{
//	vector<int>numbers{ 1,2,3,5,7,9 };
//	cout << numbers << endl;
//	int a = 3;
//	a = a << 3;
//}class Complex {
private:float r;float i;
public:Complex(float real, float imaginary) :r(real), i(imaginary) {};Complex operator+(const Complex& other)const {return Complex(this->r + other.r, this->i+other.i);}friend ostream& operator<<(ostream &o, const Complex& a){o <<"r:"<<a.r<<" "<<"i:"<<a.i;return o;}
};int main()
{Complex a(0.1, 2);Complex b(0.4,-2.1);Complex c = a + b;cout << c;return 0;
}

自增运算符重载过程

class ExampleClass
{
private:int m_a;//前缀增量运算符ExampleClass& operator++(){m_a++;return *this;}//后缀增量运算符ExampleClass operator++(int){ExampleClass temp = *this;operator++();return temp;}
};

函数调用运算符，我们定义一个一次函数表达式

struct LinearFuction {double k;double b;double operator()(double x)const {return k * x + b;}};
int main()
{LinearFuction f{ 1.5,3 };cout << "f(0)=" << f(0) << endl;cout << "f(3)=" << f(3) << endl;
}

间接引用运算符（->），它的返回值必须是一个指针或者一个对象或者对象的引用，并且这个对象的间接引用也被重载了。

struct Complex {float r, i;
};
class LocalPtr {
private:Complex* m_ptr;
public:LocalPtr(Complex* p) :m_ptr(p) {}Complex* operator->() { return m_ptr; }~LocalPtr() {if (m_ptr)delete m_ptr;}LocalPtr(const LocalPtr&) = delete;LocalPtr& operator=(const LocalPtr&) = delete;
};
int main()
{LocalPtr pComplex1(new Complex{ 0.1,0.5 });pComplex1->i++;
}

我们常用的智能指针就是重载间接引用运算符来实现的

我们定义一个Complex结构，用于表示复数。接着我们定义一个名叫LocalPtr的类，它是一个简单的指针包装类，它定义了一个指向Complex类的指针。重载了一个间接引用运算符（->），它返回指向Complex结构的指针。在主函数中可以直接访问m_ptr所指向的结构体中成员。类对象销毁时调用析构函数。释放m_ptr缩指向的内存。为了防止多个对象m_ptr成员指向同一地址。并在析构函数中释放同一块内存。localPtr删除了拷贝构造函数和赋值运算符。

下彪运算符，重载后可以让对象向数组一样访问元素。

代码如下

class Array 
{
private:vector<float>number;
public:Array(vector<float>n) :number(n) {};float operator[](int i){int size = number.size();if (i < 0)return number[size + i];return number[i];}
};
int main()
{Array arr(vector<float>{1,2,3,4,5,6,7,8,9});cout << arr[1]<<endl;cout << arr[-1] << endl;
}

相关文章：