C++运算符重载

什么是运算符重载

运算符重载赋予运算能够操作自定义类型。
运算符重载前提条件：必定存在一个自定义类型
运算符重载实质: 就是函数调用

友元重载
类重载

在同一自定义类型中，一个运算符只能被重载一次
C++重载只能重载已有的运算符，不能重载没有
C++重载一般情况不能违背运算符原来的含义(就算语法正确)
注意点:

. ,.* ,?：，:: 不能被重载

#include <iostream>
#include <string>
using namespace std;
class MM
{
public:
  MM() {}
  MM(string name, int score) :name(name), score(score) {}
protected:
  string name;
  int score;
};
int main() 
{
  int a = 1;
  int b = 2;
  int sum = a + b;
  MM mm("小芳", 6);
  MM girl("小芳", 2);
  //error: 没有与这些操作数匹配 "xxx" 运算符
  //MM result = mm + girl;      //错误
  return 0;
}

重载写法

重载函数的写法

//函数定义方式
函数返回值类型  函数名(参数)
{
   //函数体；    
}
//运算符重载也是函数，只是函数名写法不同
//函数名: operator加上运算符组成函数名
//参数：
//    友元重载: 参数个数等于操作数
//    类成员函数: 参数个数等于操作-1
//    函数返回值类型:运算符组成表达式 最终结果是什么类型就返回类型
//    int a; int b;  a+b 返回int
// 函数体：写你真正要实现的效果

友元重载

#include <iostream>
#include <string>
using namespace std;
class MM
{
public:
  MM() {}
  MM(string name, int score) :name(name), score(score) {}
  void print() 
  {
    cout << name << "\t" << score << endl;
  }
  //友元重载
  friend MM operator+(MM a, MM b);    //加法重载函数的声明
protected:
  string name;
  int score;
};
MM operator+(MM a, MM b) 
{
  return MM(a.name, a.score+b.score);  //返回一个匿名对象
}
int main() 
{
  int a = 1;
  int b = 2;
  int sum = a + b;
  MM mm("小芳", 6);
  MM girl("小芳", 2);
  //error: 没有与这些操作数匹配 "xxx" 运算符
  //重载函数的隐式调用 -->mm + girl 解析为:operator+(mm, girl)
  MM result = mm + girl;          //显示绿色就是运算符重载
  result.print();
  //重载函数显示调用：按照函数的调用方式
  MM res = operator+(mm, girl);     //operator+:函数名  参数
  //string aa("12");
  //string bb("2323");
  //cout << (aa > bb) << endl;
  return 0;
}

类重载

#include <iostream>
#include <string>
using namespace std;
class MM
{
public:
  MM() {}
  MM(string name, int score) :name(name), score(score) {}
  void print() 
  {
    cout << name << "\t" << score << endl;
  }
  //友元重载
  friend MM operator+(MM a, MM b);    //加法重载函数的声明
protected:
  string name;
  int score;
};
//类成员函数少一个参数： 对象本身可以表示参数
MM MM::operator-(MM object)
{
  return MM(this->name, this->score - object.score);
}
int main() 
{
  MM mul = mm.operator-(girl);      //类重载显示调用，跟调用普通成员函数一样的
  mul.print();
  MM girlFriend = mm - girl;        //编译器mm - girl翻译为: mm.operator-(girl)
  girlFriend.print();
  return 0;
}

特殊运算符重载

通常情况:单目运算符用类成员函数重载，双目用友元重载
= ,（）,->,[] 只能采用成员函数重载
++ --运算符重载

增加一个无用参数，标识是后置++或者--

流运算符重载(>> <<)

输入流对象(cin): istream类
输出流对象(cout): ostream类
流重载必须用引用
流重载一定要用友元重载

后缀重载

#include <iostream>
#include <string>
#include <thread>
using namespace std;
class MM 
{
public:
  MM() {}
  MM(string name, int age) :name(name), age(age) {}
  void print() 
  {
    cout << name << "\t" << age << endl;
  }
  //MM operator=(MM) = delete;    //删掉默认的
  //函数重载
  void operator=(int data) 
  {
    this->age += data;
  }
  //++ 为例
  MM operator++()           //前置
  {
    this->age++;
    return *this;         //返回对象本身
  }
  MM operator++(int)          //后置的
  {
    return MM(this->name, this->age++);
  }
  //流运算符的重载
  friend ostream& operator<<(ostream& out, MM& object);
  friend istream& operator>>(istream& in, MM& object);
private:
  string name;
  int age;
};
ostream& operator<<(ostream& out, MM& object) 
{
  //out当做cout用
  out << object.name << "\t" << object.age << endl;
  return out;
}
istream& operator>>(istream& in, MM& object) 
{
  cout << "输入对象属性:";
  //in当做cin用即可
  in >> object.name >> object.age;
  return in;
}
//文本重载, 一般写成下划线系列
//后缀的重载
unsigned long long operator""_h(unsigned long long data) 
{
  return data * 60 * 60;
}
unsigned long long operator""_m(unsigned long long data)
{
  return data * 60;
}
unsigned long long operator""_s(unsigned long long data)
{
  return data;
}
int main() 
{
  MM mm("小芳", 18);
  MM girl;
  girl = mm;        //每一个类中都存在默认的赋值重载
  girl = 8;
  girl.print();
  MM result = ++girl;
  result.print();
  girl.print();
  result = girl++;
  result.print();
  girl.print();
  cin >> girl;
  cout << girl << endl; 
  //this_thread::sleep_for(10s);
  cout << 1_h << endl;
  cout << (1_h + 30_m + 49_s) << endl;
  return 0;
}

对象的隐式转换

对象隐式转换: 就是让对象能够赋值给普通数据

//operator  转换的类型()
//{ 
//  return 要转换类型的数据；
//}
#include <string>
#include <iostream>
using namespace std;
class MM 
{
public:
  MM() {}
  MM(string name, int age) :name(name), age(age) {}
  operator int() 
  {
    return this->age;
  }
protected:
  string name;
  int age;
};
int main() 
{
  MM mm("mm", 39);
  int age = mm;
  cout << age << endl;
  return 0;
}

()运算符的重载

仿函数

让类型可以模仿函数调用的行为：函数名(参数)；类名() 调用的函数行为

#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
class Data 
{
public:
  //operator()组成函数名
  void operator()() 
  {
    cout << "无参重载()" << endl;
  }
  void operator()(int a, int b) 
  {
    cout << "有参重载(a,b)" << endl;
  }
protected:
};
int main() 
{
  //greater<int>();  //比较准则
  //int array[5] = { 3,4,1,2,32 };
  //sort(array, array + 5, greater<int>());
  //for (auto& v : array) 
  //{
  //  cout << v << "\t";
  //}
  //cout << endl;
  Data data;
  data.operator()();    //显式调用
  data.operator()(1, 2);  //显式调用
  data();         //隐式调用
  data(1, 2);       //隐式调用
  Data{}();       //{}帮助识别  Data()
  Data{}(2, 3);
  return 0;
}

运算符重载案例分析

智能指针

智能指针是用对象方式管理new的内存，可以做到自动释放(本质是析构函数自动调用)内存的功能

#include <iostream>
#include <memory>
using namespace std;
class Auto_Ptr 
{
public:
  Auto_Ptr(int* ptr) :ptr(ptr) {}
  ~Auto_Ptr() 
  {
    if (ptr) 
    {
      delete ptr;
      ptr = nullptr;
    }
  }
  //访问指针
  int* operator->() 
  {
    return this->ptr;
  }
  //访问数据
  int& operator*() 
  {
    return *ptr;
  }
  //禁止拷贝，禁止赋值
  Auto_Ptr(Auto_Ptr&) = delete;
  Auto_Ptr& operator=(Auto_Ptr&) = delete;
protected:
  int* ptr;
};
int main() 
{
  Auto_Ptr object(new int(1999));
  cout << *object << endl;
  //shared_ptr<int>  p(new int(19999));
  //cout << *p << endl;
  //shared_ptr<double>  p2(new double(19.99));
  //cout << *p2 << endl;
  return 0;
}

封装数组

#include <iostream>
#include <vector>     //动态数组
using namespace std;
class my_vector 
{
public:
  my_vector(int capacity = 10) :capacity(capacity) 
  {
    mem = new int[capacity] {0};
    curSize = 0;
  }
  void push_back(int data) 
  {
    mem[curSize++] = data;
  }
  int* begin() 
  {
    return mem + 0;
  }
  int* end() 
  {
    return mem + capacity;
  }
  int& operator[](int index) 
  {
    if (curSize < index)
      curSize = index;
    return mem[index];
  }
  //万金油函数
  int size() 
  {
    return curSize;
  }
  int empty() 
  {
    return curSize == 0;
  }
  ~my_vector() 
  {
    if (mem) 
    {
      delete[] mem;
      mem = nullptr;
    }
  }
protected:
  int* mem;
  int capacity;
  int curSize;
};
int main() 
{
  my_vector vec;
  for (int i = 0; i < 3; i++) 
  {
    vec[i] = i;
  }
  for (auto v : vec) 
  {
    cout << v << "\t";
  }
  cout << endl;
  cout << vec.size() << endl;
  for (int i = 0; i < vec.size(); i++) 
  {
    cout << vec[i] << "\t";
  }
  cout << endl;
  return 0;
}

迭代器实现

//迭代器就是让一个类中类去遍历数据

#include <iostream>
#include <string>
using namespace std;
struct Node 
{
  int data;
  Node* next;
  Node() :next(nullptr){}
  Node(int data) :data(data), next(nullptr) {}
  Node(int data, Node* next) :data(data), next(next) {}
};
class List 
{
public:
  List() :headNode(new Node),curSize(0){}
  void push_front(int data) 
  {
    headNode->next = new Node(data, headNode->next);
    curSize++;
  }
  Node* begin() 
  {
    return headNode->next;
  }
  Node* end() 
  {
    return nullptr;
  }
  class iterator 
  {
  public:
    iterator() :pmove(nullptr) {}
    void operator=(Node* pmove) 
    {
      this->pmove = pmove;
    }
    bool operator!=(Node* pmove) 
    {
      return this->pmove != pmove;
    }
    iterator operator++() 
    {
      this->pmove = this->pmove->next;  //链表++不了
      return *this;
    }
    int operator*() 
    {
      return this->pmove->data;     //*运算访问数据
    }
  private:
    Node* pmove;      //需要指针访问数据
  };
protected:
  Node* headNode;
  int curSize;
};
void my_list() 
{
  List list;
  for (int i = 0; i < 3; i++) 
  {
    list.push_front(i);
  }
  List::iterator it;
  for (it = list.begin(); it != list.end(); ++it)
  {
    cout << *it << " ";
  }
  cout << endl;
}
int main() 
{
  string str = "ILoveyou";
  for (int i = 0; i < str.size(); i++) 
  {
    cout << str[i];
  }
  cout << endl;
  //类中类访问一个容器数据
  string::iterator it;
  for (it = str.begin(); it != str.end(); it++) 
  {
    cout << *it;    //*指针取值运算
  }
  cout << endl;
  //cout << *str.end() << endl;
  my_list();
  return 0;
}

重载的特殊问题

//对象与常量运算
#include <iostream>
#include <string>
using namespace std;
class Data 
{
public:
  Data() {}
  Data(int num) :num(num) {}
  //friend Data operator+(Data data, int num);
  //friend Data operator+( int num, Data data);
  //Data operator+(Data data) 
  //{
  //  return Data(this->num + data.num);
  //}
  void print() 
  {
    cout << num << endl;
  }
  friend Data operator+(Data data1, Data data2);
protected:
  int num;
};
//Data operator+(Data data, int num) 
//{
//  return Data(data.num + num);
//}
//Data operator+(int num, Data data) 
//{
//  return Data(num + data.num);
//}
Data operator+(Data data1, Data data2) 
{
  return Data(data1.num + data2.num);
}
int main() 
{
  Data data(1);
  Data temp;
  //data.成员函数(1);
  temp = data + 1;
  //1+data : 1.成员函数()
  temp = 1 + data;   //类成员函数没办法完成
  temp.print();
  return 0;
}

7. C++运算符重载

C++运算符重载

什么是运算符重载

重载写法

友元重载

类重载

特殊运算符重载

对象的隐式转换

()运算符的重载

仿函数

运算符重载案例分析

智能指针

封装数组

迭代器实现

重载的特殊问题

热门文章

最新文章

相关课程

相关电子书