1.构造函数:
1.1 构造函数的引入:
在关于数据结构这一部分的文章中,创建了一个新的数据结构后,通常需要编写一个初始化函数来对这个数据结构进行一次初始化。在C++的类中,如果存在函数,同样也需要对函数进行初始化,例如:
class Date
{
public:
void Init(int year, int month, int date)
{
_year = year;
_month = month;
_date = date;
}
void print()
{
cout << _year << "-" << _month << "-" << _date << endl;
}
private:
int _year;
int _month;
int _date;
};
int main()
{
Date d1;
d1.Init(2023, 11, 15);
d1.print();
return 0;
}
在许多情况下,由于初始化函数容易被人为遗忘,因为造成了很多的错误。即使人为避免了这种错误,但是在每次打印不同的日期时,都需要进行一次初始化,使得操作较为繁琐。为了解决上述问题,在C++中,引入了构造函数这一概念。
1.2 构造函数的定义及特性:
构造函数定义如下:构造函数是特殊的成员函数,需要注意的是,构造函数虽然名称叫构造,但是构造函数的主要任务并不是开空间创建对象,而是初始化对象。
构造函数特性如下:
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
在构造函数的特性中的第条提到,构造函数无返回值,在C语言中,无返回值的函数一般都会在函数名之前加上类型,但是在C++中,不需要加任何额外的类型。
将文章开始给出代码中的初始化函数用构造函数进行替代,代码如下:
class Date
{
public:
Date()
{
_year = 1;
_month = 1;
_date = 1;
}
Date(int year, int month, int date)
{
_year = year;
_month = month;
_date = date;
}
/*void Init(int year, int month, int date)
{
_year = year;
_month = month;
_date = date;
}*/
void print()
{
cout << _year << "-" << _month << "-" << _date << endl;
}
private:
int _year;
int _month;
int _date;
};
特性中提到,构造函数可以构成重载。因此,在上述代码中给出了两个构造函数。在使用构造函数时,分为两种,即代码中所体现的有参数和无参数的两种构造函数。对于上述两种构造函数的使用方法如下:
int main()
{
Date d1;
d1.print();
Date d2(2023, 11, 15);
d2.print();
return 0;
}
打印结果如下:
其中,是针对无参数的构造函数的调用,是针对有参数的构造函数的调用。
对于构造函数,在使用时也可以与缺省参数进行结合,例如:
class Date
{
public:
Date(int year = 15, int month = 15, int date = 15)
{
_year = year;
_month = month;
_date = date;
}
void print()
{
cout << _year << "-" << _month << "-" << _date << endl;
}
private:
int _year;
int _month;
int _date;
};
int main()
{
Date d3;
d3.print();
Date d4(2023, 11, 15);
d4.print();
return 0;
}
打印结果如下:
1.3 内置类型和自定义类型:
在上面的代码中,构造函数都是人为进行构造的,但是,在不人为在类中创建构造函数的情况下,能否继续初始化类中的变量,需要分成两个情况,即:自定义类型和内置类型。
对于内置类型,就是语言本身提供的数据类型,例如:,等,对于自定义类型,就是人为进行构建的类型,例如:,。在不人为创建构造函数的情况下,针对自定义类型,编译器会自动生成一个构造函数。而对于自定义类型则不作用。例如:
class Time
{
public:
Time()
{
cout << "Time()" << endl;
_hour = 1;
_minute = 1;
_second = 1;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year;
int _month;
int _day;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
上述给出的代码中,由类型定义的类是一个自定义类型,在另一个类中,有三个由类型定义的基本类型和一个由类型定义的自定义类型。再代码运行后,各类型中的变量如下图所示:
由此可见,对于对象中的三个内置类型均未被初始化。而自定义类型为的对象_,编译器会去调用这个成员的默认构造函数来进行初始化。
在上面的情况中,自定义类型中有一个人为编写的构造函数。在中分别存在:三个内置类型型的变量_,_,_,_,在程序运行过程中,由于_的类型是自定义类型,因此去调用此类型的默认构造函数进行初始化。
如果,当_的类型,即中没有人为编写的构造函数时,即:
class Time
{
public:
Time()
{
cout << "Time()" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year;
int _month;
int _day;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
此时,再运行程序,中的四个变量为:
此时,编译器会因为_的类型是自定义类型,去调用自定义类型的默认构造函数,由于,没有人 为构建,因此编译器会随机生成一个构造函数,最终将变量初始化为随机值。
在C++11中,针对内置雷系在没有构造函数的情况下不能被初始化的问题,进行了一定的优化,即:内置类型变量在声明时可以给缺省值,即:
class Time
{
public:
Time()
{
cout << "Time()" << endl;
_hour = 1;
_minute = 1;
_second = 1;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year = 10;
int _month = 10;
int _day = 10;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
此时,内置类型的变量可以通过监视窗口进行监视:
1.4 默认构造:
在上面的部分中,解释了构造函数的自动调用即默认生成对于不同类型的变量,有不同的效果,即针对自定义类型会进行自动调用此类型的默认构造函数。如果在自定义类型中已经存在了人为编写的构造函数,则调用该函数,否则编译器会自动生成。需要注意,存在人为定义的构造函数的情况下,编译器不会自动生成默认构造。
class Time
{
public:
Time(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()
{
Time d1;
d1.Print();
return 0;
}
对于上述代码,在自定义类型中人为编写了一个构造函数,此时如果去运行程序,会出现下面的错误:
在人为给出了构造函数的情况下,编译器不会自动生成构造函数,但是在对这个类进行实使用时,并没有按照规则传参进行调用,因此,编译器会显示没有合适的默认构造函数。
造成上述问题的原因是因为默认构造这个概念,并不是只指在不人为编写构造函数的情况下,编译器自动给出的构造函数,还包括以下两个构造函数:不需要传参数就可以调用的构造函数以及全缺省的构造函数。因此,假设一个类中人为定义了多个构造函数,则编译器在调用时,会优先调用不需要传递参数的构造函数。如果不存在,则会报错。并且,针对上述三种默认构造函数,不可以同时存在。
2. 析构函数:
2.1 析构函数的概念及特性:
析构函数概念如下:与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数,完成对象中资源的清理工作。
析构函数特性如下:
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;
}
~Stack()
{
_array = nullptr;
_capacity = 0;
_size = 0;
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
Stack s;
return 0;
}
上述代码中,析构函数即为~,运行代码时,可以通过监视窗口来观察析构函数的作用:
当代码运行完构造函数后,即:
此时类中各对象的状态如下图所示:
当运行析构函数后,即:
此时类中各对象如下图所示:
通过上述一系列动作过程发现,析构函数自动将类中的各对象资源的清理工作。
析构函数针对于内置类型和自定义类型的处理方法于构造函数一样,本部分不再进行过多说明。