devbox
代码秘术家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【学习笔记】C++ 运算符重载_运算符重载是为了改变语法结构

作者：代码秘术家 | 2024-01-31 19:26:31

赞

踩

运算符重载是为了改变语法结构

运算符重载是使用户可以对已有的运算符进行重载，从而实现对自定义的数据类型的运算操作

  • 1、运算重载符不可以改变语法结构。
  • 2、运算重载符不可以改变操作数的个数。
  • 3、运算重载符不可以改变优先级。
  • 4、运算重载符不可以改变结合性。

1.加号运算符重载

  1. #include <iostream>
  2. #include <string>
  3.  
  4. using namespace std;
  5.  
  6. class Student
  7. {
  8.  
  9. public:
  10.     Student(int age)
  11.     {
  12.  
  13.         this->age = age; //等价于Student::age = age;
  14.  
  15.         //this指针指向被调用的成员函数所属的对象
  16.     };
  17.  
  18.     int age;
  19.     //成员函数作运算符重载
  20.     Student &operator+(Student &s1)
  21.     {
  22.  
  23.         this->age += s1.age;
  24.  
  25.         return *this;
  26.     };
  27.  
  28. private:
  29.     string arr = "你是大傻逼";
  30. };
  31.  
  32.  
  33. //全局函数作运算符重载
  34. Student operator+(Student &s1, Student &s2)
  35. {
  36.     Student temp(0);
  37.  
  38.     temp.age = s1.age + s2.age;
  39.  
  40.     return temp;
  41. };
  42.  
  43. int main()
  44. {
  45.     Student s1(10);
  46.  
  47.     Student s2(10);
  48.  
  49.     Student s3 = s1 + s2;
  50.  
  51.     cout << s3.age << endl;
  52.  
  53.     system("pause");
  54.  
  55.     return 0;
  56. }

2.左移运算符

与cout结合运用，实现输出自定义数据类型.

  1. #include <iostream>
  2. #include <string>
  3.  
  4. using namespace std;
  5.  
  6. class Student
  7. {
  8. friend ostream &operator<<(Student &s1,ostream &cout);
  9. friend ostream &operator<<(ostream &cout,Student &s1);
  10. public:
  11.     Student(int age)
  12.     {
  13.  
  14.         this->age = age; //等价于Student::age = age;
  15.  
  16.         //this指针指向被调用的成员函数所属的对象
  17.     };
  18.  
  19.     int age;
  20.     //成员函数作运算符重载
  21.     /*   Student &operator+(Student &s1)
  22.     {
  24.         this->age += s1.age;
  26.         return *this;
  27.     };
  28. */
  29.  
  30. private:
  31.     string arr = "你是大傻逼";
  32. };
  33.  
  34. //全局函数作运算符重载
  35. Student operator+(Student &s1, Student &s2)
  36. {
  37.     Student temp(0);
  38.  
  39.     temp.age = s1.age + s2.age;
  40.  
  41.     return temp;
  42. };
  43.  
  44. ostream &operator<<( Student &s1,ostream &cout)
  45. {
  46.  
  47.     cout << "student age = " << s1.age <<"student arr = "<<s1.arr<< endl;
  48.  
  49.     return cout;
  50. }
  51.  
  52. ostream &operator<<(ostream &cout,Student &s1)
  53. {
  54.  
  55.     cout << "student age = " << s1.age <<"student arr = "<<s1.arr<< endl;
  56.  
  57.     return cout;
  58. }
  59.  
  60. int main()
  61. {
  62.     Student s1(10);
  63.  
  64.     Student s2(10);
  65.  
  66.     Student s3 = s1 + s2;
  67.  
  68.     s3 << cout << endl;//ostream &operator<<( Student &s1,ostream &cout)
  69.  
  70.     cout<<s3;//ostream &operator<<(ostream &cout,Student &s1)
  71.  
  72.     system("pause");
  73.  
  74.     return 0;
  75. }

注意以下代码实现的区别

  1.  ostream &operator<<(Student &s1,ostream &cout);
  2.  ostream &operator<<(ostream &cout,Student &s1);

3.++运算符重载

注意前置递增和后置递增返回值类型的区别

前置递增返回对象本身

后置递增函数内直接对对象值进行操作，然后返回未操作前的对象的值。

  1. class MyInteger {
  2.  
  3. 	friend ostream& operator<<(ostream& out, MyInteger myint);
  4.  
  5. public:
  6. 	MyInteger() {
  7. 		m_Num = 0;
  8. 	}
  9. 	//前置++
  10. 	MyInteger& operator++() {
  11. 		//先++
  12. 		m_Num++;
  13. 		//再返回
  14. 		return *this;
  15. 	}
  16.  
  17. 	//后置++
  18. 	MyInteger operator++(int) {
  19. 		//先返回
  20. 		MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
  21. 		m_Num++;
  22. 		return temp;
  23. 	}
  24.  
  25. private:
  26. 	int m_Num;
  27. };
  28.  
  29.  
  30. ostream& operator<<(ostream& out, MyInteger myint) {
  31. 	out << myint.m_Num;
  32. 	return out;
  33. }
  34.  
  35.  
  36. //前置++ 先++ 再返回
  37. void test01() {
  38. 	MyInteger myInt;
  39. 	cout << ++myInt << endl;
  40. 	cout << myInt << endl;
  41. }
  42.  
  43. //后置++ 先返回 再++
  44. void test02() {
  45.  
  46. 	MyInteger myInt;
  47. 	cout << myInt++ << endl;
  48. 	cout << myInt << endl;
  49. }
  50.  
  51. int main() {
  52.  
  53. 	test01();
  54. 	//test02();
  55.  
  56. 	system("pause");
  57.  
  58. 	return 0;
  59. }

4.赋值运算符重载

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

  1. 默认构造函数(无参，函数体为空)
  2. 默认析构函数(无参，函数体为空)
  3. 默认拷贝构造函数，对属性进行值拷贝
  4. 赋值运算符 operator=, 对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

  1. class Person
  2. {
  3. public:
  4.  
  5. 	Person(int age)
  6. 	{
  7. 		//将年龄数据开辟到堆区
  8. 		m_Age = new int(age);
  9. 	}
  10.  
  11. 	//重载赋值运算符 
  12. 	Person& operator=(Person &p)
  13. 	{
  14. 		if (m_Age != NULL)
  15. 		{
  16. 			delete m_Age;
  17. 			m_Age = NULL;
  18. 		}
  19. 		//编译器提供的代码是浅拷贝
  20. 		//m_Age = p.m_Age;
  21.  
  22. 		//提供深拷贝 解决浅拷贝的问题
  23. 		m_Age = new int(*p.m_Age);
  24.  
  25. 		//返回自身
  26. 		return *this;
  27. 	}
  28.  
  29.  
  30. 	~Person()
  31. 	{
  32. 		if (m_Age != NULL)
  33. 		{
  34. 			delete m_Age;
  35. 			m_Age = NULL;
  36. 		}
  37. 	}
  38.  
  39. 	//年龄的指针
  40. 	int *m_Age;
  41.  
  42. };
  43.  
  44.  
  45. void test01()
  46. {
  47. 	Person p1(18);
  48.  
  49. 	Person p2(20);
  50.  
  51. 	Person p3(30);
  52.  
  53. 	p3 = p2 = p1; //赋值操作
  54.  
  55. 	cout << "p1的年龄为：" << *p1.m_Age << endl;
  56.  
  57. 	cout << "p2的年龄为：" << *p2.m_Age << endl;
  58.  
  59. 	cout << "p3的年龄为：" << *p3.m_Age << endl;
  60. }
  61.  
  62. int main() {
  63.  
  64. 	test01();
  65.  
  66. 	//int a = 10;
  67. 	//int b = 20;
  68. 	//int c = 30;
  69.  
  70. 	//c = b = a;
  71. 	//cout << "a = " << a << endl;
  72. 	//cout << "b = " << b << endl;
  73. 	//cout << "c = " << c << endl;
  74.  
  75. 	system("pause");
  76.  
  77. 	return 0;
  78. }

5.关系运算符重载

  1. #include <iostream>
  2. #include <string>
  3.  
  4. using namespace std;
  5.  
  6. class Student
  7. {
  8.     friend ostream &operator<<(Student &s1, ostream &cout);
  9.     friend ostream &operator<<(ostream &cout, Student &s1);
  10.  
  11. public:
  12.     Student(int age)
  13.     {
  14.  
  15.         this->age = age; //等价于Student::age = age;
  16.  
  17.         //this指针指向被调用的成员函数所属的对象
  18.     };
  19.  
  20.     bool operator==(Student &s1)
  21.     {
  22.  
  23.         if (this->age == s1.age && this->arr == s1.arr)
  24.             return true;
  25.         else
  26.             return false;
  27.     };
  28.  
  29.     int age;
  30.     //成员函数作运算符重载
  31.     /*   Student &operator+(Student &s1)
  32.     {
  34.         this->age += s1.age;
  36.         return *this;
  37.     };
  38. */
  39.  
  40. private:
  41.     string arr = "你是大傻逼";
  42. };
  43.  
  44. //全局函数作运算符重载
  45. Student operator+(Student &s1, Student &s2)
  46. {
  47.     Student temp(0);
  48.  
  49.     temp.age = s1.age + s2.age;
  50.  
  51.     return temp;
  52. };
  53.  
  54. ostream &operator<<(Student &s1, ostream &cout)
  55. {
  56.  
  57.     cout << "student age = " << s1.age << "student arr = " << s1.arr << endl;
  58.  
  59.     return cout;
  60. }
  61.  
  62. ostream &operator<<(ostream &cout, Student &s1)
  63. {
  64.  
  65.     cout << "student age = " << s1.age << "student arr = " << s1.arr << endl;
  66.  
  67.     return cout;
  68. }
  69.  
  70. int main()
  71. {
  72.     Student s1(10);
  73.  
  74.     Student s2(10);
  75.  
  76.     Student s3 = s1 + s2;
  77.     if (s1 == s2)
  78.     {
  79.         cout << "这俩相等" << endl; /* code */
  80.     }
  81.  
  82.     s3 << cout << endl; //ostream &operator<<( Student &s1,ostream &cout)
  83.  
  84.     cout << s3; //ostream &operator<<(ostream &cout,Student &s1)
  85.  
  86.     system("pause");
  87.  
  88.     return 0;
  89. }

6.（）运算符重载&仿函数

  • 函数调用运算符 () 也可以重载
  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数
  • 仿函数没有固定写法，非常灵活
    1. class MyPrint
    2. {
    3. public:
    4. 	void operator()(string text)
    5. 	{
    6. 		cout << text << endl;
    7. 	}
    8.  
    9. };
    10. void test01()
    11. {
    12. 	//重载的（）操作符 也称为仿函数
    13. 	MyPrint myFunc;
    14. 	myFunc("hello world");
    15. }
    16.  
    17.  
    18. class MyAdd
    19. {
    20. public:
    21. 	int operator()(int v1, int v2)
    22. 	{
    23. 		return v1 + v2;
    24. 	}
    25. };
    26.  
    27. void test02()
    28. {
    29. 	MyAdd add;
    30. 	int ret = add(10, 10);
    31. 	cout << "ret = " << ret << endl;
    32.  
    33. 	//匿名对象调用  
    34. 	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
    35. }
    36.  
    37. int main() {
    38.  
    39. 	test01();
    40. 	test02();
    41.  
    42. 	system("pause");
    43.  
    44. 	return 0;
    45. }

    MyAdd()：匿名对象，Myadd类型的一个对象，在代码执行后内存立即释放.

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号