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++运算符重载

什么是运算符重载

重载写法

友元重载

类重载

特殊运算符重载

对象的隐式转换

()运算符的重载

仿函数

运算符重载案例分析

智能指针

封装数组

迭代器实现

重载的特殊问题

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

7. C++运算符重载

C++运算符重载

什么是运算符重载

重载写法

友元重载

类重载

特殊运算符重载

对象的隐式转换

()运算符的重载

仿函数

运算符重载案例分析

智能指针

封装数组

迭代器实现

重载的特殊问题

热门文章

最新文章

相关课程

相关电子书