• (c++)类和对象中篇

    目录

    1. 类的6个默认成员函数

    2. 构造函数

    3. 析构函数

    4. 拷贝构造函数

    5. 赋值运算符重载

    6. const成员函数

    7. 取地址及const取地址操作符重载

    1. 类的 6 个默认成员函数
    • 如果一个类中什么成员都没有，简称为空类。
    • 空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
    • 默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

    2. 构造函数
    2.1 概念

    对于以下 Date 类： 
    1. class Date
    2. {
    3. public:
    4.  void Init(int year, int month, int day)
    5.  {
    6.       _year = year;
    7.      _month = month;
    8.      _day = day;
    9.  }
    10.  void Print()
    11.  {
    12.      cout << _year << "-" << _month << "-" << _day << endl;
    13.  }
    14. private:
    15.      int _year;
    16.      int _month;
    17.      int _day;
    18. };
    19.  
    20. int main()
    21. {
    22.      Date d1;
    23.      d1.Init(2023, 9, 1);
    24.      d1.Print();
    25.      Date d2;
    26.      d2.Init(2023, 9, 1);
    27.      d2.Print();
    28.      return 0;
    29. }
    30.   

              对于 Date 类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

            构造函数 是一个 特殊的成员函数，名字与类名相同 , 创建类类型对象时由编译器自动调用 ，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次 。

    2.2 特性
          构造函数 是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象 。

    其特征如下：
    • 1.函数名与类名相同。
    • 2.无返回值。
    • 3.对象实例化时编译器自动调用对应的构造函数。
    • 4.构造函数可以重载。
    1.   class Date
    2.  {
    3.   public:
    4.       // 1.无参构造函数
    5.       Date()
    6.      {}
    7.   
    8.       // 2.带参构造函数
    9.       Date(int year, int month, int day)
    10.      {
    11.           _year = year;
    12.                     _month = month;
    13.           _day = day;
    14.      }
    15.   private:
    16.       int _year;
    17.       int _month;
    18.       int _day;
    19.  };
    20.   
    21.   void TestDate()
    22.  {
    23.       Date d1; // 调用无参构造函数
    24.       Date d2(2023, 9, 1); // 调用带参的构造函数
    25.   
    26.       // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    27.       // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
    28.       // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
    29.       Date d3();
    30.  }
    • 5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦 用户显式定义编译器将不再生成。

    1.   class Date
    2.  {
    3.   public:
    4.  /*
    5.      // 如果用户显式定义了构造函数，编译器将不再生成
    6.      Date(int year, int month, int day)
    7.      {
    8.          _year = year;
    9.          _month = month;
    10.          _day = day;
    11.      }
    12.   */
    13.  
    14.  void Print()
    15.  {
    16.       cout << _year << "-" << _month << "-" << _day << endl;
    17.  }
    18.   
    19.   private:
    20.      int _year;
    21.      int _month;
    22.      int _day;
    23.  };
    24.   
    25.   int main()
    26.  {
    27.      // 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函
    28. 数
    29.      // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再
    30. 生成
    31.       // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
    32.      Date d1;
    33.      return 0;
    34.  }
    • 6. 关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会 生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？
    • C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类 型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型.

    默认生成的构造函数：

    • 内置类型成员不做处理
    • 自定义类型成员会去调用它的默认构造函数

    验证：

    1. class Time
    2. {
    3. public:
    4.      Time()
    5.      {
    6.          cout << "Time()" << endl;
    7.          _hour = 0;
    8.          _minute = 0;
    9.          _second = 0;
    10.      }
    11. private:
    12.      int _hour;
    13.      int _minute;
    14.      int _second;
    15. };
    16.  
    17. class Date
    18. {
    19. private:
    20.      // 基本类型(内置类型)
    21.      int _year;
    22.      int _month;
    23.      int _day;
    24.      // 自定义类型
    25.      Time _t;
    26. };
    27.  
    28. int main()
    29. {
    30.      Date d;
    31.      return 0;
    32. }
    注意： C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即： 内置类型成员变量在 类中声明时可以给默认值 。 

    1. class Time
    2. {
    3. public:
    4.     Time()
    5.      {
    6.          cout << "Time()" << endl;
    7.          _hour = 0;
    8.          _minute = 0;
    9.          _second = 0;
    10.      }
    11. private:
    12.      int _hour;
    13.      int _minute;
    14.      int _second;
    15. };
    16.  
    17. class Date
    18. {
    19. private:
    20.      // 基本类型(内置类型)
    21.      int _year = 1970;   //c++11允许的补丁
    22.      int _month = 1;     //这里不是初始化，而是声明，给缺省值
    23.      int _day = 1;       //给的是默认构造函数的缺省值
    24.  
    25.      // 自定义类型
    26.      Time _t;
    27. };
    28.  
    29. int main()
    30. {
    31.      Date d;
    32.      return 0;
    33. }
    • 7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
    • 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

    3. 析构函数

    3.1 概念
    析构函数：
    •          与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
    3.2 特性
    析构函数 是特殊的成员函数，其 特征 如下：
    • 析构函数名是在类名前加上字符 ~。
    • 无参数无返回值类型。
    • 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构 函数不能重载
    • 对象生命周期结束时，C++编译系统系统自动调用析构函数
    • 编译器生成的默认析构函数，对自定类型成员调用它的析构函数。
    • 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

    栈：

    1. typedef int DataType;
    2. class Stack
    3. {
    4. public:
    5. 	Stack(size_t capacity = 3)
    6. 	{
    7. 		_array = (DataType*)malloc(sizeof(DataType) * capacity);
    8. 		if (NULL == _array)
    9. 		{
    10. 			perror("malloc申请空间失败!!!");
    11. 			return;
    12. 		}
    13. 		_capacity = capacity;
    14. 		_size = 0;
    15. 	}
    16. 	void Push(DataType data)
    17. 	{
    18. 		//...
    19. 		_array[_size] = data;
    20. 		_size++;
    21. 	}
    22.  
    23. 	~Stack()
    24. 	{
    25. 		free(_array);
    26. 		//_array = nullptr;
    27. 		//_capacity = _size = 0;
    28. 	}
    29.  
    30. private:
    31. 	DataType* _array;
    32. 	int _capacity;
    33. 	int _size;
    34. };

    日期类对象：

    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 2023, int month = 9, int day = 1)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10.  
    11. 	//~Date()
    12. 	//{
    13. 	//	//~Date()没有什么需要清理的
    14. 	//	cout << "~Date()" << endl;
    15. 	//}
    16.  
    17. 	//内置类型析构函数不做处理
    18. private:
    19. 	int _year;
    20. 	int _month;
    21. 	int _day;
    22. };

    自定义队列：

    1. class MyQueue
    2. {
    3. public:
    4. 	//...
    5.  
    6. private:
    7. 	size_t _szie = 0;
    8. 	Stack _st1;
    9. 	Stack _st2;
    10. };

    关于以上三个函数的调用：

    由此也可以总结出析构函数的特点：

    a.内置类型不做处理

    b.自定义类型成员会去调用它的析构函数

    4. 拷贝构造函数

             拷贝构造函数 ： 只有单个形参 ，该形参是对本 类类型对象的引用 ( 一般常用 const 修饰 ) ，在用 已存 在的类类型对象创建新对象时由编译器自动调用 。

    特征
    拷贝构造函数也是特殊的成员函数，其 特征 如下：
    • 1. 拷贝构造函数是构造函数的一个重载形式。
    • 2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错， 因为会引发无穷递归调用。 
    1. class Date
    2. {
    3. public:
    4.  
    5.  Date(int year = 1900, int month = 1, int day = 1)
    6.  {
    7.      _year = year;
    8.      _month = month;
    9.      _day = day;
    10.  }
    11.  
    12.     Date(const Date& d)   //拷贝构造函数
    13.  {
    14.      _year = d._year;
    15.      _month = d._month;
    16.      _day = d._day;
    17.  }
    18.  
    19. private:
    20.  int _year;
    21.  int _month;
    22.  int _day;
    23. };
    24.  
    25. int main()
    26. {
    27.      Date d1;
    28.      Date d2(d1);
    29.      return 0;
    30. }

    • 3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
           注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
    义类型是调用其拷贝构造函数完成拷贝的。 

    1. class Time
    2. {
    3. public:
    4.  Time()
    5.  {
    6.      _hour = 1;
    7.      _minute = 1;
    8.      _second = 1;
    9.  }
    10.  
    11.  Time(const Time& t)
    12.  {
    13.      _hour = t._hour;
    14.      _minute = t._minute;
    15.      _second = t._second;
    16.      cout << "Time::Time(const Time&)" << endl;
    17.  }
    18.  
    19. private:
    20.  int _hour;
    21.  int _minute;
    22.  int _second;
    23. };
    24.  
    25. class Date
    26. {
    27. private:
    28.  // 基本类型(内置类型)
    29.  int _year = 2023;
    30.  int _month = 1;
    31.  int _day = 1;
    32.  
    33.  // 自定义类型
    34.  Time _t;
    35. };
    36.  
    37. int main()
    38. {
    39.  Date d1;
    40.     
    41.     // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
    42.     // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构
    43. 造函数
    44.      Date d2(d1);
    45.  return 0;
    46. }
    4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了 ，还需要自己显式实现吗？
    当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？ 

    1. // 这里会发现下面的程序会崩溃掉。
    2. typedef int DataType;
    3. class Stack
    4. {
    5. public:
    6.  Stack(size_t capacity = 10)
    7.  {
    8.      _array = (DataType*)malloc(capacity * sizeof(DataType));
    9.      if (nullptr == _array)
    10.      {
    11.          perror("malloc申请空间失败");
    12.          return;
    13.      }
    14.  
    15.      _size = 0;
    16.      _capacity = capacity;
    17.  }
    18.  
    19.  void Push(const DataType& data)
    20.  {
    21.      // ...
    22.      _array[_size] = data;
    23.      _size++;
    24.  }
    25.  
    26.  ~Stack()
    27.  {
    28.      free(_array);
    29.  }
    30.  
    31. private:
    32.  DataType *_array;
    33.  size_t _size;
    34.  size_t _capacity;
    35. };
    36.  
    37. int main()
    38. {
    39.  Stack s1;
    40.  s1.Push(1);
    41.  s1.Push(2);
    42.  s1.Push(3);
    43.  s1.Push(4);
    44.  Stack s2(s1);
    45.  return 0;
    46. }

    注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

    5. 赋值运算符重载

           C++ 为了增强代码的可读性引入了运算符重载 ， 运算符重载是具有特殊函数名的函数 ，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
    •      简单来说就是：内置类型可以直接使用运算符运算，因为编译器知道如何运算,而自定义类型无法直接使用运算符，因为编译器不知道如何运算，所以如果要支持自定义类型使用运算符，需要自己实现运算符重载
    • 函数名字为：关键字operator后面接需要重载的运算符符号。
    • 函数原型：返回值类型 operator操作符(参数列表)
    注意：
    • 不能通过连接其他符号来创建新的操作符：比如operator@
    • 重载操作符必须有一个类类型参数
    • 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
    • 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
    • .*   ::   sizeof   ?:    . 注意以上5个运算符不能重载。

    以日期类对象为例：

    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 2023, int month = 1, int day = 1)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10.  
    11. 	//私有
    12.     // bool operator==(Date* this, const Date& d2)
    13.     // 这里需要注意的是，左操作数是this，指向调用函数的对象
    14. 	bool operator==(const Date& x)
    15. 	{
    16. 		return _year == x._year
    17. 			&& _month == x._month
    18. 			&& _day == x._day;
    19. 	}
    20.  
    21. //private:
    22. 	int _year;
    23. 	int _month;
    24. 	int _day;
    25. };
    26.  
    27. //公有
    28. bool operator==(Date x, Date y)
    29. {
    30. 	return x._year == y._year
    31. 		&& x._month == y._month
    32. 		&& x._day == y._day;
    33. }
    34.  
    35.  
    36. int main()
    37. {
    38. 	Date d1(2023, 9, 1);
    39. 	Date d2(2023, 9, 1);
    40.  
    41. 	d1 == d2;
    42. 	cout << (d1 == d2) << endl;
    43.  
    44. 	return 0;
    45. }

                -------------------------------------------------------------------------------------------------------------------

    依旧以日期类为例：

    1.复用逻辑

    2.请问下面代码为什么要有返回值？为什么要传引用返回？

    返回值是为了支持连续赋值，保持运算符的特性，类似于a = b = c 。d2 = d1 ;   d3 = d2 = d1 ;

    传引用返回是因为this指针出函数作用域后会销毁

    3.赋值重载与拷贝构造的区别

    4.日期类 +  与  +=

    5.关于日期类的前置++与后置++ 

    日期类案例声明： 
    1. #pragma once
    2.  
    3. #include <iostream>
    4. using namespace std;
    5.  
    6. class Date
    7. {
    8. 	//友元
    9. 	friend ostream& operator<<(ostream& out, const Date& d); //流插入
    10.  
    11. 	friend istream& operator>>(istream& in, Date& d);//流提取
    13.  
    14. public:
    15. 	Date(int year = 2023, int month = 1, int day = 1);
    16. 	void Print();//打印
    17.  
    18. 	int GetMonthDay(int year, int month) const;//获取每月的天数
    19.  
    20. 	bool operator==(const Date& x) const;
    21. 	bool operator!=(const Date& x) const;
    22. 	bool operator<(const Date& x) const;
    23. 	bool operator<=(const Date& x) const;
    24. 	bool operator>(const Date& x) const;
    25. 	bool operator>=(const Date& x) const;
    26.  
    27. 	Date& operator+=(int day);
    28. 	Date operator+(int day) const;
    29.  
    30. 	//减不仅构成运算符重载，还构成函数重载
    31.  
    32. 	//d1 - 100 日期 - 天数
    33. 	Date operator-(int day) const;
    34.  
    35. 	Date& operator-=(int day);
    36. 	
    37. 	//d1 - d2  日期 - 日期
    38. 	int operator-(const Date& d);
    39.  
    40.  
    41. 	//++d1
    42. 	Date& operator++();
    43.  
    44. 	//d1++
    45. 	Date operator++(int);
    46.  
    47. 	//--d1   -> d1.operator--();
    48. 	Date& operator--();
    49.  
    50. 	//d1--   -> d1.operator--(int);
    51. 	Date operator--(int);
    52.  
    53. 	//void operator<<(ostream& out);
    54.  
    55. private:
    56. 	int _year;
    57. 	int _month;
    58. 	int _day;
    59. };
    60.  
    61.  
    62. ostream& operator<<(ostream& out, const Date& d);//流插入
    63.  
    64. istream& operator>>(istream& in, Date& d);//流提取

    日期类案例实现： 
    1. #include"Date.h"
    2.  
    3. int Date::GetMonthDay(int year, int month) const
    4. {
    5. 	static int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31 };
    6.  
    7. 	if (month == 2 && (((year % 400 == 0) || (year % 4 == 0)) && (year % 100 != 0)))
    8. 	{
    9. 		return 29;
    10. 	}
    11. 	else
    12. 	{
    13. 		return days[month];
    14. 	}
    15. }
    16.  
    17. Date::Date(int year , int month , int day )
    18. {
    19. 	if (month > 0 && month < 13 &&
    20. 		(day > 0 && day <= GetMonthDay(year, month)))
    21. 	{
    22. 		_year = year;
    23. 		_month = month; 
    24. 		_day = day;
    25. 	}
    26. 	else
    27. 	{
    28. 		cout << "日期非法" << endl;
    29. 	}
    30. }
    31.  
    32. void Date::Print()
    33. {
    34. 	cout << _year << "/" << _month << "/" << _day << endl;
    35. }
    36.  
    37. bool Date::operator==(const Date& x) const
    38. {
    39. 	return _year == x._year
    40. 		&& _month == x._month
    41. 		&& _day == x._day;
    42. }
    43.  
    44. bool Date::operator!=(const Date& x) const
    45. {
    46. 	return !(*this == x);
    47. }
    48.  
    49. bool Date::operator<(const Date& x) const
    50. {
    51. 	if (_year < x._year)
    52. 	{
    53. 		return true;
    54. 	}
    55. 	else if (_year == x._year && _month < x._month)
    56. 	{
    57. 		return true;
    58. 	}
    59. 	else if (_year == x._year && _month == x._month && _day < x._day)
    60. 	{
    61. 		return true;
    62. 	}
    63. 	else
    64. 	{
    65. 		return false;
    66. 	}
    67. }
    68.  
    69. bool Date::operator<=(const Date& x) const
    70. {
    71. 	return *this < x || *this == x;
    72. }
    73.  
    74. bool Date::operator>(const Date& x) const
    75. {
    76. 	return !(*this <= x);
    77. }
    78.  
    79. bool Date::operator>=(const Date& x) const
    80. {
    81. 	return !(*this < x);
    82. }
    83.  
    84.  
    85. Date& Date:: operator+=(int day)
    86. {
    87. 	if (day < 0)  //day为负数
    88. 	{
    89. 		*this -= -day;
    90. 		return *this;
    91. 	}
    92.  
    93. 	_day += day;
    94.  
    95. 	while (_day > GetMonthDay(_year, _month))
    96. 	{
    97. 		//减去多余的天数
    98. 		_day -= GetMonthDay(_year, _month);
    99.  
    100. 		//月进位
    101. 		_month++;
    102.  
    103. 		//年进位
    104. 		if (_month==13)
    105. 		{
    106. 			_month = 1;
    107. 			_year++;
    108. 		}
    109. 	}
    110.  
    111. 	return *this;
    112. }
    113.  
    114. //+ 复用+=
    115. Date Date :: operator+(int day) const
    116. {
    117. 	Date tmp(*this);
    118.  
    119. 	tmp += day;
    120.  
    121. 	return tmp;
    122. }
    123.  
    124. //Date Date :: operator+(int day)
    125. //{
    126. //	Date tmp(*this);
    127. //
    128. //	tmp._day += day;
    129. //
    130. //	while (tmp._day > GetMonthDay(tmp._year, tmp._month))
    131. //	{
    132. //		//减去多余的天数
    133. //		tmp._day -= GetMonthDay(tmp._year, tmp._month);
    134. //
    135. //		//月进位
    136. //		tmp._month++;
    137. //
    138. //		//年进位
    139. //		if (tmp._month == 13)
    140. //		{
    141. //			tmp._month = 1;
    142. //			tmp._year++;
    143. //		}
    144. //	}
    145. //
    146. //	return tmp;
    147. //}
    148.  
    149.  
    150. //+= 复用+
    151. //Date& Date::operator+=(int day)
    152. //{
    153. //	*this = *this + day;
    154. //
    155. //	return *this;
    156. //}
    157.  
    158.  
    159. //++d1
    160. Date& Date::operator++()
    161. {
    162. 	*this += 1;
    163. 	return *this;
    164. }
    165.  
    166. //d1++
    167. Date Date::operator++(int) 
    168. {
    169. 	Date tmp(*this);
    170. 	*this += 1;
    171. 	return tmp;
    172. }
    173.  
    174.  
    175. Date& Date::operator-=(int day)
    176. {
    177. 	if (day < 0)  //day为负数
    178. 	{
    179. 		*this += -day;
    180. 		return *this;
    181. 	}
    182.  
    183. 	_day -= day;
    184. 	while (_day <= 0)
    185. 	{
    186. 		--_month;
    187. 		if (_month == 0)
    188. 		{
    189. 			--_year;
    190. 			_month = 12;
    191. 		}
    192.  
    193. 		_day += GetMonthDay(_year, _month);
    194. 	}
    195.  
    196. 	return *this;
    197. }
    198.  
    199. Date Date::operator-(int day) const
    200. {
    201. 	Date tmp(*this);
    202. 	tmp -= day;
    203. 	return tmp;
    204. }
    205.  
    206.  
    207. //--d1 
    208. Date& Date::operator--()
    209. {
    210. 	*this -= 1;
    211. 	return *this;
    212. }
    213.  
    214. //d1-- 
    215. Date Date::operator--(int)  
    216. {
    217. 	Date tmp(*this);
    218. 	*this -= 1;
    219. 	return tmp;
    220. }
    221.  
    222. //d1 - d2
    223. int Date::operator-(const Date& d) 
    224. {
    225. 	Date max = *this;
    226. 	Date min = d;
    227. 	int flag = 1;
    228.  
    229. 	if (*this < d)
    230. 	{
    231. 		max = d;
    232. 		min = *this;
    233. 		flag = -1;
    234. 	}
    235.  
    236. 	int count = 0;
    237. 	while (min != max)
    238. 	{
    239. 		++min;
    240. 		++count;
    241. 	}
    242.  
    243. 	return count * flag;
    244. }
    245.  
    246.  
    247.  
    248. //void Date::operator<<(ostream& out)
    249. //{
    250. //	cout << _year << "年" << _month << "月" << _day << "日" << endl;
    251. //}
    252.  
    253.  
    254. ostream& operator<<(ostream& out, const Date& d)
    255. {
    256. 	cout << d._year << "年" << d._month << "月" << d._day << "日" << endl;
    257. 	return out;
    258. }
    259.  
    260.  
    261. istream& operator>>(istream& in, Date& d)
    262. {
    263. 	in >> d._year >> d._month >> d._day;
    264. 	return in;
    265. }
    266.

    6. const 成员函数
            将 const 修饰的 “ 成员函数 ” 称之为 const 成员函数 ， const 修饰类成员函数，实际修饰该成员函数 隐含的 this 指针 ，表明在该成员函数中 不能对类的任何成员进行修改。

    7. 取地址及 const 取地址操作符重载
    这两个默认成员函数一般不用重新定义 ，编译器默认会生成。 
    1. class A
    2. {
    3. public:
    4. 	//const 修饰 *this
    5. 	//this指针的类型变成 const A*
    6. 	//内部不改变成员变量的成员函数,最好加上const，const对象和普通对象（权限的缩小）都可以调用
    7. 	void Print() const
    8. 	{
    9. 		cout << _a << endl;
    10. 	}
    11.  
    12. 	A* operator&()
    13. 	{
    14. 		return this;
    15. 	}
    16.  
    17. 	const A* operator&() const
    18. 	{
    19. 		return this;
    20. 	}
    21.  
    22. private:
    23. 	int _a = 10;
    24. };
    25.  
    26. void Func(const A& x)
    27. {
    28. 	x.Print();
    29.  
    30. 	cout << &x << endl;
    31. }
    32.  
    33. int main()
    34. {
    35. 	A aa;
    36. 	aa.Print();
    37.  
    38. 	Func(aa);
    39.  
    40. 	cout << &aa << endl;
    41.  
    42. 	return 0;
    43. }
             这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

    概念性内容均来自比特科技

  • 相关阅读:
    一个四位数，恰好等于去掉它的首位数字之后所剩的三位数的3倍，这个四位数是多少？
    Web(二)html5基础-超链接的应用(知识训练和编程训练)
    ovs vxlan 时延和吞吐
    如何在银行系统中做批量测试~
    golang 多个struct 转换融合为一个json，平级融合或者多级融合
    NODEJS杂记
    biopython----bio.PDB
    劫持TLS绕过canary pwn89
    Java8方法引用和Lambda表达式实例源码+笔记分享
    centos 7 中没有iptables 和service iptables save 指令使用失败问题解决方案
  • 原文地址：https://blog.csdn.net/m0_73969113/article/details/132630983