1.类的6个默认成员函数
如果一个类中什么成员都没有,简称为空类。
空类中真的什么都没有吗? 并不是,任何类在上面都不写时,编译器会自动生成以下6个默认成员函数。
默认成员函数: 用户没有显式实现,编译器会生成的成员函数称为默认成员函数。
2. 构造函数
2.1 概念
对于以下Date类:
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;
d1.Init(2022, 7, 5);
d1.Print();
Date d2;
d2.Init(2022, 7, 6);
d2.Print();
return 0;
}
对于Date类,可以通过Init 公有方法给对象设置日期,但如果每次创建对象都调用该方法设置,未免有点麻烦,那能否在对象创建时,就将信息设置进去呢?
构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,以保证每个数据成员都有一个合适的初始值,并且在对象整个生命周期内只调用一次。
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;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1; //调用无参构造函数
Date d2(2022, 7, 5); //调用带参的构造函数
Date d3(); //函数声明
d1.Print();
d2.Print();
//d3.Print(); //报错 d3 不是Date类
// 注意: 如果通过无参构造函数创建对象时,对象后面不用跟括号,否则就成了函数声明
// 以下代码的函数:声明了d3函数,该函数无参,返回一个日期类型的对象
//warning C4930 : “Date d3(void)” : 未调用原型函数(是否是有意用变量定义的 ? )
//Date d3();
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类中构造函数屏蔽后,代码可以通过编译,因为编译器生成了一个无参的默认构造函数
//将Date类中构造函数放开,代码编译失败,因为一旦显式定义任何构造函数,编译器将不再自动生成
//无参构造函数,放开后报错:error C2512: “Date”: 没有合适的默认构造函数可用
Date d1;
d1.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
{
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << "-" << _t._hour <<"-" << _t._minute << "-" << _t._second << endl;
}
private:
// 基本类型(内置类型)
int _year;
int _month;
int _day;
// 自定义类型
Time _t;
};
int main()
{
Date d;
d.Print();
}
运行结果:
注意: C++11 中针对内置类型成员不初始化的缺陷,有打了补丁,即:内置类型成员变量在类中声明时可以给默认值。
class Time
{
public:
Time()
{
cout << "Time()" << endl;
_hour = 0;
_minute = 0;
_second = 0;
}
//private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << "-" << _t._hour <<"-" << _t._minute << "-" << _t._second << endl;
}
private:
// 基本类型(内置类型)
int _year=1970;
int _month=1;
int _day=1;
// 自定义类型
Time _t;
};
int main()
{
Date d;
d.Print();
}
运行结果:
7. 无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。
注意: 无参构造函数,全缺省构造函数,我们没写编译器默认生成的构造函数,都可以认为是默认构造函数。
class Date
{
public:
//无参函数
Date()
{
_year = 1900;
_month = 1;
_day = 1;
}
//全缺省函数
Date(int year=1900, int month=1, int day=1 )
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
// 以下测试函数能通过编译吗?
int main()
{
Date d1;
//error C2668: “Date::Date”: 对重载函数的调用不明确
return 0;
}
可将全缺省函数改为半缺省函数,注意缺省参数需要从右向左给
class Date
{
public:
//无参函数
Date()
{
_year = 1900;
_month = 1;
_day = 1;
}
//全缺省函数
Date(int year, int month, int day=1 )
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
// 以下测试函数能通过编译吗?
int main()
{
Date d1;
//error C2668: “Date::Date”: 对重载函数的调用不明确
return 0;
}
3.析构函数
3.1 概念
析构函数:与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作由编译器完成,而对象在销毁时会自动调用析构函数,完成对象中资源的清理工作。
3.2 特性
析构函数是特殊的成员函数,其特征如下:
1.析构函数名是在类名前加上字符 ~ 。
2.无参数无返回值类型。
3. 一个类只能有一个析构函数,若未显式定义,系统会自动生成默认的析构函数。
注意:析构函数不能重载。
4.对象生命周期结束时,C++编译系统会自动调用析构函数。
typedef int StackType;
class Stack
{
public:
void Init(size_t capacity=4)
{
StackType* t = (StackType*)malloc(sizeof StackType* capacity);
if (t == NULL)
{
perror("malloc");
exit(1);
}
_array = t;
_top = 0;
_capacity = capacity;
}
void Push(StackType x)
{
//扩容;
_array[_top++] = x;
}
void Pop()
{
if(_top>0)
_top--;
}
~Stack()
{
if (_array)
{
free(_array);
_array = nullptr;
_top = 0;
_capacity = 0;
}
}
StackType Top()
{
return _array[_top-1];
}
bool Empty() { return 0 == _top; }
bool Size() { return _top; }
private:
StackType* _array;
size_t _top;
size_t _capacity;
};
·5. 关于编译器自动生成的析构函数,是否会完成一些事情呢? 下面的程序我们会看到,编译器生成的默认析构函数,对自定义类型成员调用它的析构函数。
class Time
{
public:
~Time()
{
cout << "~Time()" << endl;
}
int _hour = 0;
int _minute = 0;
int _second = 0;
};
class Date
{
public:
~Date()
{
cout << "~Date()" << endl;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << "-" << _t._hour <<"-" << _t._minute << "-" << _t._second << endl;
}
private:
// 基本类型(内置类型)
Time _t;
int _year=1970;
int _month=1;
int _day=1;
// 自定义类型
};
// 以下测试函数能通过编译吗?
int main()
{
Date d1;
//程序运行结束后输出: ~time()
//在main方法中根本就没有直接创建time类的对象,为什么最后会调用Time类的析构函数?
//因为: main方法中创建了Date对象d,而d中包含4个成员变量,其中_year,_month,_day,
//三个是内置类型成员,销毁时不需要资源清理,最后系统直接将其内存回收即可;而 _t是Time类对象
//所以在d销毁时,要将其内部包含的Time类的_t对象销毁,所以要调用Time类的析构函数。
//但是: main函数中不能直接调用Time类的析构函数,实际上要释放的是Date类对象,所以编译器会
//调用Date类的析构函数,而Date没有显示提供,则编译器会给Date类生成一个默认的析构函数,目的是在其内部调用
//Time类的析构函数,即当Date对象销毁时,要保证其内部每个自定义对象都可以正确销毁
//main函数中并没有直接调用Time类析构函数,而是显式调用编译器为Date类生成的默认析构函数,之后在Date的析构函数中调用Time的析构函数。
//注意: 创建哪个类的对象则调用该类的析构函数,销毁那个类的对象则调用该类的析构函数
return 0;
}
6 .实践总结
1. 有资源需要显示清理,就需要写析构,如: Stack,List
2. 有两种场景不需要写析构,默认生成就可以了
a. 没有资源需要清理, 如: Date
b. 内置类型成员没有资源需要清理,剩下都是自定义类型成员,如 MyQueue
4. 拷贝构造函数
4.1 概念
拷贝构造函数: 只有单个形参,该形参是对本类类型对象的引用(一般常用const修饰),在用已存在的类类型对象创建新对象时由编译器自动调用。
4.2 特征
拷贝构造函数也是特殊的成员函数,其特征如下:
1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只能有一个且必须是类类型对象的引用,使用传参方式编译器直接报错,因为会引发无穷递归调用.
为什么对引起无限递归调用呢? 来看下面的代码
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//Date( Date d)//错误写法
Date(const Date& d)
{
cout << "Date()" << endl;
_year = d._year;
_month = d._month;
_day = d._day;
}
private:
int _year;
int _month;
int _day;
};
void fanc(Date d)
{
cout << "fanc" << endl;
}
int main()
{
Date d1;
fanc(d1);
return 0;
}
运行结果:
这说明在形参实参之间的值传递就是通过拷贝调用函数来完成,这也就是意味着,如果拷贝调用函数那里形参实参之间也是值传递的话,就会无限调用拷贝函数。
3. 若未显式定义,编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝。
class Time
{
public:
Time()
{
_hour = 1;
_minute = 1;
_second = 1;
}
Time(const Time& t)
{
_hour = t._hour;
_minute = t._minute;
_second = t._second;
cout << "Time::Time(const Time&)" << endl;
}
//private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << " " << _t._hour << ":" << _t._minute << ":" << _t._second << endl;
}
private:
//基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d1;
// 用已经存在的 d1拷贝d2, 此处会调用Date类的拷贝构造函数
// 但Date类并没有显式定义拷贝构造函数,则编译器会给Date类生成一个默认的拷贝构造函数
Date d2(d1);
Date d3 = d1;
d2.Print();
d3.Print();
return 0;
}
注意: 在编译器生成的默认拷贝构造函数中,内置类型是按照字节方式直接拷贝的,而自定义类型是调用其拷贝构造函数完成拷贝的。
4.编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了,还需要自己显式实现吗?
当然像日期类这样的类是没必要的。那么下面的类呢? 验证一下试试?
typedef int StackType;
class Stack
{
public:
void Init(size_t capacity=6)
{
StackType* t = (StackType*)malloc(sizeof StackType* capacity);
if (t == NULL)
{
perror("malloc");
exit(1);
}
_array = t;
_top = 0;
_capacity = capacity;
}
void Push(StackType x)
{
//扩容;
_array[_top++] = x;
}
void Pop()
{
if(_top>0)
_top--;
}
~Stack()
{
if (_array)
{
free(_array);
_array = nullptr;
_top = 0;
_capacity = 0;
}
}
StackType Top()
{
return _array[_top-1];
}
bool Empty() { return 0 == _top; }
bool Size() { return _top; }
private:
StackType* _array;
size_t _top;
size_t _capacity;
};
int main()
{
Stack s;
s.Init();
s.Push(1);
s.Push(2);
s.Push(3);
s.Push(4);
Stack s2(s);
return 0;
}
注意; 类中如果没有涉及资源申请时,拷贝构造函数是否写都可以; 一旦涉及到资源申请时,则拷贝构造函数是一定要写的,否则就是浅拷贝。
5. 拷贝构造函数典型调用场景:
- 使用已存在对象创建新对象
- 函数参数类型为类类型对象
- 函数返回类型为类类型对象
class Date
{
public:
Date(int year, int month, int day)
{
cout << "Date(int ,int ,int ):" << this << endl;
}
Date(const Date& d)
{
cout << "Date(const Date& d):" << this << endl;
}
~Date()
{
cout << "~Date()" << this << endl;
}
private:
int _year;
int _month;
int _day;
};
Date Test(Date d) // 创建形参拷贝调用一次
{
Date temp(d); //拷贝对象调用一次
return temp; //返回值拷贝调用一次
}
int main()
{
Date d1(2024, 4, 21);
Test(d1);
return 0;
}
所以为了提高程序效率,一般对象传参时,尽量使用引用类型,返回时根据实际场景,能用引用尽量使用引用。