（C++初阶）类&对象 二

最新推荐文章于 2023-12-14 15:08:40 发布
最新推荐文章于 2023-12-14 15:08:40 发布
阅读量262 收藏
点赞数 1
分类专栏： C/C++学习笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57594025/article/details/125463090
版权

目录

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

2. 构造函数

3. 析构函数

4. 拷贝构造函数

5. 赋值操作符重载

6. 日期类的实现

7. const成员函数

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

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

1.1  构造函数：初始化。
1.2  析构函数：清理
1.3  拷贝构造函数：使用同类对象初始化创建对象。
1.4  赋值运算符的重载：把一个对象赋值给另外一个对象。
1.4  取地址重载：普通对象和const对象取地址。
1.5  针对我们丕写编译默认生成的总结：
      ① 构造和析构的特性是类似，我们不写，编译器内置类型不处理，自定义类型调用它的构造和析构处理。
      ② 拷贝构造和赋值重载特性是类似的，内置类型会完成浅拷贝，自定义类型会调用他们的拷贝构造和赋值重载。

2. 构造函数

2.1构造函数: 是一个特殊的成员函数，名字与类名相同 , 创建类类型对象时由编译器自动调用 ，保证每个数据成员 都有 一个合适的初始值，并且 在对象的生命周期内只调用一次 。
2.2构造函数是特殊的成员函数 ，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主 要任务 并不是开空间创建对象，而是初始化对象 。
2.3特征：
     函数名与类名相同。
     无返回值。
     对象实例化时编译器自动调用对应的构造函数。
     构造函数可以重载。
2.4 默认构造函数：不用参数就可以调用的构造函数。
①我们不写，编译器自动生成的。
②我们自己写的无参的。
③我们自己写的全缺省。

2.5 例

//类里面我们什么函数都不写的时候，编译器会自动生成六个成员函数，这六个函数就叫默认成员函数。
//1、构造函数->对象的初始化。
//
class Date
{
public:
	//构造函数，函数名与类名相同,需要我们自己写。
	//在对象实例化的时候自动调用，保证对象一定会初始化。
	//全缺省
	Date(int year=2022, int month=6, int day=26)
	{
		_year = year;  
		_month = month;
		_day = day;    
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 6, 25);
	d1.print();

	Date d2;
	d2.print();
	return 0;
}

3. 析构函数

3.1 概念：
析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而 对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。
3.2 特性：
析构函数 是特殊的成员函数。
1. 析构函数名是在类名前加上字符 ~ 。
2. 无参数无返回值。
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时， C++ 编译系统系统自动调用析构函数。

3.3 示例

class Date
{
public:
	Date(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		_capacity = capacity;
		_size = 0;
	}
	void push(int x)
	{
		;
	}
	//析构函数
	~Date()
	{
		//资源的清理。
		free(_a);
		_a = nullptr;
		_size = _capacity = 0;
	}

private:
	int* _a;
	int _size;
	int _capacity;
};

int main()
{
	//因为对象是定义在函数中的，而函数调用会建立栈帧，栈帧中的对象构造和析构也要遵循先进后出原则。
	//d1 先构造 d2后构造，d2 先析构 d1 后析构。
	Date d1;
	d1.push(1);
	d1.push(2);
	d1.push(3);

	Date d2;
	d2.push(1);
	d2.push(2);
	d2.push(3);

	return 0;
}

4. 拷贝构造函数

4.1  概念：

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

4.2  拷贝构造函数也是特殊的成员函数，其特征如下：

① 拷贝构造函数 是构造函数的一个重载形式 。
② 拷贝构造函数的 参数只有一个 且 必须使用引用传参 ，使用 传值方式会引发无穷递归调用。
③ 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷 贝，这种拷贝我们叫做浅拷贝，或者值拷贝。
4.3 示例 
//拷贝构造函数--拷贝初始化
class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 6, int day = 26)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//析构函数
	~Date()
	{
		//资源的清理。
	}
	//拷贝构造函数
	//必须传引用传参，不然会发生无穷递归。
	//是默认成员函数，我们不写编译器会自动生成拷贝构造函数。
	//这个拷贝构造对内置类型会完成浅拷贝，或者值拷贝。
	//像Stack这样的类不能是浅拷贝。需要深拷贝。如果浅拷贝，会发现生析构两次的问题。
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 6, 25);
	Date d2(d1);

	return 0;
}

5. 赋值操作符重载

5.1 运算符重载

①  ‘ .* ’、‘  ::  ’、‘ sizeof ’、‘ ?: ’、‘ . ’ 这五个运算符不能重载。

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

5.2 示例

class Date
{
public:
	//构造函数
	Date(int year=2022, int month=6, int day=26)
	{
		_year = year;  
		_month = month;
		_day = day;    
	}
	//析构函数
	~Date()
	{
		//资源的清理。
		//cout << "~Date" << endl;
	}
	//运算符重载
	//当运算符有两个操作数时，第一个操作数是左操作数，第二个操作数是右操作数。
	bool operator==(Date x)
	{
		return _year == x._year\
			&& _month == x._month\
			&& _day == x._day;
	}
	bool operator<(Date x)
	{
		if (_year < x._year)
		{
			return true;
		}
		else if (_year == x._year)
		{
			if (_month < x._month)
			{
				return true;
			}
			else if (_month == x._month)
			{
				if (_day < x._day)
					return true;
			}
		}
		return false;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 6, 25);
	Date d2(2022, 6, 26);
	//内置类型语言层面就支持运算符。
	//自定义类型默认不支持。C++可以用运算符重载，来让类对象支持某个运算符。
	cout<<(d1 == d2)<<endl;
	cout << (d1 < d2) << endl;
	return 0;
}
5.3 赋值运算符重载
示例： 
//赋值运算符重载
class Date
{
public:
	//构造函数
	Date(int year=2020, int month=1, int day=11)
	{
		_year = year;  
		_month = month;
		_day = day;    
	}
	//析构函数
	~Date()
	{
		//资源的清理。
		//cout << "~Date" << endl;
	}
	//运算符重载
	//当运算符有两个操作数时，第一个操作数是左操作数，第二个操作数是右操作数。
	//写成成员函数省略掉一个操作数。因为隐含一个this
	//bool operator==(Date* this，const Date& x) 
	bool operator==(const Date& x)  
	{
		return _year == x._year\
			&& _month == x._month\
			&& _day == x._day;
	}
	bool operator<(const Date& x)
	{
		if (_year < x._year)
		{
			return true;
		}
		else if (_year == x._year)
		{
			if (_month < x._month)
			{
				return true;
			}
			else if (_month == x._month)
			{
				if (_day < x._day)
					return true;
			}
		}
		return false;
	}
	//赋值运算符重载
	Date& operator=(const Date& x)
	{
		if (this != &x)//不是自己给自己赋值，才需要拷贝。
		{
			_year = x._year;
			_month = x._month;
			_day = x._day;
			return *this;
		}
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 6, 25);
	Date d2(2022, 6, 26);
	Date d3;
	d1.print();
	d2.print();
	d3.print();
	//内置类型语言层面就支持运算符。
	//自定义类型默认不支持。C++可以用运算符重载，来让类对象支持某个运算符。
	d3= d2 = d1;
	d2.print();
	d3.print();
	return 0;
}

6. 日期类的实现

6.1 Date.cpp 
#include"date.h"

inline int GetMonthDay(int year, int month)
{
	//存储平年每月天数
	static int DayArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30 };
	int day = DayArray[month];
	if (month == 2 && (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
	{
		day=29;
	}
	return day;
}
//构造函数
Date::Date(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
	//检查日期的合法性
	if (year>=0 && month>0 && month<13 && day<= GetMonthDay(year,month) && day>0)
	{
		cout << "合法日期" << endl;
		cout << year << "年" << month << "月" << day << "日" << endl;
	}
	else
	{
		cout << "非法日期" << endl;
		cout << year << "年" << month << "月" << day << "日" << endl;
	}

}
void Date::print()
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
//析构、拷贝构造、赋值重载，可以不写，默认生成的就够用了
//像Stack这样的才需要自己写。
Date& Date:: operator+=(int day)
{
	if (day < 0)
	{
		*this -= -day;
	}
	else
	{
		_day += day;
		while (_day > GetMonthDay(_year, _month))
		{
			_day -= GetMonthDay(_year, _month);
			_month++;
			if (_month > 12)
			{
				_month = 1;
				_year++;
			}
		}
	}
	return *this;
}
Date Date:: operator+(int day)
{
	Date ret(*this);
    //复用+=
	ret += day;
	return ret;
}
Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		*this += -day;
	}
	else
	{
		_day -= day;
		while (_day <= 0)
		{
			--_month;
			if (_month <= 0)
			{
				_month = 12;
				--_year;
			}
			_day += GetMonthDay(_year, _month);
		}
	}
	return  *this;
}
Date Date:: operator-(int day)
{
	Date ret(*this);
	//复用-=
	ret -= day;
	return ret;
}
Date& Date::operator++()
{
	*this += 1;
	return *this;
}
Date Date::operator++(int)
{
	Date tem(*this);
	*this += 1;
	return tem;
}
Date& Date::operator--()
{
	*this -= 1;
	return *this;
}
Date Date::operator--(int)
{
	Date tem(*this);
	*this -= 1;
	return tem;
}
bool Date::operator<(const Date& d)
{
	if (_year < d._year)
	{
		return true;
	}
	else if (_year == d._year)
	{
		if (_month < d._month)
		{
			return true;
		}
		else if (_month == d._month)
		{
			if (_day < d._day)
			{
				return true;
			}
		}
	}
	return false;
}
bool Date::operator==(const Date& d)
{
	return  _year == d._year
		&& _month == d._month
		&& _day == d._day;
}
bool Date::operator<=(const Date& d)
{
	return *this < d || *this == d;
}
bool Date::operator>(const Date& d)
{
	return !(*this <= d);
}
bool Date::operator>=(const Date& d)
{
	return *this > d || *this == d;
}
bool Date::operator!=(const Date& d)
{
	return !(*this==d);
}
int Date::operator-(const Date& d)
{
	Date max = *this;
	Date min = d;
	int flag = 1;
	if (*this < d)
	{
		max = d;
		min = *this;
	    flag = -1;
	}
	int n = 0;
	while (max != min)
	{
		min++;
		n++;
	}
	return n*flag;
}

6.2 Date.h

#pragma once
#include<iostream>
#include<assert.h>

using std::cout;
using std::cin;
using std::endl;

class Date
{
public:
    //构造函数
    Date(int year = 2020, int month = 1, int day = 11);
    void print();
    //析构、拷贝构造、赋值重载，可以不写，默认生成的就够用了
    //像Stack这样的才需要自己写。

    Date& operator+=(int day);
    Date  operator+(int day);

    Date& operator-=(int day);
    Date  operator-(int day);

    //++d->d.operator++(&d)
    //d++->d.operator++(&d,0)
    //int 参数不需要给实参，因为没用，它的作用是为了跟前置++构成函数重载。 
    Date& operator++();
    Date operator++(int);

    Date& operator--();
    Date operator--(int);

    bool operator<(const Date& d);
    bool operator>(const Date& d);
    bool operator<=(const Date& d);
    bool operator>=(const Date& d);
    bool operator==(const Date& d);
    bool operator!=(const Date& d);

    int operator-(const Date& d);

private:
    int _year;
    int _month;
    int _day;
};

6.3 test.c

#include"date.h"

int main()
{
	Date d1(2022,6,26);
	d1.print();
	Date d2(2022,9,26);
	d2.print();
	d1 += 26;
	//d1 -= -26;
	//d1.print();
	Date d5=d1+(-26);
	//d1 += -26;
	//d1.print();
	Date d2(2022, 2, 28);//非法日期的测试
	//Date retd = --d1;
	//retd.print();
	//retd=d1--;
	//retd.print();
	//d1.print();

	cout << (d2 - d1) << endl;
	cout << (d1 - d2) << endl;
	return 0;
}

7. const成员函数

7.1  将 const 修饰的类成员函数称之为 const 成员函数 ， const 修饰类成员函数，实际修饰该成员函数 隐含的 this 指针 ，表明在该成员函数中 不能对类的任何成员进行修改。
7.2  
	void print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

........
	Date d1(2022, 6, 25);
	d1.print();  //权限缩小
	const Date d2; 
	d2.print();

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

8.1 基本用不到。了解他俩是默认成员函数就行。
Zhang丶&｜！
关注
专栏目录
Python_Day12 - 关于时间的系统模块 & 面向对象 & 类和对象 &构造函数与析构函数
Lancelot_Lv的博客
08-04 292
1. 几个关于时间的系统模块 2. 面向对象的思想 3. 类和对象 4. 构造函数和析构函数
C++初阶：类和对象
weixin_36194037的博客
09-21 340
C++初阶：类和对象
[C++] 类与对象（中）6大默认成员函数：构造、析构、拷贝构造、赋值操作符重载、const修饰符等
giturtle's blog
06-27 444
类与对象思维导图1. 构造函数2. 析构函数3. 拷贝构造函数4. 赋值运算符重载函数5. 普通对象取地址重载函数6. const对象度地址重载函数 思维导图 1. 构造函数 对于Date类，可以通过SetDate()公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？ 构造函数是一个特殊的成员函数，名字与类名相同,创建类...
C++——类
weixin_30344131的博客
09-08 107
1.类和结构体，只有的默认访问权限的区别 2.类内不能定义和类外类型名相同的类型名。为什么？typedef机制？ typedef double money; class Account { private: typedef double money;//❌ } 3.变量名一致时的调用（不推荐相同的变量名） pos height; class Sc...
C++~类和对象（一）
weixin_54792212的博客
04-10 1029
前言 类和对象是基于面向对象的语言的精髓所在，之前的C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。而面向对象，关注的是对象，将一件件事情拆分成不同的对象，靠对象之间交互完成 一、类 C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数 struct Student { void SetStudentInfo(const char* name, const char* gender, int age) { strcpy(_name,
c++初阶 类和对象 中级篇
01-22
"C++类和对象中级篇" 本篇文章讲解了C++中类和对象的中级知识，涵盖了类的6个默认成员函数、构造函数、析构函数、拷贝构造函数、赋值运算符重载、日期类的实现等内容。 一、类的6个默认成员函数 在C++中，如果一...
C++初阶+类和对象（上）.pdf
01-17
C++初阶+类和对象（上） 本节课将介绍C++中的类和对象的概念，包括面向过程和面向对象的初步认识、类的引入、类的定义、类的访问限定符及封装、类的作用域、类的实例化、类对象模型、this指针等内容。 1. 面向过程...
C++类和对象练习 实现日期类
07-29
为了更好的理解`C++`类和对象的知识,我们可以动手实现一下`C++`的一个简单的日期类,完成相应的函数,更好的帮助我们理解类和对象. 从日期类的构造函数,拷贝构造,获取当月天数,日期与天数的运算,日期类相关的比较...
C++初阶：STL之vector类模板
最新发布
weixin_36194037的博客
12-14 1530
C++初阶：STL之vector类模板
Java小程序--关于Date类的构造函数的重载
11-12
对于Date类中的构造函数，使用重载的方法，可以选择3中方式输出：1.MM/XX/DDDD 2.January 7 1989 3.37 1989(前一个参数为一年中的第37天) 使用s.equal("m")比较字符串。
创建一个日期类，定义几个变量：年、月、日、小时、分钟、秒；
01-01
创建一个日期类，定义几个变量：年、月、日、小时、分钟、秒；构造函数的参数为System.DateTime类型，然后将值分别赋给定义的变量；然后构造两个重载方法SetTime，分别使用按值传递参数和按引用传递参数方式来对定义的变量进行计算。然后定义一个方法DisplayTime将这些变量的值输出。试比较按值传递和按引用传递这两种方式的区别。 提示：方法采用两种方式来传递参数，默认按照值传递的方式，另一种为按引用传递。方法只能有一个返回值，当然这个返回值可能是程序员定义的多个值集合的一个结构。当程序需要多于一个返回值时，如果只允许按值传递，会带来不便。而按引用传递参数，使得可以按需要同时返回的几个值都作为参数传递给方法，被调用的方法在其程序的内部对这些值做了修改后，调用者可以访问这些按引用传递的参数，来获取被调用方法计算的结果。
C++ ~ 类的封装
shouwangyunkai666的博客
09-01 275
1、类概述 类是一个新的数据类型，它和结构体有些相似，是由不同数据类型组成的结合体，但类要比结构体增加了操作数据的行为，这个行为就是函数。 2、类的访问控制关键字 1）public: 修饰的成员变量和函数 可以在类的内部和类的外部访问 2）private: 修饰的成员变量和函数 只能在类的内部被访问,不能在类的外部访问 3）protected: 修饰的成员变量和函数 只能在类...
关于C++的类详细解析（学习笔记）
Cser_zhu的博客
07-17 1486
类的定义 class 类型名 { 数据成员 成员函数 }; 这里类型名相当于一种数据类型，用来定义对象。 公共、私有和保护 private 只有该类的成员函数和友元函数才能访问这些成员 public 所有的函数都可以访问这些函数 protected 在具有private特性的同时，可以由派生类（通过继承而生成的类中的成员函数来访问 数据成员和成员函数 成员函数的使用 首先定义一个类的对象，格式为： 类名 对象名 有了对象之后，就可以用对象来访问类中的成员函数了。可以用句点或者指针形式，定义一个
构造函数，拷贝构造函数，析构函数，运算符重载
JavaScripe2013的博客
10-21 1903
一、构造函数 1、概念  构造函数是一种特殊的成员函数。名字与类名相同，创建类类型对象时，由编译器自动调用，在对象的声明周期内只调用一次，以保证每个数据成员都有一个合适的初始值。   2、构造函数的特性 （1）函数名与类名相同； （2）没有返回值； （3）有初始化列表； （4）新对象被创建，由编译器自动调用，且在对象的生命周期内仅调用一次； （
C++面向对象----类
ahui_is_so_cool的博客
02-28 415
C++类部分知识点
构造函数与析构函数的调用时间
别动我u盘-的博客
02-13 1927
    构造函数与析构函数是被编译器隐式调用的。这些函数的调用时间取决于程序执行进入和离开实例化对象的作用域的顺序。通常，析构函数的调用顺序和对应构造函数的调用顺序相反。但是，对象的存储类别可以改变析构函数的调用顺序。    在全局作用域内定义的构造函数在该文件中任何其他函数（包括main函数）开始执行之前执行（尽管文件间的构造函数的执行顺序是不确定的）。在main函数终止时，调用相应的析构函数。...
类和对象（日期类）（构造函数、拷贝构造、析构、赋值操作符重载、this指针）
sophia__yu的博客
06-08 1114
首先，了解三种访问限定符： 1. public成员可从类外部直接访问，private/protected成员不能从类外部直接访问。 2. 每个限定符在类体中可使用多次，它的作用域是从该限定符出现开始到下一个限定符之前或类体结束前。 3. 类体中如果没有定义限定符，则默认为私有的。 4. 类的访问限定符体现了面向对象的封装性。 类实例化对象： 成员函数的声明和定义 1.类内定义...
程序设计与算法（三）C++面向对象程序设计笔记 第四周 运算符重载
zimuzi2019的博客
10-20 619
程序设计与算法（三）C++面向对象程序设计笔记 第四周 运算符重载
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Zhang丶&｜！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值