当前位置：首页 > news >正文

C++类的六个默认函数

news 来源：原创 2024/9/20 7:13:09

类的六个默认函数

如果一个类中什么成员都没有，这个类就叫做空类

但是类中什么都没有吗？答案是否定的，类中什么都没有的时候，编译器会默认生成六个默认成员函数

默认成员函数：用户没有显示实现（用户没有写），编译器会自动实现的函数

构造函数

构造函数虽然里面有一个构造的词语，但是和构造没有任何关系，它的作用是对数据成员进行初始化

构造函数的引入

下面有一段代码

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 date1;date1.init(2024, 8, 15);date1.print();return 0;
}

上面的代码定义的一个日期类，下面对代码进行两点说明：

1.为什么我们定义变量的时候要在前面加一个" _",比如，_year,_month,_day

答：就用上面的代码来解释，比如上面的初始化函数，里面的形参数是year,month,day,如果你成员变量也写成year，month，day的话，形参写成别的单词你又不好辨别

2.关于构造函数的引入

有的时候我们会忘记对类进行初始化，比如我们学的数据结构中的栈和队列，如果忘记初始化了，你在去插入一个值，程序就会崩溃，这时候就显示出构造函数的作用了，会帮你自动初始化成员变量

构造函数的特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任
务并不是开空间创建对象，而是初始化对象。
其特征如下：
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

class Date
{public:Date()                     //这是一个构造函数{_year = 1;_month = 1;_day = 1;}void print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year;int _month;int _day;
};int main()
{Date date1;date1.print();return 0;
}

运行结果：

从上面的代码运行结果来看，当对类进行实例化的时候，会自动调用构造函数来对数据成员进行初始化

class Date
{public:Date()                     //这是一个构造函数(无参构造函数){_year = 1;_month = 1;_day = 1;}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 date1;date1.print();Date date2(2024, 8, 15);        //有参构造函数的，在实例化的时候在后面加上要初始化的值            //即可，调用无参构造函数的话，什么也不用写，正常实例话 //对象就行date2.print();return 0;
}

运行结果：

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 date1;date1.print();return 0;
}

你如果把上面你写的构造函数的代码注释掉，程序是会正常运行的，但是如果你不注释掉，程序会报错，因为你写了构造函数，编译器不会生成无参构造函数，你调用的方式又不是有参函数的调用的方式

6. 关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会
生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默
认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的
默认构造函数并没有什么用？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看
下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员
函数

class Time
{
public:Time(){cout << "Time()" << endl;_hour = 0;_minute = 0;_second = 0;}
private:int _hour;int _minute;int _second;
};
class Date
{
private:// 基本类型(内置类型)int _year;int _month;int _day;// 自定义类型Time _t;
};
int main()
{Date d;return 0;
}

运行结果：

7.C++针对编译器生成的默认构造函数对于内置类型不初始化做了补丁，即就是内置类型在

声明的时候可以给一个默认值

class Date
{
public:void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year=1;int _month=1;int _day=1;};
int main()
{Date d;d.Print();return 0;
}

运行结果：

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

总结

1.一般情况下我们都要自己写一个默认构造函数，因为有的编译器自己生成构造函数对于内置类型是不做处理的，还是随机值

2.有的情况下不用自己写，比如

class Stack //定义一个栈

{

public:

//这里自己要实现一个构造函数

private:

int *_arr;

int _size;

int _capacity;

};

class MyQueue

{

private:

Stack st1;

Stack st2;

};

上面的虽然不用自己写，但是在嵌套的里面还是要写一个，也就是说，MyQueue里面不用写，但是Stack里面是要写的，因为Stack里面也有内置类型，不写的话有的编译器是不做处理的

析构函数

在学习数据结构的时候，比如我们的栈和队列，有时候老是忘记调用Destory函数，在C语言中要担心这个问题，但是在C++中，你是不用担心这个问题的，因为C++的析构函数会自动帮你处理这个问题

析构函数和构造函数的功能正好相反，是自动对对象进行销毁，当程序要结束的时候，（一般情况下一语句是return 的时候）就会调用默认的析构函数

析构函数的特性

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构
函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int DataType;
class Stack
{
public:Stack(size_t capacity = 3){_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){perror("malloc申请空间失败!!!");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);
}

5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器
生成的默认析构函数，对自定类型成员调用它的析构函数

class Time
{
public:~Time(){cout << "~Time()" << endl;}
private:int _hour;int _minute;int _second;
};
class Date
{
private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;
};int main()
{Date d;return 0;
}

运行结果：

总结

1.有资源需要清理的时候需要自己写析构函数，比如：栈和队列，里面的指针类型在堆上面开辟的，程序结束后需要手动去清理的

2.有的类里面不需要写析构函数

a.没有资源需要清理的，比如日期类的，里面定义了int double类的，程序结束后会自动销毁的

b.内置类型没有需要清理的，剩下的是自定义类型，但是要看自定义类型里面是否需要写

拷贝构造函数

特征

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

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

class Date
{
public:Date(int year=1,int month=1,int day=1){_year = year;_month = month;_day = day;}// Date(const Date d)       //不可以这样写，会引发无穷递归Date(const Date& d)       //可以这样写{cout << "Date(const Date&d)" << endl;_year = d._year;_month = d._month;_day = d._day;}
private:int _year;int _month;int _day;
};int main()
{Date d1;Date d2(d1);           //这样写是拷贝构造//Date d2=d1;          //这样写也是拷贝构造return 0;
}

运行结果：

3.对于自定义类型，函数传值传参会调用它的拷贝构造

class Date
{
public:Date(int year=1,int month=1,int day=1){_year = year;_month = month;_day = day;}Date(const Date& d){cout << "Date(const Date&d)" << endl;_year = d._year;_month = d._month;_day = d._day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year;int _month;int _day;
};void func(Date d)
{d.Print();
}
int main()
{Date d1;//Date d2(d1);//Date d2=d1;func(d1);return 0;
}

函数运行结果：

这也能解释上面为什么说拷贝构造传递参要采用引用的方式，而采用传值的方式会引发无穷递归，

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

class Date
{
public:Date(int year=1,int month=1,int day=1){_year = year;_month = month;_day = day;_arr = &day;}~Date(){free(_arr);_arr = nullptr;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year;int _month;int _day;int* _arr;
};int main()
{Date d1;Date d2(d1);return 0;
}

程序运行结果：

从运行结果来看，程序崩溃了，因为我们没有写拷贝构造函数，编译器自动生成的拷贝构造函数是是按值拷贝，所以这里创建的两个对象的_arr指向同一块空间，程序结束的时候会析构两次，但是第一次指针指向的空间已经为空了，第二次去释放一个空的空间程序自然会崩溃

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

所以这里我们应该写一个深拷贝，只需要申请一个和被拷贝对象大小一样的空间就行了，我们以一个栈为例

Stack(const Stack& st)
{_array = (DataType*)malloc(sizeof(DataType) * st._capacity);if (NULL == _array){perror("malloc申请空间失败!!!");return;}memcpy(_array, st._array, sizeof(DataType) * st._size);_size = st._size;_capacity = st._capacity;
}

总结

上面第二点：自定义里面有自定义类型的，如果第二个自定义类型里面涉及到资源申请的，同样需要在第二个自定义里面写拷贝构造，只是第一个不需要而已

赋值运算符重载

运算符号重载

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

比如下面的

class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}//设置成为公有int _year;int _month;int _day;
};bool operator==(const Date& d1, const Date& d2)
{return d1._year == d2._year && d1._month == d2._month&& d1._day == d2._day;
}int main()
{Date d1(2024, 8, 20);Date d2(2024, 8, 21);//隐式调用，两种方式都行cout << operator==(d1, d2) << endl;//转换调用,实际上就是operator==()函数cout << (d1 == d2) << endl;return 0;
}

运行结果：

1. 其实从上面不难看出，运算符重载极大的增加了代码的可读性，以前写相等的函数名字可能写

compare，equal甚至组合起来的单词，但是，如果有人不认识这些单词怎么办，所以，运算符重载极大的增强了代码的可读性

2.上面的函数在外面无法访问类里面的元素，有以下几个解决方案：

1、提供这些成员get函数和set函数,比如

int getyear()

{

return _year;

} //当然，这个函数是要写在类里面的

2、友元，后面再讲

3、重载为成员函数(一般使用这种)

注意

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

5. .* :: sizeof ？: . 注意以上5个运算符不能重载。

除了上面的第4点，其余的第五点没有什么讲的

第四点举例子：

class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}bool operator==(const Date & d){return _year == d._year && _month == d._month&& _day == d._day;}private:int _year;int _month;int _day;
};
int main()
{Date d1(2024, 8, 20);Date d2(2024, 8, 21);cout << (d1 == d2) << endl;cout << d1.operator==(d2) << endl;return 0;
}

代码说明：

d1.operator==(d2),其中，d1是第一个参数，d2是第二个参数，还有，上面的函数相当于

d1.operator(Date*this,const Date&d2)

拷贝构造和赋值构造的区别

赋值构造又叫赋值重载

下面，用一段代码来说明两者之间的区别：

int main()
{Date d1(2024, 4, 14);// 拷贝构造// 一个已经存在的对象，拷贝给另一个要创建初始化的对象Date d2(d1);Date d3 = d1;Date d4(2024, 5, 1);// 赋值拷贝/赋值重载// 一个已经存在的对象，拷贝赋值给另一个已经存在的对象d1 = d4;return 0;
}

函数的引用返回和直接返回

Date func()
{
Date d(2024, 8, 20);
return d;
} //直接返回

Date&func()
{
Date d(2024, 8, 20);
return d;
} //引用返回，返回的是d的别名

直接返回

直接返回，返回的是值的一份临时拷贝，每次调用函数的时候，都会建立函数的栈帧，等到函数结束的时候，里面的东西也会被销毁掉

引用返回

通过前面的学习，我们都知道，引用就是对变量起一个外号，对引用怎么操作原变量也就怎么操作，如果返回的是其别名，但是函数栈帧已经销毁了，所以接收到的值已经不是之前的那个东西了

class Date
{
public:Date(int year, int month, int day){cout << "Date(int year, int month, int day)" << endl;_year = year;_month = month;_day = day;}Date(const Date& d){cout << "Date(const Date&d)" << endl;}bool operator==(const Date & d){return _year == d._year && _month == d._month&& _day == d._day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};Date&func()
{Date d(2024, 8, 20);return d;
}int main()
{Date ref=func();ref.Print();return 0;
}

程序运行结果：

通过运行结果的第三行，我们能够看见，打印的是随机值，可以说明的是，该变量已经被销毁了

总结：

赋值重载函数

1. 赋值运算符重载格式
参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义

int i=0,j=1,k=2;

i=j=k;

从左到右边赋值，j=k返回的类型是int ,这是规定，同样，在类中，如果要连续赋值的话，必须要写一个返回类型,比如下面的，但是，如果是只有两个对象，可写可不写

上面的函数，其实

Date operator=(const Date& d)
{_year = d._year;_month = d._month;_day = d._day;return *this;
}int main()
{Date d1(2022, 2, 2);Date d2(2024, 2, 4);d2 = d1;d2.Print();return 0;
}   
//为了节省面积，其余的这里就不实现了

运行结果：