C++初阶--类与对象(2)

文章目录

  • 类的6个默认成员函数
  • 构造函数
    • 默认构造函数的用处:
  • 析构函数
    • 默认析构函数的用处
  • 拷贝构造函数
  • 赋值运算符重载
  • 取地址及const取地址操作符重载

类的6个默认成员函数

对于一个没有成员的类来说,称之为空类;
但空类并非完全是空的,类会自动生成6个默认的成员函数:
C++初阶--类与对象(2)_第1张图片

构造函数

概念:构造函数是一种特殊的成员函数,它在创建对象时被调用,用于初始化对象的数据成员。构造函数和类名相同,并且没有返回类型,甚至不能包含return语句

class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
};
int main()
{
	Date d1;
	d1.Print();
}

像这种情况,我们没有创建一个构造函数,编译器会自动调用默认构造函数,
C++初阶--类与对象(2)_第2张图片
产生结果都是随机值

class Date
{
private:
	int _year ;
	int _month;
	int _day;
public:
	//无参构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	//如果没有构造参数,编辑器会自动生成一个默认构造参数

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
};
int main()
{
	Date d1;
	d1.Print();
}

C++初阶--类与对象(2)_第3张图片
在我们的主程序中,我们没有使用我们的构造函数,但实际上,在我们创建d1对象时,编译器就已经开始调用我们的构造函数了;
创建类类型对象时由编译器自动调用,以保证每个数据成员都有 一个合适的初始值,并且在对象整个生命周期内只调用一次

也可将上面的无参构造参数改为这两种:

//全缺省参数构造函数
	Date(int year = 2, int month = 2, int day = 2)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//普通的构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
int main()
{
	//调用带参数的构造函数,在创建对象的后面加上(...)
	Date d1(2023,10,24);
}

这些都是构造函数,那有什么不同吗?
在这里,无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。
C++初阶--类与对象(2)_第4张图片
当然,现在一些编译器也不让存在多个构造函数了:
C++初阶--类与对象(2)_第5张图片
所以,如果要自己实现构造参数的话,写一个即可
而在C++11给出规定:C++11支持在内置类型变量声明处加上缺省值
C++初阶--类与对象(2)_第6张图片
我们也可以这么操作。

默认构造函数的用处:

C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型,如:int/char…,自定义类型就是我们使用class/struct/union等自己定义的类型。

如果类中存在自定义类型的成员,可没有办法用过赋予缺省值来进行初始化,所以,可以通过调用默认构造参数,来实现对该类型进行初始化;

class Stack
{
private:
	int* _a;
	int _top;
	int _capacity;
public:
	Stack(int capacity = 3)
	{
		cout << "Stack(int capacity = 3)" << endl;
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("Stack Fail");
			exit(-1);
		}

		_top = 0;
		_capacity = capacity;
	}

	
};

class MyQuene
{
private:
	Stack _PushSta;
	Stack _PopSta;
	int _size=20;
public:
	void Print()
	{
		cout << "MyQuene Print" << endl;
	}
};

int main()
{

	Stack s1;

	MyQuene m1;

	return 0;
}

C++初阶--类与对象(2)_第7张图片
C++初阶--类与对象(2)_第8张图片

析构函数

概念:析构函数是一种特殊的成员函数,它在对象被销毁时自动调用,用于执行清理操作和释放对象所占用的资源。析构函数的名称与类名相同,但前面需加上一个波浪线~作为前缀。

注意:如果没有明确的定义析构函数,编译器会提供一个默认的析构函数。默认析构函数不执行任何清理工作,仅释放对象所占内存空间

class Date
{
private:
	//C++11支持在内置类型变量声明处加上缺省值
	int _year = 1;
	int _month = 1;
	int _day = 1;
public:
	Date(int year = 2, int month = 2, int day = 2)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
//析构函数
	~Date()
	{
		cout << "~Date()" << endl;
	}
};
int main()
{
	Date d1;
	return 0;
}

C++初阶--类与对象(2)_第9张图片

默认析构函数的用处

class Stack
{
private:
	int* _a;
	int _top;
	int _capacity;
public:
	Stack(int capacity = 3)
	{
		cout << "Stack(int capacity = 3)" << endl;
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("Stack Fail");
			exit(-1);
		}

		_top = 0;
		_capacity = capacity;
	}
	//自定义一个析构函数
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
//默认的析构函数不会释放堆区上的空间,需要自己实现对资源的释放
	
};

class MyQuene
{
private:
	Stack _PushSta;
	Stack _PopSta;
	int _size=20;
public:
	void Print()
	{
		cout << "MyQuene Print" << endl;
	}
	//让它默认生成析构函数
};

int main()
{
	Stack s1;
	MyQuene m1;

	return 0;
}

C++初阶--类与对象(2)_第10张图片

析构函数会在一个函数内,进行栈帧销毁之前将类对象进行析构;
C++初阶--类与对象(2)_第11张图片
C++初阶--类与对象(2)_第12张图片

拷贝构造函数

概念:拷贝构造函数是一种特殊的成员函数,用于创建一个新对象并将其初始化为已有对象的副本。只有单个形参,该形参是对本类类型对象的引用(一般常用const修饰),在用已存在的类类型对象创建新对象时由编译器自动调用

特征:
拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须是类类型对象的引用

普通 情况下:

class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	Date(int year = 2, int month = 2, int day = 2)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	
	~Date()
	{
		cout << "~Date()" << endl;
	}

	void Func(Date d)
	{
		d.Print();
	}
};

class Stack
{
private:
	int* _a;
	int _top;
	int _capacity;
public:
	Stack(int capacity = 3)
	{
		cout << "Stack(int capacity = 3)" << endl;
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("Stack Fail");
			exit(-1);
		}

		_top = 0;
		_capacity = capacity;
	}

	
	//自定义一个析构函数
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
	void Print()
	{
		cout << "Stack" << endl;
	}
	void Func(Stack* s)
	{
		s->Print();
	}
	
};
class MyQuene
{
private:
	Stack _PushSta;
	Stack _PopSta;
	int _size=20;
public:
	void Print()
	{
		cout << "MyQuene Print" << endl;
	}
	//让它默认生成析构函数
};


int main()
{
	Date d1(2023,10,22);
	d1.Func(d1);
	

	Stack s1;
	s1.Func(s1);
}

C++初阶--类与对象(2)_第13张图片
C++初阶--类与对象(2)_第14张图片
原因:
C++初阶--类与对象(2)_第15张图片
在这里插入图片描述

所以,这里就有了拷贝构造函数这一函数;
写法:

Date(const Date& d)
	{
		cout << "Date(Date& d)" << endl;

		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
Stack(Stack& s)
	{
		cout << "Stack(Stack& s)" << endl;
		_a = (int*)malloc(sizeof(int) * s._capacity);
		if (_a == nullptr)
		{
			perror("Stack Fail");
			exit(-1);
		}

		_top = s._top;
		_capacity = s._capacity;
	}
int main()
{
	Stack s1;
	s1.Func(&s1);
	

	MyQuene q1;
	MyQuene q2(q1);
}

C++初阶--类与对象(2)_第16张图片
由于d1对象已存在,所以对于形参d来说,就会自动调用拷贝构造函数;

注意
C++初阶--类与对象(2)_第17张图片

测试:

Date Test(Date d)
{
	Date dd(d);
	return dd;
}

C++初阶--类与对象(2)_第18张图片

赋值运算符重载

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

注意
不能通过连接其他符号来创建新的操作符:比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符,其含义不能改变,例如:内置的整型+,不 能改变其含义
作为类成员函数重载时,其形参看起来比操作数数目少1,因为成员函数的第一个参数为隐藏的this

在Date类中写:

//域内有一个隐藏的this指针,所以把第一个参数看作是this指针所指向的
	bool operator>(const Date& y)
	{
		if (_year > y._year)
		{
			return true;
		}
		else if (_year == y._year && _month > y._month)
		{
			return true;
		}
		else if (_year == y._year && _month == y._month &&_day > y._day)
		{
			return true;
		}
		return false;
	}

测试:

Date d1;
	Date d2(2023, 10, 22);
	cout << (operator>(d1, d2)) << endl;
	//可以简写
	cout << (d1 > d2) << endl;

d1被看作是this指针指向的对象,在写运算符重载函数时,可以省略第一个比较参数;
在实际上的比较操作时,可以像内置类型一样,直接使用运算符来进行比较;

对于赋值运算符重载,他是有默认函数的,也就是以值的方式逐字节拷贝;

默认情况下:
C++初阶--类与对象(2)_第19张图片
自己实现情况下:

//引用提高效率,由于主函数会有一个类对象来进行赋值,所以对象是存在的
	Date& operator=(const Date& y)
	{
		if (this != &y)//如果是类对象对自己赋值,这种情况没必要
		{
			_year = y._year;
			_month = y._month;
			_day = y._day;
		}
		return *this;
	}

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

像这种赋值运算,对于一般情况,都是可以使用默认的赋值重载的,但如果类成员函数涉及到资源管理的话,就必须要自己实现

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

这两个默认成员函数一般不用重新定义 ,编译器默认会生成。

class Date
{ 
private :
 int _year ; 
 int _month ; 
 int _day ; 
public :
 Date* operator&()
 {
 return this ;
 }
 const Date* operator&()const
 {
 return this ;
 }

};

你可能感兴趣的:(C++初阶,c++,服务器,数据库)