拷贝构造
拷贝构造是构造函数的重载。
拷贝构造的第一个参数是自身类型的引用。
c++对于类的传值传参必须调用拷贝构造。所以不加引用会无穷递归。
如果没有使用拷贝构造,默认会生成一个拷贝构造,一个个字节的拷贝。
一个个字节的拷贝不会申请空间,如类中的malloc了空间,默认拷贝会拷贝相同的空间。操作空间时会重复多次操作。两个对象进行争抢。
对于内有多种类的大类也可以不用写自己的拷贝构造,因为内部的类有自己的拷贝构造。
对于相同的空间会释放两遍。
类名(const lei&t){
}
cpp
#include<iostream>
using namespace std;
class data{
public:
data(int a=0,int b=0,int c=0){//构造函数
year=a;
yue=b;
day=c;
}
data(const data&t){//拷贝构造
year=t.year;
yue=t.yue;
day=t.day;
}
void print(){
cout<<year<<"/"<<yue<<"/"<<day<<endl;
}
private:
int year;
int yue;
int day;
};
int main(){
data t1(2025,12,16);
t1.print();
data t2(t1);
t2.print();
return 0;
}

引用返回应当使用非临时的变量作返回值。
运算符重载
重载后有限级不会发生变化。
有5个不能进行重载,(sizeof),(.*),(::),(?:), (.);
重载操作符必须有一个类变量。
.*的使用

赋值运算符重载,两个已经存在的对象进行拷贝赋值。
data t1=t2是拷贝构造。data t1;t1=t2;是拷贝赋值,
在初始时是拷贝构造,先创建是拷贝赋值。
重载(=)加返回值可以连续赋值。
返回值推荐使用引用。可以减少拷贝构造的使用。
对于默认的赋值重载,类似拷贝构造的默认,只关注字节,
不关注包含的资源。
日期的重载+-。
+,+=int;

cpp
int getmonthday(int year,int month){
static int mothday[13]={-1,31,28,31,30,31,30,31,31,30,31,30,31};
if(runyear(year)&&month==2)
return 29;
else
return mothday[month];
}
data& operator+=(int n){
day=day+n;
while(day>getmonthday(year,yue)){
day-=getmonthday(year,yue);
yue++;
if(yue>12){
yue=1;
year++;
}
}
return *this;
}
data operator+(int n){
data tmp=*this;
tmp.day=tmp.day+n;
while(tmp.day>getmonthday(tmp.year,tmp.yue)){
tmp.day-=getmonthday(tmp.year,tmp.yue);
tmp.yue++;
if(tmp.yue>12){
tmp.yue=1;
tmp.year++;
}
}
return tmp;
}

重载日期减

cpp
data operator-(int n){
data tmp=*this;
tmp.day=tmp.day-n;
while(tmp.day<1){
tmp.day+=getmonthday(tmp.year,tmp.yue);
tmp.yue--;
if(tmp.yue==0){
tmp.yue=12;
tmp.year--;
}
}
return tmp;
}
data& operator-=(int n){
*this=*this-n;
return *this;
}
日期减日期。
cpp
int tian(){
int i;
int n=0;
for(i=1;i<year;i++){
if(runyear(i))
n+=366;
else
n+=365;
}
for(i=1;i<yue;i++){
n+=getmonthday(year,i);
}
n+=day;
return n;
}
int operator-(data d2){
return tian()-d2.tian();
}
