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的函数声明。
class Queue
{
public:
private:
Stack st1;
Stack st2;
int _size;
};
int main()
{
Queue q;
return 0;
}
即使Queue这个类没有显示定义构造函数，所以编译器自动生成了一个默认构造函数，对自定义类型会去调用其默认构造，对内置类型不做处理（可以看到编译器也对_size进行了初始化，这只是针对本编译器会这样做，不具有普遍性）。
class Queue
{
public:
private:
Stack st1;
Stack st2;
int _size = 1;
};
int main()
{
Queue q;
return 0;
}
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;
};
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指向的空间没有被释放，造成内存泄露。
拷贝构造函数是构造函数的一种重载形式，只有一个参数，是本类对象的引用（一般用const 修饰），用已有对象去初始化创建新的对象时，会自动调用拷贝构造。
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;
}
}
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;
}
注意：
1，运算符重载格式
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;
};
这两个默认成员函数一般不用自己实现，编译器会默认生成。
class Date
{
public :
Date* operator&()
{
return this ;
}
const Date* operator&()const
{
return this ;
}
private :
int _year ; // 年
int _month ; // 月
int _day ; // 日
};
1，类的6个默认成员函数：
2，默认成员函数共同的性质就是，用户不主动提供时，编译器会自动提供默认成员函数。
3，编译器自动提供的构造函数与析构函数，对内置类型不做处理，对与自定义类型会调用其构造函数和析构函数。
4，编译器自动提供的赋值运算符重载 拷贝构造，对内置类型会进行值拷贝，对自定义类型调用其赋值运算符重载和拷贝构造。
5，C++ 11 提供了可以给内置类型提供缺省值。