类和对象(中)

类和对象(中)

默认成员函数

当一个类中什么都没有，我们称这个类为空类。

但是这个类中声明都没有吗？

当然不是的，这里还有自动生成的6个默认成员函数。

class Date{}

我们没有手动实现，编译器会帮我们自动生成，但是没有显示定义。

一、构造函数

我们在实现一个栈时，我们需要自己实现一个初始化的Init函数。

并且每次创建一个栈都要手动调用初始化。而我们常常会忘记初始化并且手动调用很麻烦，于是C++就写出一个构造函数来解决这个麻烦的问题。

void StackInit()
{
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}

1.概念

构造函数:是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，

保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

2.特性

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

1. 函数名和类名相同
2. 无返回值
3. 构造函数可以重载
4. 对象实例化的时候，编译器会自动调用对应的构造函数
5. 如果你自己不写构造函数，编译器会自己创建一个默认的构造函数

3.构造函数的使用

#include<iostream>
class Date
{
public:
	Date()                              //无参构造函数
	{

	}
	Date(int year, int month, int day) //带参构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		std::cout << _year << "/" << _month << "/" << _day << std::endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;               //调用无参构造函数
	d1.Print();
	Date d2(2021, 5, 30);  //调用带参构造函数
	d2.Print();
	Date d3();            //此时并没有调用构造函数，对象并没有实例化出来，不知道是函数的声明,还是构造函数。
	return 0;
}

如果我们没有手动写出构造函数，编译器也会自动实现。编译也可以通过。

class Date
{
public:
	/*
	// 如果用户显式定义了构造函数，编译器将不再生成
	Date (int year, int month, int day)
	{
	_year = year;
	_month = month;
	_day = day;
	}
	*/
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	// 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
	Date d;
}

注意：无参构造函数、全缺省构造函数,我们没写编译器默认生成的构造函数，都可以认为是默认成员函数，所以下面代码编译不成功。

#define _CRT_SECURE_NO_WARNINGS   1
#include<iostream>
class Date
{
public:
	Date()                                             //1.无参构造函数
	{
		_year = 1000;
		_month = 1;
		_day = 1;
	}
	Date(int year = 1000, int month = 1, int day = 1)  //2.全缺省构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1; //对象实例化时自动调用构造函数，所以这里不能调用两个构造函数。
	return 0;
}

4.默认生成的构造函数

上面提到过，如果我们不写构造函数，编译器会自己生成一个。

但测试过以后，你会发现，这个默认生成的构造函数，好像啥事都没有干，而且把year/month/day初始化成了随机值。

class Date
{
public:
	void Print()
			{
				std::cout << _year << "/" << _month << "/" << _day << std::endl;
			}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1; 
	d1.Print();
	return 0;
}

实际上，编译器默认生成的构造函数是不会处理内置类型的。

• 内置类型：int、char、float、double……
• 自定义类型：我们使用自己定义的类型。

在处理的时候，编译器忽略内置类型；自定义类型会调用它的构造函数。

---

一般情况下一个C++类都需要自己写构造函数，下面这两个情况除外：

1. 类里面的成员都是自定义类型成员（且有自己的构造函数）
2. 如果还有内置类型成员，声明时给了缺省值

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

class Date
{
public:
	void Print()
			{
				std::cout << _year << "/" << _month << "/" << _day << std::endl;
			}
private:
	int _year = 2022;
	int _month = 10;
	int _day = 11;
	Date2 hour;
};

二、析构函数

我们写链表时，有时会忘记销毁链表从而导致内存泄漏，于是C++也有了析构函数。

1.概念

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

2.特性

• 析构函数名是在类名前加~
• 无参数，无返回值
• 一个类只能有一个析构函数
• 如果你没有自己写，编译器会自动生成一个析构函数
• 先构造的后析构，后构造的先析构

和构造函数一样，编译器自己生成的析构函数不会处理内置类型；会调用自定义类型的析构函数。

3.析构函数的使用

class Stack
{
public:
     Stack(size_t capacity = 3)
     {
     _array = (DataType*)malloc(sizeof(DataType) * capacity);
 if (NULL == _array)
 {
     perror("malloc fail");
     return;
 }
     _capacity = capacity;
     _size = 0;
 }
 void Push(DataType data)
 {
 // CheckCapacity();
     _array[_size] = data;
     _size++;
 }
 // 其他方法...
 ~Stack()
 {
     if (_array)
     {
         free(_array);
         _array = NULL;
         _capacity = 0;
         _size = 0;
     }
  }
private:
 DataType* _array;
 int _capacity;
 int _size;
};
void TestStack()
{
     Stack s;
     s.Push(1);
     s.Push(2);
}
void TestStack()
{
    Stack s1;
    s1.Push(1);
    s1.Push(2);
    Stack s2;
    s2.Push(10);
    s2.Push(20);
    s2.Push(30);
}

同时，我们也验证一下5.先构造后析构。

因为在底层操作中，编译器会给main函数开辟栈帧

栈遵从后进先出的原则，s2是后创建的，所以在析构的时候会先析构。

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

三、拷贝构造

1.概念

在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。

那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

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

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

2.使用

class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 18)  //构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		std::cout << _year << "/" << _month << "/" << _day << std::endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	Date d2(d1);  //把d1拷贝给d2
	d2.Print();
}

3.特性

因为拷贝的时候我们不会修改d的内容，所以传的是const

另外，我们必须进行传引用调用！

因为我们在使用如下代码时：

void func(Date d)

编译器会就递归不断创建新的对象进行值拷贝构造，程序就会死循环。

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

• 对外置类型会调用它的构造函数

4.拷贝问题

浅拷贝

像日期类这样的类，我们不用写拷贝构造，默认的已经够用了。但是如果我们使用了自定义类型并且使用了malloc时，默认的拷贝构造就不够用了。

class Stack
{
public:
     Stack(size_t capacity = 3)
     {
     _array = (DataType*)malloc(sizeof(DataType) * capacity);
 if (NULL == _array)
 {
     perror("malloc fail");
     return;
 }
     _capacity = capacity;
     _size = 0;
 }
 void Push(DataType data)
 {
 // CheckCapacity();
     _array[_size] = data;
     _size++;
 }
 // 其他方法...
 ~Stack()
 {
     if (_array)
     {
         free(_array);
         _array = NULL;
         _capacity = 0;
         _size = 0;
     }
  }
private:
 DataType* _array;
 int _capacity;
 int _size;
};
void TestStack()
{
     Stack s;
     s.Push(1);
     s.Push(2);
}
void TestStack()
{
    Stack s1(10);
    s1.Push(1);
    s1.Push(2);
    Stack s2(s1);  
}

原因是什么呢？

原因是编译器默认生成的拷贝构造会进行值拷贝，拷贝完了之后，就会出现s1和s2指向同一个空间的情况。修改s2会影响s1，free的时候多次释放同一个空间会报错，不符合我们的拷贝构造的要求。

malloc不行的原因是，数据是存在堆区里面，拷贝的时候，s2的得到的是一个地址，而不是拷贝了新的数据内容。

深拷贝

如果默认的不行，我们直接手动实现。由于需要空间，我们就直接malloc一个和s1一样大的空间再用memcpy一个字节一个字节拷贝进去，这样我们就完成了深拷贝。

#include <stdio.h>
#include <iostream>
using namespace std;
typedef int DataType;
class Stack
{
public:
    Stack(size_t capacity = 3)
    {
        _array = (DataType*)malloc(sizeof(DataType) * capacity);
        if (NULL == _array)
        {
            perror("malloc fail");
            return;
        }
        _capacity = capacity;
        _size = 0;
    }
    void Push(DataType data)
    {
        // CheckCapacity();
        _array[_size] = data;
        _size++;
    }
    // 其他方法...
    Stack(const Stack& st)
    {
        cout << "Stack(const Stack& st)" << endl;
        
        _array = (DataType*)malloc(sizeof(DataType)*st._capacity);
        if (_array == nullptr)
        {
        	perror("malloc fail");
        	exit(-1);
        }
        memcpy(_array, st._array, sizeof(int)*st._capacity);
        _size = st._size;
        _capacity = st._capacity;
    }
    ~Stack()
    {
        if (_array)
        {
            free(_array);
            _array = NULL;
            _capacity = 0;
            _size = 0;
        }
    }
private:
    DataType* _array;
    int _capacity;
    int _size;
};
void TestStack()
{
    Stack s1(10);
    s1.Push(1);
    Stack s2(s1);
}
int main()
{
    TestStack();
    return 0;
}

四、运算符重载

1.定义

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

函数名为：关键字+运算符

如：

Date operator=();

2.特性

1. 不能通过连接其他符号来创建新的操作符：比如operator@
2. 重载操作符必须有一个自定义类型的操作数，操作符重载对内置类型无效
3. 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义。
4. 对于类类型的操作符重载，形参比操作数少一个传参（因为有一个默认的形参this指针）
5. 有五个无法重载的操作符：.*,::,sizeof,?:,.

3.使用

编译器眼中是这样的：

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

我们更习惯于这样，使用this指针

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

而在main里面使用的时候，这个重载后的操作符和原本的使用方法完全相同。

---

4.注意事项

1. 返回值和参数类型（注意要引用传参，不然会调用拷贝构造）
2. 检测是否自己给自己赋值
3. 返回*this
4. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

注：如果类中有自定义类型，编译器会默认调用它的赋值运算符重载。

当赋值操作符和拷贝构造同时存在的时候，什么时候会调用赋值，什么时候会调用拷贝构造呢？

• 如果对象在之前已经存在，就会调用赋值重载

• 如果是一个全新的变量在定义的时候初始化，就调用的是拷贝构造