类的六个默认成员函数（上）
目录
对于日期（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. 拷贝构造函数典型调用场景：
使用已存在对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用
尽量使用引用。
感谢大家的观看！
原文地址：https://blog.csdn.net/2301_80468112/article/details/137692273
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！