【C++】类和对象（中）

最新推荐文章于 2024-09-16 17:46:36 发布

码者阿铭

最新推荐文章于 2024-09-16 17:46:36 发布

阅读量102

点赞数 1

分类专栏： C++初阶文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/fbzhl/article/details/132197696

版权

C++初阶专栏收录该内容

6 篇文章 0 订阅

订阅专栏

往期回顾：

1 类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。在上一篇文章中我们已经说明过空类会占据1个字节的空间。

空类中并不是什么都没有。任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

2 构造函数

2.1 概念

我们回想以下在C语言学习阶段，当我们写一个数据结构时，总是会写一个初始化函数来对一些初始参数进行设置。但如果每次创建一个新对象，都要我们主动去掉用一次初始化函数；或者偶尔我们忘记写初始化函数，就会造成一些问题。C++祖师爷就考虑到了这点问题：能否在对象创时，就将信息设置进去呢？于是构造函数就诞生了。

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

2.2 特性

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

构造函数有如下特性：

1. 函数名与类名相同。

2. 无返回值。

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

4. 构造函数可以重载。

class Date
{
public:
    // 1.无参构造函数
    Date()
    {}
    // 2.带参构造函数
    Date(int year, int month, int day)
    {
    _year = year;
    _month = month;
    _day = day;
        }
private:
    int _year;
    int _month;
    int _day;
};
void TestDate()
{
    Date d1; // 调用无参构造函数
    Date d2(2015, 1, 1); // 调用带参的构造函数
    // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
    // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
    Date d3();
}

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

class Date
{
public:
    /*
    // 如果用户显式定义了构造函数，编译器将不再生成
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    */
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    // 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
    // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
    // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
    Date d1;
    return 0;
}

6. 关于编译器生成的默认成员函数，C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型。编译器自动生成的构造函数对于内置类型不会处理，只会处理自定义类型。

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

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

总结一下：

构造函数，也是默认成员函数，我们不写，编译器会自动生成

编译生成的默认构造函数的特点：

1、我们不写才会生成，我们写了任意一个构造函数就不会生成了

2、内置类型的成员不会处理（C++11，声明支持给缺省值）

3、自定义类型的成员才会处理，回去调用这个成员的默认构造函数

总结：一般情况都需要我们自己写构造函数，决定初始化方式；当成员变量全是自定义类型时，可以考虑不写构造函数（编译器会自动调用自定义类型的构造函数）

3 析构函数

3.1 概念

析构函数是一种与构造函数功能相反的函数。我们都知道，一个程序结束之后会对创建的对象等进行销毁。执行销毁过程是由编译器来完成的，对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

3.2 特性

析构函数的特性如下：

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

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

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载

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

5.关于编译器自动生成的析构函数，对于内置类型不会处理，最后系统直接将其内存回收即可；对于自定义类型，编译器生成的析构函数会去调用自定义类型的析构函数。

对于两个对象，假如对象2是对象1中的一个成员变量，在销毁对象1时，需要对对象2进行资源回收。因为main函数中不能直接调用对象2的析构函数，所以编译器为对象1自动生成的析构函数的作用就是调用对象2的析构函数，通过调用对象1的析构函数间接回收对象2的空间资源。

即：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

6. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数；有资源申请时，一定要写，否则会造成内存泄漏。

4 拷贝构造函数

4.1 概念

4.1.1 深拷贝与浅拷贝

拷贝这个概念我们都很熟悉，并且实际操作中会经常用到拷贝操作。而根据用途的不同，拷贝分为深拷贝和浅拷贝两种。

浅拷贝（也呈值拷贝）：指按位拷贝对象，它会创建一个新对象，对象按内存存储按字节序完成拷贝。

深拷贝：指创建一个与原对象的数据一模一样的全新的对象，新旧对象代表不同的内存空间，是相互独立的。

当我们把一个对象赋值给一个新的变量时，赋的其实是该对象的在栈中的地址，而不是堆中的数据。发生的其实是浅拷贝。

假如我们直接用赋值操作符进行拷贝，实际进行的就是浅拷贝。不过，当对象中有指针成员负责维护动态申请的空间时就会出现问题。这是因为在程序结束时，两个对象都会调用析构函数。而两个对象的指针成员所指内存相同，相当于同一块内存空间有两个名字。析构一次以后该空间已经被释放掉，而还未被析构的对象中的指针就变成了野指针，此时再次析构释放这块空间就会导致程序崩溃。

所以当对象涉及资源申请时，一般需要使用深拷贝。

4.1.2 拷贝构造函数

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

4.2 特性

拷贝构造函数有如下特性：

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

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

假如拷贝构造函数的参数是类类型成员，相当于传值调用，要将实参拷贝一份给形参，于是编译器会对形参和实参继续调用拷贝构造函数，会产生一个新的形参，要将实参拷贝一份给新的形参，再次调用拷贝构造函数......如此往复形成无穷递归。

3. 若未显式定义，编译器会生成默认的拷贝构造函数。默认拷贝构造函数进行的是浅拷贝。

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
义类型是调用其拷贝构造函数完成拷贝的。

4.当类中涉及资源申请时，需要自己写实现深拷贝的拷贝构造函数，否则就是浅拷贝，调用析构函数时程序会崩溃。

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

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

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

5 赋值运算符重载

5.1 运算符重载

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

函数的名字为：关键字operator后接需要重载的运算符符号。

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

使用运算符重载有如下注意：

不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其加法的含义
不能改变操作符的操作数个数。原来的操作符是几个操作数，重载的时候就必须有几个参数
作为类成员函数重载时，其形参看起来比操作数数目少1，这是因为成员函数的第一个参数为隐藏的this
:: sizeof . .* ?: 左边五个运算符不能被重载，这在笔试中经常出现

5.2 赋值运算符重载

1. 赋值运算符重载格式

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

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值检测是否自己给自己赋值

返回*this ：要符合连续赋值的含义

以日期类为例：
Date& operator=(const Date& d)
{
	if (this != &d)
	{
		_year = d._year;
		_day = d._day;
		_month = d._month;
	}
	return *this;
}
注：左操作数是隐含的this指针，指向调用函数的对象

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

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

3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝（浅拷贝）。

注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

4.如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现，此道理同拷贝构造函数类似，都是为了防止二次析构的问题。

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

运算符重载的格式是关键字operator后接需要重载的运算符符号，那对于前置++和后置++，如果都用operator++这样的格式就会产生歧义。

为了让前置++与后置++形成能正确重载，C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递

以日期类为例：

//前置++
Date& operator++()
{
	*this += 1;
	return *this;
}

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

注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1

而temp是临时对象，因此只能以值的方式返回，不能返回引用。（能不能使用引用返回就看出了作用域返回对象有没有被销毁，没有被销毁就可以用引用返回提升效率）

6 日期类的实现

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

	//拷贝构造函数
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	//析构函数
	~Date()
	{
		_year = _month = _day = 0;
	}
	void Print() const
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

	//获取月份天数
	int GetMonthDay(int year, int month)
	{
		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];
	}

	//+=运算符重载
	//出作用域this还在，传引用返回
	Date& operator+=(int day)
	{
		_day += day;
		while (_day > GetMonthDay(_year, _month))
		{
			_day -= GetMonthDay(_year, _month);
			_month++;

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

	//+运算符重载
	//出作用域tmp销毁，传值返回
	Date operator+(int day)
	{
		Date tmp(*this);
		//date tmp=*this    两种方式等价
		tmp += day;
		return tmp;
	}

	//-=运算符重载
	Date& operator-=(int day)
	{
		_day -= day;
		while (_day <= 0)
		{
			_month--;
			if (_month == 0)
			{
				_year--;
				_month = 12;
			}
			_day += GetMonthDay(_year,_month);
		}
		return *this;
	}

	//前置++
	Date& operator++()
	{
		*this += 1;
		return *this;
	}

	//后置++
	Date operator++(int)
	{
		Date tmp(*this);
		*this += 1;
		return tmp;
	}
	
	//-运算符重载（减去天数）
	Date operator-(int day)
	{
		Date tmp = *this;
		tmp -= day;
		return tmp;
	}

	//-运算符重载（日期相减）
	int 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 (min != max)
		{
			++min;
			++n;
		}
		return n * flag;
	}
	// >运算符重载
	bool operator>(const Date& d)
	{
		return !(*this <= d);
	}

	// ==运算符重载
	bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}

	// >=运算符重载
	bool operator >= (const Date& d)
	{
		return !(*this < d);
	}

	// <运算符重载
	bool operator < (const Date& d)
	{
		if (_year < d._year)
		{
			return true;
		}
		else if (_year == d._year && _month < d._month)
		{
			return true;
		}
		else if (_year == d._year && _month == d._month && _day < d._day)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	// <=运算符重载
	bool operator <= (const Date& d)
	{
		return (*this < d) || (*this == d);
	}

	// !=运算符重载
	bool operator != (const Date& d)
	{
		return !(*this == d);
	}

	//赋值运算符重载
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_day = d._day;
			_month = d._month;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

7 const成员函数

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

我们来看如下例子：

class Date
{
public:
    void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
    ......
}
void test()
{
    const Date d1;
    d1.Print();
}
对于以上程序，编译器会报错，这是因为Print函数隐含的this指针是Date*类型的，而d1的类型是const Date类型，这里直接调用Print函数会造成权限的放大

(权限可以缩小，可以平移，不能放大）

解决办法就是，将Print直接重载成const成员函数，方式是直接在Print()之后加上const。

class Date
{
public:
    void Print() const
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
    ......
}
void test()
{
    const Date d1;
    d1.Print();
}

其实，编译器对如上代码，会将const处理为函数参数的修饰：

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

这两个是对&运算符的重载。因为运算符本身是不支持自定义类型的，如果想对自定义类型取地址，虽然直接用&也可以取到对象的地址，但是底层的逻辑其实也是运算符重载。

（注：&作为运算符的意义是取地址符号，而不是引用，引用不是运算符）

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

这里的两个版本分别是为是否为const对象准备的，构成函数重载。具体执行时根据类型调用不同的函数。

实际使用中，这两个函数一般是不需要显式定义的，库里面已经提供好了两个版本，需要使用时编译器会默认生成。所以比起其余四个默认成员函数，这两个函数并不是特别重要，稍作了解即可。