什么是运算符重载

在C++中，运算符重载允许开发者自定义运算符的操作和行为。这个特性允许用户将运算符用于自定义类型的对象，从而使代码更加灵活和易于读取。通常情况运算符不能直接操作自定义类型(类或者结构体),如下错误代码：

而C++重载就是可以实现运算符直接操作自定义类型，注意点：运算符重载时必须存在至少一个自定义类型

C++运算符重载基础

运算符重载本质是函数调用，运算符直接操作的方式可以说是重载函数的隐式调用，当然我们也可以显示调用。因为是函数，所以一般有以下两种重载方式：

• 友元函数重载
• 成员函数重载

既然运算符重载本质是函数调用，那么也具备函数的所有特性，只是有些组成部分写法不一致，主要有以下几点：

• 函数名： operator关键和运算符组成函数名
• 函数参数友元函数重载：参数个数等于操作数成员函数重载：参数个数等于操作数减1
• 函数返回值： 由运算符最终运算的结果决定

如下运算符重载代码：

#include <iostream>#include <string>class MM{public:  MM(std::string name, int age) :name(name), age(age){}  void print()  {    std::cout << name << "\t" << age << std::endl;  }  //类重载  MM operator+(int num)   {    return MM(this->name, this->age + num);  }  //友元重载  friend MM operator-(const MM& object, int num)   {    return MM(object.name, object.age + num);  }protected:  std::string name;  int age;};int main(){  MM  mm("mm", 18);  //隐式调用  MM result1 = mm + 1;  result1.print();  //显式调用  MM result2 = mm.operator+(1);  result2.print();  //隐式调用  MM result3 = result2 - 1;  result3.print();  //显式调用  MM result4 = operator-(result3,1);  result4.print();  return 0;}

程序运行结果如下：

运算符重载注意项：

• . = () -> [] 只能重载为类的成员函数
• 运算符重载必须包含一个自定义类型(结构体或者类)
• . .* ?: :: 不能被重载
• 重载运算符不能无中生有
• 习惯行为: 单目用成员函数重载,双目用友元重载

C++流运算符重载

在C++中流重载允许开发者自定义输入输出流的行为，通过流重载，我们可以以与标准类型相同的方式定制化自定义类型的输入及输出操作，方便了与标准类型交互。流重载须知两个类型

• cin： istream类的对象
• cout:： ostream类的对象

如下流重载代码：

#include <iostream>#include <string>class MM{public:  MM(std::string name, int age) :name(name), age(age){}  void print()  {    std::cout << name << "\t" << age << std::endl;  }  friend std::ostream& operator<<(std::ostream& out, const MM& object)   {    out << object.name << " " << object.age << std::endl;    return out;  }  friend std::istream& operator>>(std::istream& in, MM& object)  {    in >> object.name >> object.age;    return in;  }protected:  std::string name;  int age;};int main(){  MM  mm("mm", 18);  std::cout << mm;  std::cin >> mm;  mm.print();  return 0;}

程序运行结果如下：

注意项：

• 流重载必须采用友元方式重载，cout<<对象 只能解析为operator<<(cout,对象);
• istream与ostream类型必须使用引用，类中禁止拷贝

C++前置后置重载

前置后置重载主要是++ 和– 运算符的重载，增加无用参数作为后置重载标识

如下++运算符重载代码：

#include <iostream>#include <string>class MM{public:  MM(std::string name, int age) :name(name), age(age) {}  void print()  {    std::cout << name << "\t" << age << std::endl;  }  //前置重载  MM operator++()   {    return MM(this->name, ++this->age);  }  //后置参数  MM operator++(int)   {    return MM(this->name, this->age++);  }protected:  std::string name;  int age;};int main(){  MM  mm("mm", 18);  std::cout << "-------后置测试-------" << std::endl;  (mm++).print();  mm.print();  std::cout << "-------前置测试-------" << std::endl;  (++mm).print();  mm.print();  return 0;}

程序运行结果如下：

C++文本重载

C++文本重载就是后缀重载，我们可以使用后缀运算符来表示这种时间单位，例如1s。为了实现这种语法，我们可以通过重载后缀运算符来实现。后缀重载函数的要点有以下两个：

• 函数名是固定的：operator”” 后缀
• 函数参数有且只有一个函数参数，并且只能是字符类型或者unsigned long long 类型

如下文本重载代码：

#include <iostream>#include <string>unsigned long long operator""_s(unsigned long long num) {  return num;}unsigned long long operator""_min(unsigned long long num){  return num*60;}unsigned long long operator""_h(unsigned long long num){  return num * 60*60;}int main(){  int sec = 30_s + 20_min + 1_h;  std::cout << sec << std::endl;  return 0;}

程序运行结果如下：

文本重载不一定需要下划线开头，一般都会带下划线，主要为了避免和标准库中重载的后缀产生冲突。时分秒后缀C++chrono中都给予重载了。

C++重载new和delete

C++中的new和delete是用于动态内存分配和释放的运算符。可以通过重载这些运算符来自定义内存的分配和释放行为，以满足特定的需求。重载new和delete运算符通常需要定义为全局函数或类的静态成员函数。

如下new和delete重载代码：

#include <iostream>#include <cstdlib>//重载申请单个变量内存void* operator new(unsigned int size) {    std::cout << "申请--->"<<size << std::endl;    void* p = std::malloc(size);    if (p == nullptr)        abort();    return p;}void operator delete(void* p)  {    std::cout << "释放" << std::endl;    std::free(p);}class MM {public:    MM() {        std::cout << "构造MM" << std::endl;    }    //重载申请一段内存    void* operator new[](size_t size)    {           std::cout << "申请--->" << size << std::endl;        void* ptr = malloc(size);        if (ptr == nullptr) {            abort();        }        return ptr;    }    void operator delete[](void* p) {        std::cout << "释放" << std::endl;        std::free(p);    }    ~MM() {        std::cout << "析构MM" << std::endl;    }    int age;    int num;};int main() {    MM* p = new MM;    delete p;    MM* parr = new MM[3];    delete [] parr;    return 0;}

重载带[]的new操作符可以用于分配数组类型的内存，它与重载标准的new操作符的区别在于，它需要一个大小参数。此时，编译器会自动调用带[]的new操作符来分配数组类型的对象。

程序运行结果如下：

总之，重载 new 和 delete 运算符可以让我们更好地控制内存的分配和释放，可以用于实现一些高级的内存管理方案。但是，需要注意的是，重载这些运算符时需要格外小心，以确保正确的内存管理。

C++对象的隐式转换

C++对象的隐式转换是operator的另一个用法，简单来说可以直接用对象赋值给基本数据，便捷快速的提取想要的数据类型。基本语法：operator DataType () {return data;}

如下代码：

#include <iostream>#include <string>class MM{public:  MM(std::string name, int age) :name(name), age(age) {}  operator std::string()  {    return name;  }  operator int()  {    return age;  }  std::string getName() { return name; }  int getAge() { return age; };protected:  std::string name;  int age;};int main(){  MM mm("girl", 18);  //隐式转换:实现对象与基本数据类型的赋值运算  std::string name = mm;  int age = mm;  std::cout << name << "\t" << age << std::endl;  name = mm.getName();  age = mm.getAge();  std::cout << name << "\t" << age << std::endl;  return 0;}

程序运行结果如下：

相关

如果阁下正好在学习C/C++，看文章比较无聊，不妨关注下关注下小编的视频教程，通俗易懂，深入浅出，一个视频只讲一个知识点。视频不深奥，不需要钻研，在公交、在地铁、在厕所都可以观看，随时随地涨姿势。