• c++——构造函数， 析构函数，拷贝构造函数，赋值运算符重载，const成员

    一.构造函数

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

    2.作用：初始化对象。

    3.特性：

    (1). 函数名与类名相同。

    (2). 无返回值。

    (3). 对象实例化时编译器自动调用对应的构造函数。

    (4). 构造函数可以重载。

    1. #include
    2. using namespace std;
    3. class lin
    4. {
    5. public:
    6. 	// 1.无参构造函数
    7. 	lin()
    8. 	{
    9. 		cout << "lin1" << endl;
    10. 	}
    11. 	// 2.带参构造函数
    12. 	lin(int year, int month, int day)
    13. 	{
    14. 		_year = year;
    15. 		_month = month;
    16. 		_day = day;
    17. 		cout << "lin2" << endl;
    18. 	}
    19. private:
    20. 	int _year;
    21. 	int _month;
    22. 	int _day;
    23. };
    24. void Testlin()
    25. {
    26. 	lin d1; // 调用无参构造函数
    27. 	lin d2(2022, 8, 10); // 调用带参的构造函数
    28.  
    29. 	lin d3();//如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    30. }
    31. int main()
    32. {
    33. 	Testlin();
    34. 	return 0;
    35. }

     4. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定 义编译器将不再生成。

    1. #include 
    2. using namespace std;
    3. class lin
    4. {
    5. public:
    6. 	/*
    7. 	// 如果用户显式定义了构造函数，编译器将不再生成
    8. 	lin(int year, int month, int day)
    9. 	{
    10. 	_year = year;
    11. 	_month = month;
    12. 	_day = day;
    13. 	}
    14. 	*/
    15.  
    16. 	void Print()
    17. 	{
    18. 		cout << _year << "-" << _month << "-" << _day << endl;
    19. 	}
    20. private:
    21. 	int _year;
    22. 	int _month;
    23. 	int _day;
    24. };
    25. int main()
    26. {
    27. 	// 将lin类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
    28. 	// 将lin类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
    29. 	lin d;
    30. 	//lin d1(1);// 没有合适的默认构造函数可用
    31. 	d.Print();
    32. 	return 0;
    33. }

     

     5.：C++11 中针对自定义类型初始化，内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时 可以给默认值。

    6.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参 构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

    1. #include 
    2. using namespace std;
    3. class lin
    4. {
    5. public:
    6. 	/*lin()
    7. 	{
    8. 		_year = 2022;
    9. 		_month = 8;
    10. 		_day = 10;
    11. 		cout << "lin1	" << _year <<"/" << month<<"/" << day << endl;
    12. 	}*/
    13. 	lin(int year = 2022, int month = 8, int day = 10)
    14. 	{
    15. 		_year = year;
    16. 		_month = month;
    17. 		_day = day;
    18. 		cout << "lin2	" << _year <<"/" << month<<"/" << day << endl;
    19. 	}
    20. private:
    21. 	int _year;
    22. 	int _month;
    23. 	int _day;
    24. };
    25. int main()
    26. {
    27. 	lin d;
    28. 	return 0;
    29. }

    二.析构函数

    1.概念：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成 的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

    2.特性

    (1). 析构函数名是在类名前加上字符 ~。

    (2). 无参数无返回值类型。

    (3). 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。

    (4)析构函数不能重载

    (5). 对象生命周期结束时，C++编译系统系统自动调用析构函数。

    1. #include
    2. using namespace std;
    3. typedef int DataType;
    4. class Stack
    5. {
    6. public:
    7. 	Stack(size_t capacity = 3)
    8. 	{
    9. 		_a = (DataType*)malloc(sizeof(DataType) * capacity);
    10. 		if (NULL == _a)
    11. 		{
    12. 			perror("malloc申请空间失败:");
    13. 			return;
    14. 		}
    15. 		_capacity = capacity;
    16. 		_size = 0;
    17. 	}
    18. 	void Push(DataType data)
    19. 	{
    20. 		_a[_size] = data;
    21. 		_size++;
    22. 	}
    23. 	~Stack()
    24. 	{
    25. 		if (_a)
    26. 		{
    27. 			free(_a);
    28. 			_a = NULL;
    29. 			_capacity = 0;
    30. 			_size = 0;
    31. 		}
    32.         cout << "~Stack()" << endl;
    33. 	}
    34. private:
    35. 	DataType* _a;
    36. 	int _capacity;
    37. 	int _size;
    38. };
    39. int main()
    40. {
    41. 	Stack s;
    42. 	s.Push(1);
    43. 	s.Push(2);
    44. }

    三.拷贝构造函数

    1.概念：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型 对象创建新对象时由编译器自动调用 

    2.特性：

    (1). 拷贝构造函数是构造函数的一个重载形式。

    (2). 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发 无穷递归调用。

    1. #include
    2. using namespace std;
    3. class lin
    4. {
    5. public:
    6. 	lin(int year = 2022, int month = 8, int day = 10)
    7. 	{
    8. 		_year = year;
    9. 		_month = month;
    10. 		_day = day;
    11. 	}
    12. 	// lin(const lin d) // 错误写法：编译报错，会引发无穷递归
    13. 	lin(const lin& d) // 正确写法
    14. 	{
    15. 		_year = d._year;
    16. 		_month = d._month;
    17. 		_day = d._day;
    18. 	}
    19. private:
    20. 	int _year;
    21. 	int _month;
    22. 	int _day;
    23. };
    24. int main()
    25. {
    26. 	lin d1;
    27. 	lin d2(d1);
    28. 	return 0;
    29. }

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

    4.：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构 造函数是一定要写的，否则就是浅拷贝,为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引 用。

    5.拷贝构造函数典型调用场景：

    C++中拷贝构造函数的总结详解
    pdf 0星 超过10%的资源 65KB
    下载

    (1).使用已存在对象创建新对象

    (2)函数参数类型为类类型对象

    (3)函数返回值类型为类类型对象

    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	Date(int year, int minute, int day)
    7. 	{
    8. 		cout << "Date(int,int,int):" << this << endl;
    9. 	}
    10. 	Date(const Date& d)
    11. 	{
    12. 		cout << "Date(const Date& d):" << this << endl;
    13. 	}
    14. 	~Date()
    15. 	{
    16. 		cout << "~Date():" << this << endl;
    17. 	}
    18. private:
    19. 	int _year;
    20. 	int _month;
    21. 	int _day;
    22. };
    23. Date Test(Date d)
    24. {
    25. 	Date temp(d);//调用拷贝构造函数创建temp
    26. 	return temp;//函数以值方式返回，返回时使用temp拷贝构造临时对象来返回
    27. }
    28. int main()
    29. {
    30. 	Date d1(2022, 8, 10);//调用构造函数创建的d1
    31. 	Test(d1);//Test以值传递的方式传参时调用拷贝构造函数创建d
    32. 	return 0;
    33. }

     四..赋值运算符重载

    1.概念：C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。 函数名字为：关键字operator后面接需要重载的运算符符号。

    2.函数原型：返回值类型 operator操作符(参数列表）

    3.注意：

    (1) 不能通过连接其他符号来创建新的操作符：比如operator@

    (2) 重载操作符必须有一个类类型参数

    (3) 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义

    (4) 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

    (5) (.*)( ::)( sizeof)(  ?)( :  .) 注意以上5个运算符不能重载。

    4.赋值运算符重载格式：

    (1)参数类型：const T&，传递引用可以提高传参效率

    (2)返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

    (3)检测是否自己给自己赋值

    详解C++ 拷贝构造函数
    pdf 0星 超过10%的资源 60KB
    下载

    (4)返回*this ：要复合连续赋值的含义

    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	Date(int year = 2022, int month = 8, int day = 10)
    7. 	{
    8. 		_year = year;
    9. 		_month = month;
    10. 		_day = day;
    11. 	}
    12.  
    13. 	Date(const Date& d)
    14. 	{
    15. 		_year = d._year;
    16. 		_month = d._month;
    17. 		_day = d._day;
    18. 	}
    19.  
    20. 	Date& operator=(const Date& d)
    21. 	{
    22.         //检查是否为自己为自己赋值
    23. 		if (this != &d)
    24. 		{
    25. 			_year = d._year;
    26. 			_month = d._month;
    27. 			_day = d._day;
    28. 		}
    29. 		return *this;
    30. 	}
    31. private:
    32. 	int _year;
    33. 	int _month;
    34. 	int _day;
    35. };
    36.  
    37. int main()
    38. {
    39. 	return 0;
    40. }

    5.赋值运算符只能重载成类的成员函数不能重载成全局函数

    1. class Date
    2. {
    3. public:
    4.  Date(int year = 1900, int month = 1, int day = 1)
    5.  {
    6.  _year = year;
    7.  _month = month;
    8.  _day = day;
    9.  }
    10.  int _year;
    11.  int _month;
    12.  int _day;
    13. };
    14. // 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
    15. Date& operator=(Date& left, const Date& right)
    16. {
    17.  if (&left != &right)
    18.  {
    19.  left._year = right._year;
    20.  left._month = right._month;
    21.  left._day = right._day;
    22.  }
    23.  return left;
    24. }
    25. // 编译失败：
    26. // error C2801: “operator =”必须是非静态成员

    原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

    6.用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

    7.日期类的实现

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

     五：const成员

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

    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	Date(int year, int month, int day)
    7. 	{
    8. 		_year = year;
    9. 		_month = month;
    10. 		_day = day;
    11. 	}
    12. 	void Print()
    13. 	{
    14. 		cout << "Print()" << endl;
    15. 		cout << "year:" << _year << endl;
    16. 		cout << "month:" << _month << endl;
    17. 		cout << "day:" << _day << endl << endl;
    18. 	}
    19. 	void Print() const
    20. 	{
    21. 		cout << "Print()const" << endl;
    22. 		cout << "year:" << _year << endl;
    23. 		cout << "month:" << _month << endl;
    24. 		cout << "day:" << _day << endl << endl;
    25. 	}
    26. private:
    27. 	int _year; 
    28. 	int _month; 
    29. 	int _day; 
    30. };
    31. void Test()
    32. {
    33. 	Date d1(2022, 8, 10);
    34. 	d1.Print();
    35. 	const Date d2(2022, 8, 10);
    36. 	d2.Print();
    37. }
    38.  
    39. int main()
    40. {
    41. 	Test();
    42. 	return 0;
    43. }

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

    1. class Date
    2. { 
    3. public :
    4.  Date* operator&()
    5.  {
    6.  return this ;
    7.  }
    8.  
    9.  const Date* operator&()const
    10.  {
    11.  return this ;
    12.  }
    13. private :
    14.  int _year ; // 年
    15.  int _month ; // 月
    16.  int _day ; // 日
    17. };

    这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比 如想让别人获取到指定的内容！

  • 相关阅读:
    DevOps的出现带来的变化
    纳米银和巯基共修饰SiO2包裹Fe3O4磁性微球/空腔型Fe3O4@mSiO2-AuNCs复合微球制备方法
    多线程-线程池
    纯css就能实现可点击切换的轮播图，feel起来很丝滑
    新移动时代内容制作呈现与开发利器-Zoomla!逐浪CMS v8.6.2发布
    小程序也能是App中的引流神器？
    【MATLAB】求解含有三角函数的方程
    yhtest
    变量、常量以及与其他语言的差异 - Go语言从入门到实战
    C++项目实战-UDP服务器
  • 原文地址：https://blog.csdn.net/qq_64425854/article/details/126266586