类和对象（上）
- 一，构造函数
- 1，概念
- 2，特性
- 二，析构函数
- 1，概念
- 2，特性
- 三，拷贝构造
- 1，概念
- 2，特性
- 四，运算符重载
- 1，概念
- 2，赋值运算符重载
- 五，&重载与const& 重载
- 六，总结
一，构造函数
1，概念
class Stack
{
public:
void Init(int n = 4)
{
_a = (int*)malloc(sizeof(int) * n);
if (!_a)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capcity = n;
}
void Destroy()
{
if (_a)
{
free(_a);
_a = nullptr;
_top = _capcity = 0;
}
}
private:
int* _a;
int _top;
int _capcity;
};
int main()
{
Stack st;
st.Init();
return 0;
}
由于C++的类内允许定义函数，但是像上述那样需要我们去手动的初始化对象很容易玩掉。于是C++中提出了构造函数这一概念。
构造函数 ：构造函数是一个特殊的成员函数，名字与类名相同，在类的实例化时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象的整个生命周期内只调用一次。
注意：构造函数不是用来创建对象的，而是用来初始化对象的，构造函数是没有返回值的，且支持函数重载。
所以，一般在C++中是这样写的：
class Stack
{
public:
Stack(int n = 4)
{
_a = (int*)malloc(sizeof(int) * n);
if (!_a)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capcity = n;
}
private:
int* _a;
int _top;
int _capcity;
};
int main()
{
Stack st1;
Stack st2(8);
return 0;
}
切忌这样使用无参的构造函数：
Stack st3();
这会与函数的声明冲突，函数名为st3，参数为空，返回值为Stack的函数声明。
2，特性
- 函数名与类名相同
- 无返回值
- 类的实例化时编译器自动调用其构造函数
- 支持函数重载
- 如果没有显示的定义构造函数，编译器会自动生成一个默认构造函数，一旦用户显示定义了构造函数，那么编译器就不会自动生成
- 编译器自动生成的默认构造函数，对内置类型不做处理，对自定义类型会去调用其默认构造函数
class Queue
{
public:
private:
Stack st1;
Stack st2;
int _size;
};
int main()
{
Queue q;
return 0;
}
即使Queue这个类没有显示定义构造函数，所以编译器自动生成了一个默认构造函数，对自定义类型会去调用其默认构造，对内置类型不做处理（可以看到编译器也对_size进行了初始化，这只是针对本编译器会这样做，不具有普遍性）。
- 针对编译器自动生成的默认构造函数对内置类型不做处理，在C++ 11中提出允许给非静态成员变量提供一个缺省值，即在类的实例化时未对某个成员变量初始化，那么其的值就为所给的缺省值。
class Queue
{
public:
private:
Stack st1;
Stack st2;
int _size = 1;
};
int main()
{
Queue q;
return 0;
}
- 无参的构造函数与全缺省的构造函数与编译器自动生成的都是默认构造函数，且默认构造函数只允许有一个。
二，析构函数
1，概念
void Destroy()
{
if (_a)
{
free(_a);
_a = nullptr;
_top = _capcity = 0;
}
}
与构造函数的功能相反，当我们定义的对象涉及到动态内存开辟时，之前我们会手动的去调用Destroy函数去进行资源管理，析构函数在对象销毁的时候自动调用，完成对象中资源的清理工作，且函数名为 ~类名 ，没有参数，不支持函数重载。
class Stack
{
public:
Stack(int n = 4)
{
_a = (int*)malloc(sizeof(int) * n);
if (!_a)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capcity = n;
}
~Stack()
{
if (_a)
{
free(_a);
_a = nullptr;
_top = 0;
_capcity = 0;
}
}
private:
int* _a;
int _top;
int _capcity;
};
2，特性
- 函数名 ~类名
- 无参数
- 不支持函数重载
- 对象销毁时自动调用
- 当用户没有显示的去写析构函数时，编译器会自动生成一个析构函数。
- 编译器自动生成的析构函数，对内置类型不做处理，对于自定义类型会去调用其析构函数。
class Stack
{
public:
Stack(int n = 4)
{
_a = (int*)malloc(sizeof(int) * n);
if (!_a)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capcity = n;
}
private:
int* _a;
int _top;
int _capcity;
};
void test1()
{
Stack st1(6);
}
int main()
{
test1();
return 0;
}
Stack 类中的成员变量都是内置类型，编译器自动生成的析构函数不对其做处理，导致_a指向的空间没有被释放，造成内存泄露。
- 如果类中没有涉及申请资源时，析构函数可以不用写，直接使用编译器自动生成的析构函数，像Stack类这样的涉及申请资源时，一定要写析构函数。
三，拷贝构造
1，概念
拷贝构造函数是构造函数的一种重载形式，只有一个参数，是本类对象的引用（一般用const 修饰），用已有对象去初始化创建新的对象时，会自动调用拷贝构造。
2，特性
- 拷贝构造函数是构造函数的一种重载形式
- 拷贝构造函数的参数只有一个且必须是同类对象的引用，使用传值的方式编译器会报错，因为会发生无穷递归。
如果调用拷贝构造使用传值的方式：由于传值传参会发生拷贝构造，也就是说我们还没调用到拷贝构造之前，要现发生一次拷贝构造，依次反复，无穷的递归下去。 - 如果没有显示的定义拷贝构造函数，编译器会自动生成一个拷贝构造。其对内置类型进行简单的值拷贝，对自定义类型会调用其拷贝构造函数。
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2023, 2, 10);
Date d2(d1);
return 0;
}
- 当类中涉及到资源的申请时，一定也要写显示的拷贝构造函数，否则自动生成的是浅拷贝。
class Stack
{
public:
Stack(int n = 4)
{
_a = (int*)malloc(sizeof(int) * n);
if (!_a)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capcity = n;
}
~Stack()
{
if (_a)
{
free(_a);
_a = nullptr;
_top = 0;
_capcity = 0;
}
}
private:
int* _a;
int _top;
int _capcity;
};
int main()
{
Stack st1;
Stack st2(st1);
return 0;
}
可以看到如果使用把编译器提供的拷贝构造，会发生浅拷贝，会导致一系列错误的出现。
Stack(const Stack& st)
{
if (this != &st)
{
_a = (int*)malloc(sizeof(int) * st._capcity);
if (!_a)
{
perror("malloc fail");
exit(-1);
}
memcpy(_a, st._a, sizeof(int) * st._capcity);
_top = st._top;
_capcity = st._capcity;
}
}
四，运算符重载
1，概念
int main()
{
vector<int> a(4, 0);
for (int i = 0; i < 4; i++)
{
a[i] = i;
}
for (int i = 0; i < 4; i++)
{
cout << a[i] << " ";
}
return 0;
}
vector是STL库中提供的顺序表这一数据结构，但是你发现他居然能像数组一样使用[ ]来访问其成员，其实这是重载了[ ]这个运算符，本质上是函数调用。
运算符重载： C++中为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有返回值，函数名，参数列表，且与普通函数类似。其函数名为operator（关键字）+ 要重载的运算符
例如，我们自己实现一个数组类来运用一下这个运算符重载：
class Array
{
public:
int& operator[](int i)
{
return a[i];
}
private:
int a[10];
int size = 0;
};
int main()
{
Array arr1;
for (int i = 0; i < 5; i++)
{
arr1[i] = i;
}
for (int i = 0; i < 5; i++)
{
cout << arr1[i] << " ";
}
return 0;
}
注意：
- 不能通过连接其他符号来创建新的操作符：比如operator@
- 重载运算符必须有一个参数是自定义类型的
- 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
- 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
- .* :: sizeof ?: . 注意以上5个运算符不能重载。
2，赋值运算符重载
1，运算符重载格式
- 参数类型：const T&，传递引用可以提高传参效率，同时也防止了由于赋值的顺序产生-错误。
- 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
- 检测是否自己给自己赋值
- 返回*this ：要复合连续赋值的含义
2，赋值运算符只能重载成类的成员函数不能重载成全局函数
==原因：==赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。
3，用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
Date& operator[](const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
}
private:
int _year;
int _month;
int _day;
};
五，&重载与const& 重载
这两个默认成员函数一般不用自己实现，编译器会默认生成。
class Date
{
public :
Date* operator&()
{
return this ;
}
const Date* operator&()const
{
return this ;
}
private :
int _year ; // 年
int _month ; // 月
int _day ; // 日
};
六，总结
1，类的6个默认成员函数：
- 构造函数
- 析构函数
- 拷贝构造函数
- 赋值运算符重载
- &运算符重载
- const& 运算符重载
2，默认成员函数共同的性质就是，用户不主动提供时，编译器会自动提供默认成员函数。
3，编译器自动提供的构造函数与析构函数，对内置类型不做处理，对与自定义类型会调用其构造函数和析构函数。
4，编译器自动提供的赋值运算符重载 拷贝构造，对内置类型会进行值拷贝，对自定义类型调用其赋值运算符重载和拷贝构造。
5，C++ 11 提供了可以给内置类型提供缺省值。
