文章摘自:c++从入门到精通(第四版 清华大学出版社)
运算符实际上是一个函数,所以运算符的重载实际上是函数的重载,。编译程序对运算符的重载的选择,遵循函数重载的选择原则。当遇到不很明显的运算时,编译程序会寻找与参数相匹配的运算符函数。
目录
1.重载运算符的必要性
C++语言中的数据类型分为基本数据类型和构造数据类型。基本数据类型可以直接完成算术运算。例如:
#include<bits/stdc++.h>
using namespace std;
int main(void){
int a=10;
int b=20;
cout<<a+b<<endl;
}
程序中实现了两个整型变量的相加,可以正确输出运行结果30。通过两个浮点变量、两个双精度变量都可以直接运用加法运算符+来求和。但是类属于新构造的数据类型,类的两个对象就无法通过加法运算符来求和。例如:
#include<bits/stdc++.h>
using namespace std;
class CBook{
public:
CBook(int iPage){
m_iPage=iPage;
}
void display(){
cout<<m_iPage<<endl;
}
protected:
int m_iPage;
};
int main(void){
CBook book1(10);
CBook book2(20);
tmp=book1+book2;//错误
tmp.display();
}
当编译器编译到语句book1+book2时会报错,因为编译器不知道如何进行两个对象的相加,要实现两个类对象的加法运算有两种方法,一种是通过成员函数,一种是通过重载运算符。
首先看通过成员函数方法实现求和的例子:
#include<bits/stdc++.h>
using namespace std;
class CBook{
public:
CBook(int iPage){
m_iPage=iPage;
}
int add(CBook a){
return m_iPage+a.m_iPage;
}
void display(){
cout<<m_iPage<<endl;
}
protected:
int m_iPage;
};
int main(void){
CBook book1(10);
CBook book2(20);
cout<<book1.add(book2)<<endl;
}
程序运行结果正确。使用成员函数实现求和的形式比较单一,并且不利于代码复用。如果要实现多个对象的累加其代码的可读性会大大降低,使用重载运算符的方法可以解决这些问题。
2.重载运算符的形式与规则
重载运算符的声明形式如下:
operator类型名():
operator是需要重载的运算符,整个语句没有返回类型,因为类型名就代表了它的返回类型。重载运算符将对象转化成类型名规定的类型,转换时的形式就像强制转换一样。但如果没有重载运算符定义,直接强制类型转换会导致编译器将无法通过编译。
重载运算符不可以是新创建的运算符,只能是C++语言中已有的运算符,可以重载的运算符如下:
算术运算符:+ - * / % ++ --
位操作运算符:& | ~ ^ >> <<
逻辑运算符 ! && ||
比较运算符 < > >= <= == !=
赋值运算符 = += -= *= /= %= &= |= ^= <<= >>=
其他运算符: [ ] () -> , new delete new[] delete[] ->*
并不是所有的C++语言中已有的运算符都可以重载,不允许重载的运算符有 . * :: ?和:
重载运算符时不能改变运算符操作数的个数,不能改变运算符原有的优先级,不能改变运算符原有的结合性,不能改变运算符原有的语法结构,即单目运算符只能重载为单目运算符,双目运算符只能重载为双目运算符,重载运算符含义必须清楚,不能有二义性。
实例:通过重载运算符实现求和:
#include<bits/stdc++.h>
using namespace std;
class CBook{
public:
CBook(int iPage){
m_iPage=iPage;
}
CBook operator+(CBook b)
{
return CBook(m_iPage+b.m_iPage);
}
void display(){
cout<<m_iPage<<endl;
}
protected:
int m_iPage;
};
int main(void){
CBook book1(10);
CBook book2(20);
CBook tmp(0);
tmp=book1+book2;
tmp.display();
}
类CBook重载了求和运算符后,由它声明的两个对象book1和book2可以向两个整型变量一样相加。
3.重载运算符的运算
重载运算符后可以完成对象和对象之间的运算,同样也可以通过重载运算实现对象和普通类型数据的运算。例如:
#include<bits/stdc++.h>
using namespace std;
class CBook{
public:
int m_Pages;
void OutputPage(){
cout<<m_Pages<<endl;
}
CBook(){
m_Pages=0;
}
CBook operator+(const int page){
CBook book;
book.m_Pages=m_Pages+page;
return book;
}
};
int main(void){
CBook Book1,Book2;
Book2=Book1+10;
Book2.OutputPage();
}
通过修改运算符的参数为整数类型,可以实现CBook对象与整数相加。
对于两个整型变量的相加,可以调换加数和被加数的顺序,因为加法符合交换律。但是对于通过重载运算符实现的加法,不可以交换顺序。
illegal:
Book2=10+Book1;//非法代码
对于++和--运算符,由于涉及前置运算和后置运算,在重载这类运算符时如何区分呢?默认情况是,如果重载运算符没有参数则表示是前置运算,例如:
void operator++()//前置运算
{
++m_Pages;
}
如果重载运算符使用了整数作为参数,则表示的是后置运算,此时的参数值可以被忽略,它只是一个标识,标识后置运算。
void operator++(int)//后置运算
{
++m_Pages;
}
默认情况下,将一个整数赋值给一个对象是非法的,可以通过重载运算符将其变成合法的。例如:
void operator = (int page){//重载运算符
m_Pages=page;
}
通过重载运算符也可以实现将一个整型数复制给一个对象,例如:
#include<bits/stdc++.h>
using namespace std;
class CBook{
public:
int m_Pages;
void OutputPages()
{
cout<<m_Pages<<endl;
}
CBook(int page){
m_Pages=page;
}
operator = (const int page){
m_Pages=page;
}
};
int main(void){
CBook mybook(0);
mybook = 100;
mybook.OutputPages();
}
程序中重载了赋值运算符,给mybook对象赋值100,并通过OutpuName()函数将其进行输出。
也可以通过重载构造函数将一个整数赋值给一个对象
#include<bits/stdc++.h>
using namespace std;
class CBook{
public:
int m_Pages;
void OutputPages()
{
cout<<m_Pages<<endl;
}
CBook(){
}
CBook(int page){
m_Pages=page;
}
};
int main(void){
CBook mybook;
mybook = 100;
mybook.OutputPages();
}
程序中定义了一个重载的构造函数,以一个整数作为函数参数,这就可以将一个整数赋值给一个CBook类的对象,语句mybook=100;将调用构造函数CBook(int page)重新构造一个CBook对象,并将其赋值给mybook对象。
4.C++运算符重载为友元函数
引用了这位博主的文章:C++ 运算符重载_高祥xiang的博客-CSDN博客_c++运算符重载
一般情况下,将运算符重载为类的成员函数是较好的选择。但有时,重载为成员函数不能满足使用要求,重载为全局函数又不能访问类的私有成员,因此需要将运算符重载为友元。
例如,对于复数类 Complex 的对象,希望它能够和整型以及实数型数据做四则运算,假设 c 是 Complex 对象,希望c+5和5+c这两个表达式都能解释得通。
将+重载为 Complex 类的成员函数能解释c+5,但是无法解释5+c。要让5+c有意义,则应对+进行再次重载,将其重载为一个全局函数。为了使该全局函数能访问 Complex 对象的私有成员,就应该将其声明为 Complex 类的友元。具体写法如下:
class Complex
{
double real, imag;
public:
Complex(double r, double i):real(r), imag(i){};
Complex operator + (double r);
friend Complex operator + (double r, const Complex & c);
};
Complex Complex::operator + (double r)
{ //能解释c+5
return Complex(real+r, imag);
}
Complex operator + (double r, const Complex & c)
{ //能解释5+c
return Complex (c.real+r, c.imag);
}
5.转义运算符
C++语言中普通的数据类型可以进行强制类型转换,例如:
int i=10;
double d;
d = double(i)
程序中将整数i强制转换为double型。
语句
d=double(i)//等同于d=double(i)
double()在C++语言中被转化为转换运算符。通过重载转换运算符可以将类对象转换为想要的数据。
实例:转换运算符
#include<bits/stdc++.h>
using namespace std;
class CBook{
public:
CBook(double iPage=0);
operator double(){
return m_iPage;
}
protected:
int m_iPage;
};
CBook::CBook(double iPage){
m_iPage = iPage;
}
int main(void){
CBook book1(10.0);
CBook book2(20.00);
cout<<double(book1)+double(book2)<<endl;
}
程序重载了转换运算符double(),然后将类CBook的两个对象强制转换为double类型后再进行求和,最后输出求和的结果。
6.C++实现可变长度的动态数组
这一部分的原文链接:链接:https://blog.csdn.net/qq_27278957/article/details/85269245
实践中经常碰到程序需要定义一个数组,但不知道定义多大合适的问题。按照最大的可能性定义,会造成空间浪费;定义小了则无法满足需要。
如果用动态内存分配的方式解决,需要多少空间就动态分配多少,固然可以解决这个问题,但是要确保动态分配的内存在每一条执行路径上都能够被释放,也是一件头疼的事情。
因此需要编写一个长度可变的数组类,该类的对象就能存放一个可变长数组。该数组类应该有以下特点:
数组的元素个数可以在初始化该对象时指定。
可以动态往数组中添加元素。
使用该类时不用担心动态内存分配和释放问题。
能够像使用数组那样使用动态数组类对象,如可以通过下标访问其元素。
#include <iostream>
#include <cstring>
using namespace std;
class CArray
{
int size; //数组元素的个数
int* ptr; //指向动态分配的数组
public:
CArray(int s = 0); //s代表数组元素的个数
CArray(CArray & a);
~CArray();
void push_back(int v); //用于在数组尾部添加一个元素 v
CArray & operator = (const CArray & a); //用于数组对象间的赋值
int length() const { return size; } //返回数组元素个数
int & operator[](int i)
{ //用以支持根据下标访问数组元素,如“a[i]=4;”和“n=a[i];”这样的语句
return ptr[i];
};
};
CArray::CArray(int s) : size(s)
{
if (s == 0)
ptr = NULL;
else
ptr = new int[s];
}
CArray::CArray(CArray & a)
{
if (!a.ptr) {
ptr = NULL;
size = 0;
return;
}
ptr = new int[a.size];
memcpy(ptr, a.ptr, sizeof(int) * a.size);
size = a.size;
}
CArray::~CArray()
{
if (ptr) delete[] ptr;
}
CArray & CArray::operator=(const CArray & a)
{ //赋值号的作用是使 = 左边对象中存放的数组的大小和内容都与右边的对象一样
if (ptr == a.ptr) //防止 a=a 这样的赋值导致出错
return *this;
if (a.ptr == NULL) { //如果a里面的数组是空的
if (ptr)
delete[] ptr;
ptr = NULL;
size = 0;
return *this;
}
if (size < a.size) { //如果原有空间够大,就不用分配新的空间
if (ptr)
delete[] ptr;
ptr = new int[a.size];
}
memcpy(ptr, a.ptr, sizeof(int)*a.size);
size = a.size;
return *this;
}
void CArray::push_back(int v)
{ //在数组尾部添加一个元素
if (ptr) {
int* tmpPtr = new int[size + 1]; //重新分配空间
memcpy(tmpPtr, ptr, sizeof(int) * size); //复制原数组内容
delete[] ptr;
ptr = tmpPtr;
}
else //数组本来是空的
ptr = new int[1];
ptr[size++] = v; //加入新的数组元素
}
int main()
{
CArray a; //开始的数组是空的
for (int i = 0; i<5; ++i)
a.push_back(i);
CArray a2, a3;
a2 = a;
for (int i = 0; i<a.length(); ++i)
cout << a2[i] << " ";
a2 = a3; //a2 是空的
for (int i = 0; i<a2.length(); ++i) //a2.length()返回 0
cout << a2[i] << " ";
cout << endl;
a[3] = 100;
CArray a4(a);
for (int i = 0; i<a4.length(); ++i)
cout << a4[i] << " ";
return 0;
}