目录
1.类的6个默认成员函数
c++的特性为三种分别是：封装，继承，多态~~这三个特性造就了c++从这三个特性上也体现出了和c语言的差别~~在封装这里又涉及到比较细的语法知识~就是我们需要了解到的默认构造函数~~
2.构造函数
2.1概念
class D
{
public:
void Init(int year = 2010, int month = 10, int day = 29)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
D d1,d2;
d1.Init();
d2.Init(2022, 2, 27);
d1.Print();
d2.Print();
return 0;
}这样每次要用这个函数都需要设置信息，未免有些太麻烦了，可以通过构造函数来完成
构造函数:是一个特殊的成员函数，名字与类名相同，创建类型对象时由编译器自动调用，保证每个成员对象都有一个初始值，并且在对象的声明周期内只调用一次。
2.2特性
class Data
{
public:
//推荐使用全缺省或者半缺省。比较好用！
Data(int year=0, int month=20, int day=28)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Data d1;
Data d2(2022, 2, 27);
d1.Print();
d2.Print();
return 0;
}无参的缺省函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数，全缺省构造函数，我们没写编译生成的构造函数。都可以认为是默认构造函数！
✨Notice：
构造函数对内置类型不做处理，但是对自定义类型编译器会调用它的默认构造函数~👇👇👇👇👇👇
class A
{
public:
A(int x)
{
a = x;
cout << "A()" << endl;
}
private:
int a;
};
class Date
{
public:
Date(int year=1,int month=1,int day=1,int x=0)
:_a(x)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
A _a;
};
int main()
{
Date d1;
return 0;
}上面这段代码定义了无参构的日期类的构造函数，里面还有一个自定义A类的变量~~👇👇👇👇
👇👇
我们观察到，编译器并没有对日期类里面的成员变量做统一处理，而是只处理了自定义类型，去调用了自定义的默认构造函数~~。这一点是需要注意的~~~~~~；
3.析构函数
3.1概念
3.2特性
class A
{
public:
A()
{
a = 99;
cout << "A()" << endl;
}
~A()
{
cout << "我是自定义类型我析构了~~" << endl;
}
private:
int a;
};
class Date
{
public:
Date(int year=1,int month=1,int day=1)
{
/*_year = year;
_month = month;
_day = day;*/
}
~Date()
{
cout << "我里面有内置类型也有自定义类型，我也想析构一下~" << endl;
}
private:
int _year;
int _month;
int _day;
A _a;
};
int main()
{
Date d1;
return 0;
}
✨Notice：
我们可以注意到，编译器也是自动调用了它们的析构函数~我们写了析构函数编译器便不再默认生了~~~显然析构函数对于日期类里面的成员变量是毫无意义的~，👇 👇👇👇👇👇👇👇👇👇👇👇
如果是动态开辟的空间我们还是需要注意析构函数释放的方式的~~~~
4.拷贝构造函数
4.1概念biaoqing
我们可以发现，这种方式直接就让d2有了d1的性质，这里就涉及到了系统默认生成的拷贝构造函数~~~
✨Notice：
这里我们需要关注的是，系统默认生成的拷贝构造函数只是完成简单的值拷贝，并不能解决所有的问题~拷贝构造也属于是构造函数的一种~拷贝构造对于内置类型参数我们无需手动去写一个拷贝构造函数~系统默认生成的就够用了~~但是对于那么动态开辟的就是另外一个概念了~~👇👇👇
class A
{
public:
A(const char*a)
{
_a =(char*) malloc(strlen(a)+1);
strcpy(_a, a);
int len = strlen(_a);
for (size_t i = 0; i < len; i++)
{
cout << _a[i];
}
}
~A()
{
cout <<endl<< "析构函数，包括拷贝对象~" << endl;
}
private:
char* _a;
};
int main()
{
A a("hello ,world");
A b(a);
return 0;
}
我们需要注意的是，动态开辟的空寂是需要我们手动释放的，不然就会造成内存泄露的情况~~
那么我们手动释放一下空间看一下会怎么样·👇👇👇👇👇👇👇👇👇
可恶的是程序崩溃了，这个编译器默认生成的拷贝构造好像也不是特别好用~~问题的关键就是，系统生成的靠二拷贝构造含函数，只是拷贝了原来_a所指向的空间的内容，其实也就又定义了一个指针指向了了被拷贝对象指针指向的那块空间，这样就是两个指针指向同一块空间了，我们又对这块空间进行了手动释放，两个对象都会自己调用他们的析构函数，就会导致同一块空间被析构了两次~~这样的问题我们就需要靠深拷贝进行解决了~~就是将要被粘贴的对象生成自己的空间，然后将被copy的内容copy过来~~~👇👇👇👇👇👇👇👇👇
这样就完成我们的深拷贝了
4.2特征
如果我们不实现拷贝函数，系统也会默认生成一个拷贝构造函数。
默认生成拷贝构造函数：
1.内置类型完成按字节序的值拷贝--浅拷贝。
5.赋值运算符重载
5.1运算符重载
class Data
{
public:
Data(int year = 0, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//private:
int _year;
int _month;
int _day;
};
bool operator>(const Data& d1, const Data& d2)
{
if (d1._year > d2._year)
{
return true;
}
else if (d1._year == d2._year && d1._month > d2._month)
{
return true;
}
else if (d1._year == d2._year && d1._month > d2._month && d1._day > d2._day)
{
return true;
}
else
{
return false;
}
}
int main()
{
Data d1(2022,2,20);
Data d2(2022,2,28);
Data d3(2022,2,30);
cout<<(d1 > d2)<<endl;//这里并没有定义函数但是operator是一个特殊的函数，直接用这个>就可以进去
cout << operator>(d1, d2) << endl;
return 0;
}这里我们想用这个函数只有在类外面定义，而且里面的私有变量还需要用其他的方法访问到。这里我们可以把函数放到类里面，这样私有变量就可以直接被访问，但是传参的时候是有方法的，
bool operator>(const Data& d1)
{
if (d1._year > d1._year)
{
return true;
}
else if (_year == d1._year &&_month > d1._month)
{
return true;
}
else if (_year == d1._year &&_month > d1._month &&_day > d1._day)
{
return true;
}
else
{
return false;
}可以看到这里传参只传了一个形参，这是因为类在生成并且传参的时候，默认传一个this指针过去，也就是第一个实参的值，所以可以不用定义第一个形式参数。
总结：赋值运算符主要有4点
1.参数类型
2.返回值
3.检测自己是否给自己赋值
4.返回*this
5.一个类如果没有显示定义赋值运算符重载，编译器也会自动生成一个，完成对象按字节序的值拷贝！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
