【C++】类的默认成员函数:深入剖析与应用(上)
CSDN 2024-10-22 16:05:01 阅读 87
😀在上一篇文章中我们初步了解了C++的基础概念,现在我们进行对C++类的默认成员函数进行更加深入的理解!
👉【C++新手入门指南:从基础概念到实践之路】
目录
💯前言
💯构造函数
一、构造函数的定义与特性
1.定义
2.特性
二、构造函数的种类
1.默认构造函数
2.带参数的构造函数
💯拷贝构造函数
⭐概念
⭐特征
💯析构函数
⭐概念
⭐特性
💯总结
💯前言
在 C++ 的面向对象编程世界中,类的默认成员函数犹如构建程序大厦的基石,发挥着至关重要的作用。它们分别是构造函数、析构函数、拷贝构造函数、赋值运算符重载、<code>const成员函数以及取地址及const
取地址操作符重载。
⭐深入理解和掌握这些默认成员函数,对于每一位 C++ 开发者来说都至关重要。
💯构造函数
在解析这个概念之前,我们引用一段代码👇:
<code>#include <iostream>
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
std::cout << _year << "-" << _month << "-" << _day << std::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 公有方法给对象设置日期,但如果每次创建对象时都调用该方法设置信息,未免有点麻烦,那能否在对象创建时,就将信息设置进去呢?”
一、构造函数的定义与特性
1.定义
构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,以保证每个数据成员都有 一个合适的初始值,并且在对象整个生命周期内只调用一次。
2.特性
构造函数是特殊的成员函数,需要注意的是,构造函数虽然名称叫构造,但是构造函数的主要任
务并不是开空间创建对象,而是初始化对象。 通过构造函数,可以为对象的数据成员赋予初始值,确保对象在诞生之时就处于一个合理的状态。
😕例如:
当我们定义一个表示学生信息的类时,可以在构造函数中为学生的姓名、年龄等属性赋予初始值,这样在创建学生对象时,就不必再单独为每个属性进行赋值操作,提高了代码的简洁性和可读性。
⭐构造函数的特性:
函数名与类名相同。无返回值。对象实例化时编译器自动调用对应的构造函数。构造函数可以重载。
#include <iostream>
class MyClass {
public:
int value;
// 默认构造函数
MyClass() {
value = 0;
std::cout << "默认构造函数被调用。" << std::endl;
}
// 带参数的构造函数,实现了构造函数的重载
MyClass(int val) : value(val) {
std::cout << "带参数的构造函数被调用,值为:" << value << std::endl;
}
};
int main() {
// 对象实例化时编译器自动调用对应的构造函数
MyClass obj1; // 调用默认构造函数
MyClass obj2(42); // 调用带参数的构造函数
return 0;
}
如果类中没有显式定义构造函数,则C++编译器会自动生成一个无参的默认构造函数,一旦用户显式定义编译器将不再生成。
#include <iostream>
class Person {
public:
std::string name;
int age;
// 如果没有显式定义构造函数,编译器自动生成默认构造函数
// Person() {
// std::cout << "编译器自动生成的默认构造函数被调用。" << std::endl;
// name = "Unknown";
// age = 0;
// }
};
class AnotherPerson {
public:
std::string name;
int age;
AnotherPerson() {
std::cout << "显式定义的默认构造函数被调用。" << std::endl;
name = "Another Unknown";
age = 0;
}
};
int main() {
// 对于没有显式定义构造函数的类 Person,编译器自动生成默认构造函数
Person p1;
std::cout << "Person 的名字:" << p1.name << ", 年龄:" << p1.age << std::endl;
// 对于显式定义了构造函数的类 AnotherPerson
AnotherPerson ap1;
std::cout << "AnotherPerson 的名字:" << ap1.name << ", 年龄:" << ap1.age << std::endl;
return 0;
}
无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。 注意: 无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为是默认构造函数。
<code>#include <iostream>
class MyClass {
public:
int value;
// 无参构造函数
MyClass() {
value = 0;
std::cout << "无参构造函数被调用。" << std::endl;
}
// 全缺省构造函数(也被认为是默认构造函数,但不能与无参构造函数同时存在)
// MyClass(int v = 0) {
// value = v;
// std::cout << "全缺省构造函数被调用。" << std::endl;
// }
};
int main() {
// 调用无参构造函数创建对象
MyClass obj1;
std::cout << "obj1 的值:" << obj1.value << std::endl;
// 如果存在全缺省构造函数,可以这样创建对象
// MyClass obj2;
// std::cout << "obj2 的值:" << obj2.value << std::endl;
return 0;
}
二、构造函数的种类
1.默认构造函数
默认构造函数是在没有显式定义任何构造函数时,由编译器自动生成的构造函数。它没有参数,或者所有参数都有默认值。默认构造函数的作用是在创建对象时,为对象的数据成员赋予默认值。
<code>class Student {
public:
string name;
int age;
Student() {
name = "Unknown";
age = 0;
}
};
在这个例子中,Student()
就是默认构造函数,它将学生的姓名初始化为 “Unknown”,年龄初始化为 0。
2.带参数的构造函数
带参数的构造函数可以接受一个或多个参数,用于在创建对象时为数据成员赋予特定的值。这种构造函数可以提高代码的灵活性,允许程序员根据不同的情况创建对象。
class Student {
public:
string name;
int age;
Student(string n, int a) {
name = n;
age = a;
}
};
在这个例子中,Student(string n, int a)
是带参数的构造函数,可以通过传入学生的姓名和年龄来创建学生对象。
😕例如:
#include <iostream>
#include <string>
class Student {
public:
std::string name;
int age;
Student() {
name = "Unknown";
age = 0;
}
Student(std::string n, int a) : name(n), age(a) {}
};
int main() {
Student s1;
std::cout << "Default constructor: " << s1.name << ", " << s1.age << std::endl;
Student s2("Tom", 18);
std::cout << "Parameterized constructor: " << s2.name << ", " << s2.age << std::endl;
return 0;
}
代码结果如下:
💯拷贝构造函数
⭐概念
在现实生活中,可能存在一个与你一样的自己,我们称其为双胞胎。
🌚"那在创建对象时,可否创建一个与已存在对象一某一样的新对象呢?"
拷贝构造函数:只有单个形参,该形参是对本类类型对象的引用(一般常用const修饰),在用已存
在的类类型对象创建新对象时由编译器自动调用。
⭐特征
拷贝构造函数也是特殊的成员函数,其特征如下:
拷贝构造函数是构造函数的一个重载形式。拷贝构造函数的参数只有一个且必须是类类型对象的引用,使用传值方式编译器直接报错,
因为会引发无穷递归调用。
<code>#include <iostream>
class Date
{
public:
// 构造函数,可以接受三个参数,也可以不接受参数,此时使用默认值
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year; // 初始化成员变量_year为传入的年份或默认值1900
_month = month; // 初始化成员变量_month为传入的月份或默认值1
_day = day; // 初始化成员变量_day为传入的日期或默认值1
}
// 拷贝构造函数,正确写法
Date(const Date& d)
{
_year = d._year; // 将传入对象的年份赋值给当前对象的年份
_month = d._month; // 将传入对象的月份赋值给当前对象的月份
_day = d._day; // 将传入对象的日期赋值给当前对象的日期
}
// 错误写法:会引发无穷递归
/*Date(const Date& d)
{
// 这里如果再次调用拷贝构造函数,就会形成无穷递归
Date temp(d);
_year = temp._year;
_month = temp._month;
_day = temp._day;
}*/
private:
int _year; // 存储年份
int _month; // 存储月份
int _day; // 存储日期
};
int main()
{
// 创建一个使用默认值初始化的 Date 对象 d1
Date d1;
// 使用拷贝构造函数,以 d1 为蓝本创建一个新的 Date 对象 d2
Date d2(d1);
return 0;
}
若未显式定义,编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝。
<code>#include <iostream>
class MyClass {
public:
int* data;
MyClass() {
data = new int(10);
}
// 默认拷贝构造函数,由编译器生成(浅拷贝)
// MyClass(const MyClass& other) : data(other.data) {}
};
int main() {
MyClass obj1;
MyClass obj2 = obj1;
// 修改 obj2 的数据,会影响 obj1 的数据,因为它们指向同一块内存
*(obj2.data) = 20;
std::cout << "obj1 的数据:" << *(obj1.data) << std::endl;
std::cout << "obj2 的数据:" << *(obj2.data) << std::endl;
return 0;
}
在这个例子中,没有显式定义拷贝构造函数,编译器会生成默认的拷贝构造函数进行浅拷贝。对象
obj2
通过默认拷贝构造函数从obj1
复制而来,但是它们的成员指针data
指向了同一块内存地址。当修改obj2
的数据时,obj1
的数据也会被改变,因为它们实际上共享同一块内存空间,这就是浅拷贝的行为。如果要避免这种情况:需要显式定义一个深拷贝的拷贝构造函数,在其中为新对象分配独立的内存空间并复制数据。
💯析构函数
⭐概念
通过前面构造函数的学习,我们知道一个对象是怎么来的,😮“那一个对象又是怎么没呢的?”
析构函数:与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数,完成对象中资源的清理工作。
⭐特性
析构函数是特殊的成员函数,其特征如下:
析构函数名是在类名前加上字符 ~。 无参数无返回值类型。一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。注意:析构函数不能重载。 对象生命周期结束时,C++编译系统系统自动调用析构函数。
#include <iostream>
class MyClass {
public:
MyClass() {
std::cout << "构造函数被调用。" << std::endl;
}
~MyClass() {
std::cout << "析构函数被调用。" << std::endl;
}
};
int main() {
{
MyClass obj;
}
std::cout << "离开局部作用域。" << std::endl;
return 0;
}
“😦关于编译器自动生成的析构函数,是否会完成一些事情呢?”下面的程序我们会看到,编译器生成的默认析构函数,对自定类型成员调用它的析构函数。
<code>#include <iostream>
class SomeResource {
public:
SomeResource() {
std::cout << "SomeResource 构造函数被调用。" << std::endl;
}
~SomeResource() {
std::cout << "SomeResource 析构函数被调用。" << std::endl;
}
};
class MyClass {
public:
MyClass() {
std::cout << "MyClass 构造函数被调用。" << std::endl;
}
~MyClass() {
std::cout << "MyClass 析构函数被调用。" << std::endl;
}
private:
SomeResource resource;
};
int main() {
MyClass obj;
std::cout << "程序继续执行..." << std::endl;
return 0;
}
😎 析构函数会对自定义类型的成员调用它们的析构函数,以正确地清理资源。 如果类中没有申请资源时,析构函数可以不写,直接使用编译器生成的默认析构函数,比如:Date类;有资源申请时,一定要写,否则会造成资源泄漏,比如Stack类。
<code>#include <iostream>
// 没有申请资源的类 Date
class Date {
public:
int year;
int month;
int day;
Date(int y, int m, int d) : year(y), month(m), day(d) {}
};
// 申请资源的类 Stack(这里只是简单模拟,实际的栈通常更复杂)
class Stack {
public:
int* data;
int top;
int capacity;
Stack(int size) {
data = new int[size];
top = -1;
capacity = size;
}
~Stack() {
// 释放申请的资源
delete[] data;
std::cout << "Stack 析构函数被调用,资源已释放。" << std::endl;
}
};
int main() {
// Date 类可以直接使用默认析构函数,无需显式编写
Date date(2023, 10, 19);
// Stack 类必须显式编写析构函数以避免资源泄漏
Stack stack(10);
return 0;
}
💯总结
以上就是本文的全部内容了,本文讲解了C++ 类的默认成员函数的前半部分内容,如果你渴望深入了解 C++ 类的内部机制,如果你追求更高水平的编程技艺,那么千万不要错过 C++ 类的默认成员函数(下)。😜持续关注,一同开启这场充满挑战与惊喜的编程之旅吧!👉【A charmer】
😎让我们在 C++ 的海洋中继续乘风破浪,探索无限可能!
声明
本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。