目录
对于日期(Date)类,可以通过 Init 公有方法给对象设置日期,但如果每次创建对象时都调用该方法设置信息,未免有点麻烦,那能否在对象创建时,就将信息设置进去呢?
构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,以保证
每个数据成员都有 一个合适的初始值,并且在对象整个生命周期内只调用一次。
构造函数
构造函数是特殊的成员函数,需要注意的是,构造函数虽然名称叫构造,但是构造函数的主要任
务并不是开空间创建对象,而是初始化对象。
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
class Date
{
public:
Date()
{
_year = 1;
_mouth = 1;
_day = 1;
}
Date(int year, int mouth, int day)
{
_year = year;
_mouth = mouth;
_day = day;
}
void print()
{
cout << _year << ' ' << _mouth << ' ' << _day << ' ' << endl;
}
private:
int _year;
int _mouth;
int _day;
};
int main()
{
Date s1;
Date s2(2023, 2, 2);
s1.print();
s2.print();
return 0;
}
5. 如果类中没有显式定义构造函数,则C++编译器会自动生成一个无参的默认构造函数,一旦
用户显式定义编译器将不再生成。
class Date
{
public:
void print()
{
cout << _year << '-' << _mouth << '-' << _day << endl;
}
private:
int _year;
int _mouth;
int _day;
};
int main()
{
Date s1;
Date s2;
s1.print();
s2.print();
return 0;
}
6. 关于编译器生成的默认成员函数,很多童鞋会有疑惑:不实现构造函数的情况下,编译器会
生成默认的构造函数。但是看起来默认构造函数又没什么用?d对象调用了编译器生成的默
认构造函数,但是d对象_year/_month/_day,依旧是随机值。也就说在这里编译器生成的
默认构造函数并没有什么用?有一些编译器会把默认值初始化为零。
解答:C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型,如:int/char...,自定义类型就是我们使用class/struct/union等自己定义的类型,看看
下面的程序,就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员
函数。
class Time
{
public:
Time()
{
cout << "time()" << endl;
_hour = 1;
_minute = 1;
_second = 1;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
void print()
{
cout << _year << '-' << _mouth << '-' << _day << endl;
}
private:
int _year;
int _mouth;
int _day;
Time _t;
};
int main()
{
Date s1;
s1.print();
return 0;
}
注意:C++11 中针对内置类型成员不初始化的缺陷,又打了补丁,即:内置类型成员变量在
类中声明时可以给默认值。
class Date
{
public:
void print()
{
cout << _year << '-' << _mouth << '-' << _day << endl;
}
private:
int _year = 1;
int _mouth = 1;
int _day = 1;
};
int main()
{
Date s1;
s1.print();
return 0;
}
7. 无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。
注意:无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为
是默认构造函数。
- 无参构造函数: Date() {}
- 全缺省构造函数: Date(_year = 1,_minute = 1,_day = 1){}
- 们没写编译器默认生成的构造函数: 这个就字面意思
析构函数
通过前面构造函数的学习,我们知道一个对象是怎么来的,那一个对象又是怎么没呢的?
析构函数:与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数,完成对象中资源的清理工作。
析构函数是特殊的成员函数,其特征如下:
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。注意:析构
函数不能重载
4. 对象生命周期结束时,C++编译系统系统自动调用析构函数。
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 3)
{
cout << "Stack(size_t capacity = 3)" << endl;
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
_array[_size] = data;
_size++;
}
~Stack()
{
cout << "~Stack()" << endl;
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
Stack s;
s.Push(1);
s.Push(2);
return 0;
}
5. 关于编译器自动生成的析构函数,是否会完成一些事情呢?下面的程序我们会看到,编译器
生成的默认析构函数,对自定类型成员调用它的析构函数。
class myqueue
{
private:
Stack s1;
Stack s2;
int size = 0;
};
int main()
{
myqueue q1;
return 0;
}
编译器自动生成的析构函数与构造函数类似:
内置类型不做处理,自定义类型调用它的析构函数。
6. 如果类中没有申请资源时,析构函数可以不写,直接使用编译器生成的默认析构函数,比如
Date类;有资源申请时,一定要写,否则会造成资源泄漏,比如Stack类。
拷贝构造函数
拷贝构造函数:只有单个形参,该形参是对本类类型对象的引用(一般常用const修饰),在用已存
在的类类型对象创建新对象时由编译器自动调用。
拷贝构造函数也是特殊的成员函数,其特征如下:
1. 拷贝构造函数是构造函数的一个重载形式。
class Date
{
public:
Date(int year = 1, int mouth = 1, int day = 1)
{
_year = year;
_mouth = mouth;
_day = day;
}
Date(Date& b)
{
_year = b._year;
_mouth = b._mouth;
_day = b._day;
}
void print()
{
cout << _year << ' ' << _mouth << ' ' << _day << ' ' << endl;
}
private:
int _year;
int _mouth;
int _day;
};
int main()
{
Date s1(2023,2,3);
Date s2(s1);
s1.print();
s2.print();
return 0;
}
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用,使用传值方式编译器直接报错,
因为会引发无穷递归调用。
class Date
{
public:
Date(int year = 1, int mouth = 1, int day = 1)
{
cout << "Date(int year = 1, int mouth = 1, int day = 1)" << endl;//为了方便观察
_year = year;
_mouth = mouth;
_day = day;
}
Date(Date& b)
{
_year = b._year;
_mouth = b._mouth;
_day = b._day;
}
void print()
{
cout << _year << ' ' << _mouth << ' ' << _day << ' ' << endl;
}
private:
int _year;
int _mouth;
int _day;
};
void func(Date d)
{
d.print();
}
int main()
{
Date s1(2023,2,3);
func(s1);
return 0;
}
使用传值方式编译器为什么会直接报错:
如果是传值如下:
语法逻辑上会形成无限递归,因此拷贝的函数要使用传引用。
那如果传指针呢?
指针是可以的,但它就不是拷贝构造了,它就是一个普通的构造函数了。
3. 若未显式定义,编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝。
注意:在编译器生成的默认拷贝构造函数中,内置类型是按照字节方式直接拷贝的,而自定
义类型是调用其拷贝构造函数完成拷贝的。
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 3)
{
cout << "Stack(size_t capacity = 3)" << endl;
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
_array[_size] = data;
_size++;
}
~Stack()
{
cout << "~Stack()" << endl;
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
Stack s1;
s1.Push(1);
s1.Push(1);
s1.Push(1);
Stack s2 = s1;
return 0;
}
运行结果如下:
我们可以通过下图看到由于传值的原因两个对象的_array指得是同一个地址,s1._array释放置空之后,s2._array还是指向原来那块地址的。导致同一块内存释放了两次,所以报错。这就叫做浅拷贝(值拷贝)
4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了,还需要自己显式实现吗?
当然像日期类这样的类是没必要的。
注意:类中如果没有涉及资源申请时,拷贝构造函数是否写都可以;一旦涉及到资源申请
时,则拷贝构造函数是一定要写的,否则就是浅拷贝。
接以上代码深拷贝代码如下:
Stack(const Stack& s)
{
_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
if (_array == nullptr)
{
perror("malloc fail");
return;
}
memcpy(_array, s._array, sizeof(DataType) * s._size);
_size = s._size;
_capacity = s._capacity;
}
5. 拷贝构造函数典型调用场景:
使用已存在对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象
为了提高程序效率,一般对象传参时,尽量使用引用类型,返回时根据实际场景,能用引用
尽量使用引用。
感谢大家的观看!