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

最新推荐文章于 2024-07-25 21:43:46 发布

大炒面制作者BadCen

最新推荐文章于 2024-07-25 21:43:46 发布

阅读量112

点赞数 2

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

本文链接：https://blog.csdn.net/qq_68601751/article/details/129270774

版权

C++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、类的6个默认成员函数

在C++中，任何类中都有6个默认成员函数，如果程序员没有实现，编译器便会自动生成。即使是空类，也同样有这样的六个函数。

6个默认成员函数如下：

二、构造函数

1.概念

如下我们写一个日期类：

class Date
{
public:
 //初始化函数
 void Init(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 d1;
 //通过Init函数来实现初始化
 d1.Init(2022, 7, 5);
 d1.Print();
 Date d2;
 d2.Init(2022, 7, 6);
 d2.Print();
 return 0;
}

但是如果每个类的构造都要调用初始化函数，不免过于的繁琐，所以C++就引入了构造函数来实现类对象的初始化。

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

2.特性

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

特征：

函数名与类名相同。

无返回值。

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

构造函数可以重载。

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成
无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。

解释特性3：对象实例化时编译器自动调用对应的构造函数

可见在d1实例化完成之后，类中的成员变量已经完成初始化，因为在实例化的同时调用了构造函数。

解释特性4：构造函数支持重载

如下的两个Date构造函数构成函数重载

class Date
{
public:
    //无参的默认成员函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}

    //有三个参数的成员函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

初始化之后两个对象成员变量的值如下，很明显两个对象调用了不同的构造函数：

注意：没有参数时我在调用的时候不能加上括号（），切忌！！构造函数尤为特殊，报错如下：

构造函数建议写成全缺省的形式，这样他同样也是默认成员函数。代码如下：

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

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

看如下代码把构造函数屏蔽后，类的成员变量没有初始值，和上述的特性5不匹配，要知晓原因，要知道如下性质。

C++把变量分为两种类型：

内置类型/基本类型：int、char、double、指针……
自定义类型：class、struct去定义的类型对象

C++默认生成的构造函数对内置类型不做处理，对自定义类型才会进行处理，由于之前的年、月、日均为内置类型，所以虽然会自动生成构造函数但是不会对这些int这样的内置类型进行处理，这就是为什么得到的结果为随机值。

如果是自定义类型，自动生成的构造函数会自动去调用这个自定义类型的构造函数。下文进行代码讲解：

首先：定义一个名为A的类，它有成员变量_a,他的构造函数会把_a初始化为0。

class A
{
public:
	A()
	{
		cout << "A()" << endl;
		_a = 0;
	}
private:
	int _a;
};

然后：定义一个Date类，成员变量中包含了类A。Date类中没有A类的构造函数。

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

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	A _aa;
};
int main()
{
	Date d;
	d.Print();
}

运行结果：

由屏幕上的结果可知，Date的构造函数中虽然只初始化了内置类型，但是自定义类型的成员变量调用了它的析构函数A()从而完成了初始化_aa的值为0。所以，构造函数实现完成的类，在其他类中被使用时，编译器会自动调用他的构造函数，无需自己重新实现构造函数。

总结：

如果一个类中的成员全是自定义类型，我们就可以用默认生成的函数。
如果有内置类型的成员，或者需要显示传参初始化，那么都要自己实现构造函数。

由于后期的程序员认为C++中对内置类型不做处理不合理，所以在C++11中打了补丁：给缺省值

没有实现构造函数，但是内置类型完成了初始化。

三、析构函数

1.概念

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

2.特性

特征：

析构函数名是在类名前加上字符 ~
无参数无返回值类型

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

对象生命周期结束时，C++编译系统系统自动调用析构函数
编译器生成的默认析构函数，对自定类型成员调用它的析构函数

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

像Date这样的日期类，并不需要使用析构函数，因为成员变量只有内置变量int类型year、month、date，无需清理对象资源，程序会自动完成类的销毁。但是像Stack一样的类，由于用到了malloc函数在堆上申请了空间，所以一定要清理对象资源。

总结：只有用到了malloc、new、fopen这些函数时才需要自己写析构函数

看如下代码，问类的析构顺序：

int main()
{
	Stack st1;
	Stack st2;
}

这里涉及到了一个知识点，由于类定义栈上，所以遵循后进先出原则，由于st1比st2优先构造，所以st2比st1优先析构。

四、拷贝构造

1.概念

通过已有的类对象来初始化另一个对象就是拷贝构造。

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

如下就是拷贝构造函数：

Date(Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

如下就是拷贝构造的实用场景：

int main()
{
	Date d1(2022, 5, 18);
	Date d2(d1); //拷贝构造
	return 0;
}

2.特性

特性：

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

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

若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象 按内存存储按字节序完成拷贝 ，这种拷贝叫做浅拷贝，或者值拷贝。

解释特性2：拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

要像弄明白为什么要使用拷贝构造，知道一个知识点，在一个类对象赋值或者传递给另一个类对象是，编译器会自动默认的去调用他的拷贝构造。

假如拷贝构造传值而不是传引用是如下代码：

//传值
Date(Date d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

在拷贝拷贝构造被使用时首先要把类的值传给形参d，传值就要调用拷贝构造，调用拷贝构造又要传值,如此循环，就造成了死递归。如下图：

为了避免出现无限递归调用拷贝构造，所以要加上引用，加上引用后，d就是d1的别名，不存在拷贝构造了。同类型的传值传参是要调用拷贝构造的。正确代码如下：

Date(const Date& d) {} 
//最好加上const，对d形成保护

解释特性3：若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

如下代码没有定义拷贝构造函数，但是实现了拷贝构造的功能。这就是因为编译器自动实现了拷贝构造，把d1对象的值浅拷贝给了d2。

但是需要注意的是，编译器自主实现的拷贝构造只能完成浅拷贝，无法完成深拷贝。可见，内置类型的拷贝构造可以通过编译器自动生成的拷贝构造函数实现，但是如果换成成员变量是自定义类型呢？

class Stack
{
public:
	//构造函数
	Stack(int capacity = 10)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		assert(_a);
		_top = 0;
		_capacity = capacity;
	}
//不写拷贝构造，编译器调用默认拷贝构造
	/*
	Stack(const Stack& st)
	{
		_a = st._a;
		_top = st._top;
		_capacity = st._capacity;
	}
	*/
	//析构函数
	~Stack()
	{
		cout << "~Stack():" << this << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st1(10);
	Stack st2(st1);
}

在调试是，这段代码会发生如下报错：

其原因就是编译器默认生成的拷贝构造函数对st2完成了st1的浅拷贝，导致两者的地址是完全相同的，由编译器调试可见下图：

内存结构如下图，st1和st2的两个指针指向同个地址：

这是两个对象分别调用析构函数，把一个地址释放了两次，自然会发生报错，所以，我们遇到自定义类型时要自己完成拷贝构造函数，给它开辟新的空间，在把数据搬运到这个空间中，实现深拷贝。

总结：一般的类，自己生成拷贝构造就够用了，只有像Stack这样自己直接管理资源的类，需要自己实现深拷贝。

注：如下代码是拷贝构造而不是赋值

void TestDate2()
{
	Date d1(2022, 5, 18);
	Date d3 = d1; //等价于 Date d3(d1);
}

五、赋值运算符重载

1.运算符重载

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

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

函数返回值：运算符运算后结果
函数原型：返回值类型 operator操作符(参数列表)

我们写一段写在类外的“==”的运算符重载的代码：

bool operator==(const Date& d1, const Date& d2) //避免传值传参调用拷贝构造
{
    return d1._year == d2._year &&
        d1._month == d2._month &&
        d1._day == d2._day;
}

运行结果如下：

可见，通过运算符重载实现了“==”，但是在类外实现无法访问类内的private成员变量，所以我们需要屏蔽private，让他成为public。但是这样操作严重破坏了类的封装性，所以我们一般把运算符重载放在类内。

由于成员函数在传参是有一个隐藏指针this，这个this指针就是传的操作符用到的第一个操作数，所以和定义在类外相比，要减少一个参数。代码如下：

bool operator==(const Date& d)//编译器会处理成 bool operator(Date* const this, const Date& d)
{
	return _year == d._year &&
		_month == d._month &&
		_day == d._day;
}

显示调用如下：

d1.operator==(d2)

但一般直接写成这样：

d1==d2

运算符重载注意点：

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

重载操作符必须有一个类类型参

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

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

.* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

2.赋值运算符重载

有了运算符重载的知识，我们能很轻松的写出赋值运算符重载的函数：

//d2 = d1;  -> d2.operator=(&d2, d1);
void operator=(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

但是需要注意的是，赋值符号可以连续赋值，为了实现类似的效果，我们要加上返回值this*。代码如下：

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

此外，这个函数还可以进行如下两点的修改：

刚才我们写的赋值重载是传值返回，传值返回会生成一个拷贝，会调用拷贝构造。由于出了作用域对象还存在，所以我们就可以用传引用返回
有可能会存在这样的情况：d1=d1，像这样自己给自己赋值的情况还要再调用赋值重载函数属实没必要，所以我们还可以加个if条件判断。

	//d2 = d1;  -> d2.operator=(&d2, d1);
	Date& operator=(const Date& d)
	{
		if (this != &d) //不推荐写成if (*this != d) ，怕的是万一没有重载!=呢？，因为这里是对象的比较
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}

赋值运算符重载注意：就算程序员不实现赋值运算符重载，编译器也会自动生成，但是要拷贝构造相同，只能完成浅拷贝，涉及深拷贝要自行实现。

七、const成员

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

如下代码存在报错：

其原因是代码在Func中的形参由于被const所修饰，所以this指针的类型变为了const *A，所以，权限被缩小了，而调用类中print函数时会传递this指针,类中的this指针的类型为*A,这就形成了典型的权限放大问题。

我们通过上文的const来修饰成员函数就能解决这个问题。正确代码如下：

class A
{
public:
	// const 修饰 *this
    // this的类型变成 const A*
    // 内部不改变成员变量的成员函数
    // 最好加上const，const对象和普通对象都可以调用
	void Print() const
	{
		cout << _a << endl;
	}

	void Add(int x)
	{
		_a += x;
	}

private:
	int _a = 10;
};

void Func(const A& x)
{
	x.Print();

	cout << &x << endl;
}

int main()
{
	A aa;
	aa.Print();

	Func(aa);

	return 0;
}