类和对象（二）-CSDN博客

本文链接：https://blog.csdn.net/m0_75103228/article/details/140731320

类中的默认构造函数

如果一个类中什么成员都没有，简称为空类，空类并不是什么都没有，编译器会默认生成6个函数，如果用户显式实现，则编译器会使用用户的函数

初始化和清理

构造函数主要完成初始化工作（Init）
析构函数主要完成清理工作（Destory）

拷贝复制

拷贝构造使用同类对象初始化创建对象
赋值重载主要把一个对象赋值给另一个对象

取地址重载

主要是普通对象和const对象取地址，这两个很少自己实现

构造函数

概念

构造函数是一个特殊的成员函数，名字与类名相同，在对象整个生命周期只调用一次

class Date
{
public:
	// 之前版本的初始化函数
	void Init(int year = 1970, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
    }

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

int main()
{
    Date d1;
    d1.Init(2024, 7, 21); // 这种初始化方式太麻烦，我们希望在创建对象时就初始化
 	   
    return 0;
}

class Date
{
public:
	// 构造函数
	Date(int year = 1970, int month = 1, int day = 1)
	{
	 	_year = year;
		_month = month;
		_day = day;
	}

    void Print()
    {
        std::cout << _year << "/" << _month << "/" << _day << endl;
	}
    
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    // 默认值
    Date d1;
    d1.Print(); // 1970/1/1
    
    Date d2;
    d2.Print(2024, 7, 21); // 2024/7/21
     
    return 0;
}

特点

函数名与类名相同
不用写而且也没有返回值(void)
对象实例化时自动调用
构造函数可以重载

如果通过无参数构造函数时创建对象时，对象后面不用写括号，否则就会成为函数声明

class Date
{
public:
	// 带参数构造函数
	Date(int year, int month, int day)
	{
	 	_year = year;
		_month = month;
		_day = day;
	}
    
    // 无参数构造函数
    Date()
    {
        
	}
    
private:
	int _year;
	int _month;
	int _day;
}

int main()
{
    Date d1; // 调用无参构造函数，不用带括号，否则就成为了一个函数声明
    Date d2(2015, 1, 1); // 调用带参的构造函数
    
    // 以下代码是一个函数声明,该函数无参，返回一个日期类
    Date d3();
    
    return 0;
}

class Date
{
public:
	void Print()
	{
		std::cout << _year << "-" << _month << "-" << _day << std::endl;
	}

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

int main()
{
	Date d;
	d.Print();

	return 0;
}

在这里插入图片描述

运行上述程序，可以看出，我们不写构造函数，编译器自动生成的默认构造函数似乎没用，初始化的值是随机值，似乎没用???c++把类型分为内置类型（int或char或float或指针类型等）和自定义类型(使用class或struct等自己定义的类型)，当我们在类中使用其他自定义类型时，我们就不用再写构造函数，编译器默认生成的构造函数就会调用该自定义类型的构造函数初始化

class Stack
{
public:
	Stack(int capacity = 10)
	{
		// ...
	}

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

class MyQueue
{
	// 当实例化对象时，编译器会调用Stack的默认构造函数，不用自己实现
private:
	Stack _stack1;
	Stack _stack2;
};

编译器默认生成的构造函数方便性就体现在这里

在c++11之前，内置类型不能初始化，在之后，内置成员变量在类中声明可以给默认值（缺省值）

无参构造函数、全缺省默认构造函数、编译器默认生成的构造函数（当我们没写构造函数时，编译器会自动生成），都可以认为是默认构造函数

初始化列表

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值，构造函数体中的语句只能称为赋值，为不能称作初始化，因为初始化只能初始化一次，而构造函数体内可以多次赋值

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个“成员变量”构面跟一个放在括号中的初始值或表达式

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{} // 注意这里还有大括号
private:
	int _year;
	int _month;
	int _day;
};

注意：

每个成员变量在初始化列表中只能出现一次（因为初始化只能出现一次）
类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量
const成员变量
自定义成员（且该类没有默认构造函数）

class A
{
public:
	A(int a)
		: _a(a)
	{}
private:
	int _a;
};

class B
{
public:
	B(int a, int ref)
		: _aobj(a)
		, _ref(ref)
		, _n(10)
	{}
private:
	A _aobj;      // 没有默认构造函数 
	int& _ref;    // 引用
	const int _n; // const
};

尽量使用初始化列表初始化，因为不论是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化

成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

析构函数

概念

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

特点

析构函数名前加字符~
无参数无返回值类型
一个类只能有一个析构函数，若未显式定义，系统会自动生成默认析构函数
对象生命周期结束时，C++编译器自动调用析构函数

class Stack
{
public:
	// 构造函数
	Stack(size_t capacity = 3)
	{
		// ...
	}

	void Push(int data)
	{
		// ...
	}

	// ...

	// 析构函数
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}

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

与构造函数类似，内置类型成员销毁时不需要资源清理，最后系统直接将其内存回收即可，而对于自定义类型，编译器会自动调用对应的析构函数。所以如果类中没有申请资源时，析构函数可以不写，直接使用编译器默认析构函数，如果有资源申请时（例如Stack类），一定要写析构函数

拷贝构造函数

概念

只有单个形参，该形参是对本类类型对象的引用（一般用**const修饰**），再用已存在的类类型对象创建新对象时由编译器自动调用

特点

是构造函数的一个重载形式
参数只有一个且必须是该类类型对象的引用，使用传值方式编译器会报错，因为会引发无穷递归调用
若未显示定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储的字节序完成拷贝，这种方式叫作浅拷贝

class Date
{
public:
	Date(int year = 1970, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//Date(const Date d) // 错误写法，会引发无穷递归
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

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

对于不涉及资源申请时，拷贝构造函数写不写都可以，一旦涉及到自愿申请时，拷贝构造函数一定要写，否则就是浅拷贝

class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}

		_size = 0;
		_capacity = capacity;
	}

	void Push()
	{
		// ...
	}

	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = _size = 0;
		}
	}

private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};

对于日期类型，不需要写拷贝构造，编译器默认生成的已经够用，但是对于栈类，如果不写拷贝构造，假设执行以下程序：

int main()
{
    Stack s1;
    s1.Push(1);
    
    Stack s2(s1); // 用s1拷贝给s2
}

编译器生成的默认拷贝构造是按值拷贝的，即将s1的内容原封不动的拷贝到s2，因此s1和s2指向了同一块空间，当程序退出时，s2和s1都要销毁，s2先销毁，但是s1再销毁时，_array指向的空间已经被销毁，就会造成程序崩溃，所以涉及资源申请时，需要写拷贝构造函数

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

使用已存在的对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象

赋值运算符重载

运算符重载

c++为了增强代码可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名称和参数列表，其返回值类型与参数列表和普通函数类似

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

注意:

不能通过连接其他符号来创建新的操作符：比如operator@，仅可以使用已有实际含义的操作符
重载操作符必须有一个类类型对象
用于内置类型的操作符，其含义不能改变，例如用于内置类型的整形+，不能改变其含义
作为类成员函数重载时，其形参比操作数数目少1，因为成员函数第一个参数为隐藏的this

class Date
{
public:
	Date(int year = 1970, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	bool operator==(const Date& d)
	{
		return d._year == _year && d._month == _month && d._day == _day;
	}

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

int main()
{
	Date d1(2024, 7, 26);
	Date d2(2024, 7, 26);
	cout << (d1 == d2) << endl;

	return 0;
}

上面程序将==重载，使其不仅可以用于内置类型，也可以用于Date类

格式

参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值是为了支持连续赋值

对于上述Date类

Date& operator=(const Date& d)
{
	if (this != &d) // 判断是否给自己赋值
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	return *this;
}

特点

赋值运算符只能重载成类的成员函数不能重载成全局函数，只能被定义为成员函数
用户没有显示定义时，编译器会生成一个默认的赋值运算符重载，以值的方式逐字节拷贝

与拷贝构造类似，当未涉及到资源申请时，赋值运算符写不写都可以，一旦涉及到资源申请时则必须要实现复制重载

与拷贝构造的区别

拷贝构造：

Date d1(2024, 7, 26);
Date d2 = d1; // 拷贝构造

赋值重载：

Date d1(2024, 7, 26);
Date d2;
d2 = d1; // 赋值重载

前置++和后置++的重载

class Date
{
public:
	Date(int year = 1970, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	int GetMonthDay(int year, int month) const
	{
		const static int monthArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

		if (month == 2
			&& ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
		{
			return 29;
		}

		return monthArray[month];
	}

	// 前置++，返回+1后的结果
	Date& operator++()
	{
		_day += 1;
		while (_day > GetMonthDay(_year, _month))
		{
			_day -= GetMonthDay(_year, _month);
			++_month;

			if (_month == 13)
			{
				++_year;
				_month = 1;
			}
		}
		
		return *this;
	}
	// 后置++
    Date operator++(int)
    {
        Date tmp(*this);

        _day += 1;
        while (_day > GetMonthDay(_year, _month))
        {
            _day -= GetMonthDay(_year, _month);
            ++_month;

            if (_month == 13)
            {
                ++_year;
                _month = 1;
            }
        }

        return tmp;
    }

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

前置++和后置++都是一元运算符，需要重载时好像无法区分

c++规定：后置++重载时增加一个int类型的参数，但调用参数时该参数不会传递，编译器会自动传递

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

这两个默认成员函数一般不用重定义，编译器默认生成的就可以

Date operator++(int)
    {
        Date tmp(*this);

        _day += 1;
        while (_day > GetMonthDay(_year, _month))
        {
            _day -= GetMonthDay(_year, _month);
            ++_month;

            if (_month == 13)
            {
                ++_year;
                _month = 1;
            }
        }

        return tmp;
    }

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

前置++和后置++都是一元运算符，需要重载时好像无法区分

c++规定：后置++重载时增加一个int类型的参数，但调用参数时该参数不会传递，编译器会自动传递