AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

黑马程序员C++类和对象【5】 —— 运算符重载（蓝桥杯必备知识）万字超详解

2023-01-19 95
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 黑马程序员C++类和对象【5】 —— 运算符重载（蓝桥杯必备知识）万字超详解

加号运算符重载

如果现在我们希望对对象的属性进行求和，我们可能会想到用+直接进行相加，那么就让我们先来试试吧，下面是我实例化两个对象的两个属性相加，结果编译器会报错，说我的操作数和运算符不匹配，那么这时候就需要自己手动重载运算符了。


作用：实现两个自定义数据类型相加的运算

使用运算符重载（注意：重载函数名必须是编译器提供的operator+）


成员函数重载

//运算符重载
class Person {
public:
  //1、成员函数重载+号
  Person operator+(Person& p)
  {
    Person temp;
        //this指针指向的是调用该成员函数的对象（p1），这里面的p是指传进来的p2的引用
    temp.m_A = this->m_A + p.m_A;
    temp.m_B = this->m_B + p.m_B;
    return temp;
  }
  int m_A;
  int m_B;
};
void test01()
{
  Person p1;
  p1.m_A = 10;
  p1.m_B = 10;
  Person p2;
  p2.m_A = 10;
  p2.m_B = 10;
  Person p3 = p1 + p2;    //等价于 p1.operator+(p2)
  cout << p3.m_A << " " << p3.m_B << endl;
}
int main() {
  test01();    //调用
  system("pause");
  return 0;
}

全局函数重载

//运算符重载
class Person {
public:
  //1、成员函数重载+号
  //Person operator+(Person& p)
  //{
  //  Person temp;
  //  temp.m_A = this->m_A + p.m_A;
  //  temp.m_B = this->m_B + p.m_B;
  //  return temp;
  //}
  int m_A;
  int m_B;
};
//2、全局函数重载  + 号
Person operator+(Person &p1,Person &p2)
{
  Person temp;
  temp.m_A = p1.m_A + p2.m_B;
  temp.m_B = p1.m_B + p2.m_B;
  return temp;
}
void test01()
{
  Person p1;
  p1.m_A = 10;
  p1.m_B = 10;
  Person p2;
  p2.m_A = 10;
  p2.m_B = 10;
  //Person p3 = p1 + p2;    //成员函数重载本质调用等价于 p1.operator+(p2)
  Person p3 = p1 + p2;      //全局函数重载本质调用等价于 operator+(p1,p2)
  cout << p3.m_A << " " << p3.m_B << endl;
}
int main() {
  test01();
  system("pause");
  return 0;
}

运算符重载也可以发生函数重载

class Person {
public:
  Person() {};
  Person(int a, int b)
  {
    this->m_A = a;
    this->m_B = b;
  }
  //成员函数实现 + 号运算符重载
  Person operator+(const Person& p) {
    Person temp;
    temp.m_A = this->m_A + p.m_A;
    temp.m_B = this->m_B + p.m_B;
    return temp;
  }
public:
  int m_A;
  int m_B;
};
//全局函数实现 + 号运算符重载
//Person operator+(const Person& p1, const Person& p2) {
//  Person temp(0, 0);
//  temp.m_A = p1.m_A + p2.m_A;
//  temp.m_B = p1.m_B + p2.m_B;
//  return temp;
//}
//运算符重载 可以发生函数重载 
Person operator+(const Person& p2, int val)
{
  Person temp;
  temp.m_A = p2.m_A + val;
  temp.m_B = p2.m_B + val;
  return temp;
}
void test() {
  Person p1(10, 10);
  Person p2(20, 20);
  //成员函数方式
  Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
  cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
  Person p4 = p3 + 10; //相当于 operator+(p3,10)
  cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;
}
int main() {
  test();
  system("pause");
  return 0;
}

总结1：对于内置的数据类型的表达式的的运算符是不可能改变的；


总结2：不要滥用运算符重载

左移运算符重载

比如这个例子，显然下面这个不能输出的。

左移运算符重载的作用：可以输出自定义数据类型

可以转到定义查看cout是ostream类型的 

//左移运算符重载
class Person {
  friend ostream& operator<<(ostream& out, Person& p);
public:
  Person(int a, int b)
  {
    this->m_A = a;
    this->m_B = b;
  }
  //成员函数 实现不了（  p << cout 不是我们想要的效果 )
  //void operator<<(Person& p){
  //}
private:
  int m_A;
  int m_B;
};
//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p) {
    //内部就是一个简单的对象属性的输出
  out << "a:" << p.m_A << " b:" << p.m_B << endl;;
  return out;
}
void test() {
  Person p1(10, 20);
  //如果返回的是void型，后面就不能追加输出了
  cout << p1 << "hello world" << endl; //链式编程
}
int main() {
  test();
  system("pause");
  return 0;
}

总结：重载左移运算符配合友元可以实现输出自定义数据类型


递增运算符重载

作用： 通过重载递增运算符，实现自己的整型数据

class MyInteger {
  friend ostream& operator<<(ostream& out, MyInteger myint);
public:
  MyInteger() {
    m_Num = 0;
  }
  //前置++
  MyInteger& operator++() {
    //先++
    m_Num++;
    //再返回
    return *this;
  }
  //后置++
  MyInteger operator++(int) {
    //先返回
    MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
    m_Num++;
    return temp;
  }
private:
  int m_Num;
};
ostream& operator<<(ostream& out, MyInteger myint) {
  out << myint.m_Num;
  return out;
}
//前置++ 先++ 再返回
void test01() {
  MyInteger myInt;
  cout << ++myInt << endl;
  cout << myInt << endl;
}
//后置++ 先返回 再++
void test02() {
  MyInteger myInt;
  cout << myInt++ << endl;
  cout << myInt << endl;
}
int main() {
  test01();
  //test02();
  system("pause");
  return 0;
}

总结： 前置递增返回引用，后置递增返回值

递减运算符重载

class MyInteger {
  //友元函数，是函数可以调用类里面的私有属性
  friend ostream& operator<<(ostream& out, MyInteger myint);
public:
    MyInteger() {
      //给m_Num赋初值。
      m_Num = 2;
    }
    //前置--
    MyInteger& operator--() {
      //先 -- 
      --m_Num;
      //再返回
      return *this;
    }
    //后置--
    MyInteger operator--(int) {
      //先返回
      MyInteger temp = *this; //记录当前本身的值，然后让本身的减1，但是返回的是以前的值，达到先返回后--；
      m_Num--;
      return temp;
    }
private:
  int m_Num;
};
//全局函数重载左移运算符用于输出
ostream& operator<<(ostream& out, MyInteger myint) {
  out << myint.m_Num;
  return out;
}
//前置-- 先-- 再返回
void test01() {
  MyInteger myInt;
  cout <<--myInt << endl;
  cout << myInt << endl;
}
//后置-- 先返回 再--
void test02() {
  MyInteger myInt;
  cout << myInt-- << endl;
  cout << myInt << endl;
}
int main() {
  test01();
  test02();
  system("pause");
  return 0;  
}

递减和递增一样，前置返回引用，后置返回值。


赋值运算符重载

C++编译器至少给一个类添加4个函数

  1. 默认构造函数(无参，函数体为空)
  2. 默认析构函数(无参，函数体为空)
  3. 默认拷贝构造函数，对属性进行值拷贝
  4. 赋值运算符 operator=, 对属性进行值拷贝
class Person
{
public:
  Person(int age) {
    m_Age = new int(age);
  }
  ~Person() {
    if (m_Age != NULL) {
      delete m_Age;
      m_Age = NULL;
    }
  }
  int *m_Age;
};
void test01()
{
  Person p1(18);
  cout << "p1的年龄为：" << *p1.m_Age << endl;
  Person p2(28);
  p2 = p1;
  cout << "p1的年龄为：" << *p2.m_Age << endl;
}
int main() {
  test01();
  system("pause");
  return 0;
}

写了个析构函数，释放了自己手动在堆上面申请的内存 ，结果出现崩溃了。。。

这里实际上是浅拷贝的问题。


p1和p2公用一块堆内存18，并没有再重新开辟和p1的属性值一样的空间给p2，他们都指向这一块内存。


在函数执行完之后，p2被释放了，再判断p2空间是否为空，不为空释放一次，p1进行同样操作。

堆区内存重复释放，重新崩溃！

解决方案：利用深拷贝，解决浅拷贝带来的问题。

  //重载赋值运算符
  void operator=(Person& p)
  {
    //编译器是提供浅拷贝
    //m_Age = p.m_Age;
    //应该先判断编译器是否有属性在堆区，如果有先释放干净，然后再深拷贝
    if (m_Age != NULL) {
      delete m_Age;
      m_Age = NULL;
    }
    //深拷贝
    m_Age = new int(*p.m_Age);

直接在类里面添加上面代码就可以实现了


但是，你以为这就完了吗


如果这时候要求连续赋值操作，p3 = p2 = p1；则会报错，为啥呢？


仔细看，你前面返回的是void类型，这里需要返回对象本体Person&。


重载部分代码：

  //重载赋值运算符
  Person& operator=(Person& p)
  {
    //编译器是提供浅拷贝
    //m_Age = p.m_Age;
    //应该先判断编译器是否有属性在堆区，如果有先释放干净，然后再深拷贝
    if (m_Age != NULL) {
      delete m_Age;
      m_Age = NULL;
    }
    //深拷贝
    m_Age = new int(*p.m_Age);
    //返回对象本身
    return *this;
  }

总结：

 先在堆区开辟内存

重载流程：

  1.        判断是否有内存，进行清空操作。
  2.        进行深拷贝
  3.        返回自身

关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

class Person
{
public:
  Person(string name, int age)
  {
    this->m_Name = name;
    this->m_Age = age;
  };
    //==的重载
  bool operator==(Person & p)
  {
    if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
    {
      return true;
    }
    else
    {
      return false;
    }
  }
    //!=的重载
  bool operator!=(Person & p)
  {
    if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
    {
      return false;
    }
    else
    {
      return true;
    }
  }
  string m_Name;
  int m_Age;
};
void test01()
{
  //int a = 0;
  //int b = 0;
  Person a("孙悟空", 18);
  Person b("孙悟空", 18);
  if (a == b)
  {
    cout << "a和b相等" << endl;
  }
  else
  {
    cout << "a和b不相等" << endl;
  }
  if (a != b)
  {
    cout << "a和b不相等" << endl;
  }
  else
  {
    cout << "a和b相等" << endl;
  }
}
int main() {
  test01();
  system("pause");
  return 0;
}

函数调用运算符重载（仿函数）

  • 函数调用运算符 () 也可以重载
  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数
  • 仿函数没有固定写法，非常灵活
class MyPrint
{
public:
  void operator()(string text)
  {
    cout << text << endl;
  }
};
void test01()
{
  //重载的（）操作符 因为调用的时候和函数调用很像，所以也称为仿函数
  MyPrint myFunc;
  myFunc("hello world");
}
class MyAdd
{
public:
  int operator()(int v1, int v2)
  {
    return v1 + v2;
  }
};
void test02()
{
  MyAdd add;
  int ret = add(10, 10);
  cout << "ret = " << ret << endl;
  //匿名函数对象调用  
  cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}
int main() {
  test01();
  test02();
  system("pause");
  return 0;
}

记住：仿函数非常灵活，没有固定的写法。

文章标签：
C++
程序员
编译器
关键词：
C++类
C++对象
C++类对象
C++类运算符重载
C++运算符重载
大耳朵宋宋
目录
相关文章
ephemerals__
|
24天前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色，它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作，帮助读者更好地理解和掌握`string`类的应用。
ephemerals__
38 2
ephemerals__
|
1月前
|
存储 编译器 C++
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
本文介绍了C++中类和对象的高级特性，包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项，帮助读者深入了解C++面向对象编程的核心机制。
ephemerals__
83 5
ephemerals__
|
1月前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
80 4
ephemerals__
|
1月前
|
存储 编译器 Linux
【c++】类和对象（上）（类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针）
本文介绍了C++中的类和对象，包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用，以及如何使用访问限定符控制成员的访问权限。此外，还讨论了对象的内存分配规则和this指针的使用场景，帮助读者深入理解面向对象编程的核心概念。
ephemerals__
86 4
白子寰
|
2月前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
白子寰
26 1
白子寰
|
2月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象（下）
【C++打怪之路Lv5】-- 类和对象（下）
白子寰
31 4
白子寰
|
2月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象（中）
【C++打怪之路Lv4】-- 类和对象（中）
白子寰
31 4
努力学习的小廉
|
2月前
|
存储 编译器 C++
【C++类和对象（下）】——我与C++的不解之缘（五）
【C++类和对象（下）】——我与C++的不解之缘（五）
努力学习的小廉
24 1
努力学习的小廉
|
2月前
|
编译器 C++
【C++类和对象（中）】—— 我与C++的不解之缘（四）
【C++类和对象（中）】—— 我与C++的不解之缘（四）
努力学习的小廉
24 1
努力学习的小廉
|
2月前
|
存储 编译器 C语言
【C++类和对象（上）】—— 我与C++的不解之缘（三）
【C++类和对象（上）】—— 我与C++的不解之缘（三）
努力学习的小廉
20 1