程序.docx

程序.docx

《程序.docx》由会员分享，可在线阅读，更多相关《程序.docx（49页珍藏版）》请在冰豆网上搜索。

程序

重载前置自加运算符

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"调用构造函数"<

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

//operator++（）;

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

i.add（）;

cout<<"i="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"调用构造函数"<

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

voidoperator++（）{n=100;};

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

i.add（）;

cout<<"i="<

i++;

cout<<"i="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"调用构造函数"<

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

numoperator++（）

{

numt;

n++;

t.set（n）;

returnt;

};

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

i.add（）;

cout<<"i="<

++i;

cout<<"i="<

numf=++i;

cout<<"f="<

return0;

}

创建无名临时对象

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

numoperator++（）

{

n++;

returnnum（n）;

};

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

i.add（）;

cout<<"i="<

++i;

cout<<"i="<

numf=++i;

cout<<"f="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

numoperator++（）

{

n++;

returnnum（n）;

};

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

numf=++i;

cout<<"f="<

return0;

}

取消临时对象

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

numoperator++（）

{

n++;

return*this;

};

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

numf=++i;

cout<<"f="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

num（constnum&s）{n=s.n;cout<<"复制构造函数"<

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

numoperator++（）

{

n++;

cout<

return*this;

//用*this替换为num（n）,用构造函数创建的临时对象来替换*this指针，它所指向的是原始对象

//用this对象来替换创建一个临时对象，这样返回的自加以后的原始对象，而不是不是临时对象，

//因此不用调用带有参数的构造函数，

};

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

i.add（）;

cout<<"i="<

numf;

f=++i;

cout<<"f="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

num（constnum&s）{n=s.n;cout<<"复制构造函数"<

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

numoperator++（）

{

n++;

cout<

return*this;

//用*this替换为num（n）,用构造函数创建的临时对象来替换*this指针，它所指向的是原始对象

//用this对象来替换创建一个临时对象，这样返回的自加以后的原始对象，而不是不是临时对象，

//因此不用调用带有参数的构造函数，

//返回的是自加以后的原始对象，而不是临时对象，因此不用调用带有参数的构造函数

};

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

i.add（）;

cout<<"i="<

numf=++i;

//将返回的原始对象赋给了新建的对象f,因此会调用复制构造函数来进行对象i到对象f成员X的复制

cout<<"f="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

num（constnum&s）{n=s.n;cout<<"复制构造函数"<

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

numoperator++（）

{

n++;

cout<

return*this;

//用*this替换为num（n）,用构造函数创建的临时对象来替换*this指针，它所指向的是原始对象

//用this对象来替换创建一个临时对象，这样返回的自加以后的原始对象，而不是不是临时对象，

//因此不用调用带有参数的构造函数，

//返回的是自加以后的原始对象，而不是临时对象，因此不用调用带有参数的构造函数

};

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

i.add（）;

cout<<"i="<

numf;

f=++i;

//将返回的原始对象赋给了新建的对象f,因此会调用复制构造函数来进行对象i到对象f成员X的复制

cout<<"f="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

num（constnum&s）{this->n=s.n;cout<<"复制构造函数"<

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

numoperator++（）

{

n++;

return*this;

};

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

numf=++i;

cout<<"f="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

num（constnum&s）{cout<<"n="<n<

cout<<"为什么="<

this->n=s.n;cout<<"复制构造函数"<

//因为不会改变，别名的值，因此将之改为const的变量

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

numoperator++（）

{

n++;

cout<<"自增后的"<<"n="<n<

return*this;

//为什么不返回成员变量执行的自加后的对象呢

//num（n）为构造函数创建的临时对象

//将之替换为this指针，他所指向原始对象

};

private:

intn;

};

intmain（）

{

numi;

//没创建一个对象都要调用构造函数来为该对象开辟内存空间

//而销毁对象则要调用析构函数来释放内存

//每一次创建对象都要牺牲一定的内存空间和一定的速度

//而且我们要执行的也只是对象的成员变量，为什么我们不返回成员变量自加后的对象呢

cout<<"i="<

numf=++i;

cout<<"f="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

num（constnum&s）

{

this->n=s.n;cout<<"复制构造函数"<

};

//因为不会改变，别名的值，因此将之改为const的变量

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

numoperator++（）

{

n++;

return*this;

//为什么不返回成员变量执行的自加后的对象呢

//num（n）为构造函数创建的临时对象

//将之替换为this指针，他所指向原始对象

//返回的是自加以后的原始对象，而不是临时对象

};

private:

intn;

};

intmain（）

{

numi;

//没创建一个对象都要调用构造函数来为该对象开辟内存空间

//而销毁对象则要调用析构函数来释放内存

//每一次创建对象都要牺牲一定的内存空间和一定的速度

//而且我们要执行的也只是对象的成员变量，为什么我们不返回成员变量自加后的对象呢

cout<<"i="<

numn=++i;

//将返回的原始对象赋给了新建的对象f

//因此会调用复制构造函数来执行对象i到对象n的成员值的复制

cout<<"n="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

num（constnum&s）

{

this->n=s.n;cout<<"复制构造函数"<

};

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

constnum&operator++（）

{

n++;

return*this;

};

constnumoperator++（intq）

{

numtemp（*this）;

n++;

returntemp;

};

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

i.add（）;

cout<<"i="<

numn=i++;

cout<<"i="<

cout<<"n="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

num（constnum&s）

{

this->n=s.n;cout<<"复制构造函数"<

};

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

constnum&operator++（）

{

n++;

return*this;

};

constnumoperator++（intq）

{

numtemp（*this）;

//将原始对象的值也就是成员拷贝到临时对象temp中，这一步可以调用复制构造函数来完成

//在为这个复制构造函数，我们要传递一个对象，这个对象是this对象，也就是原始对象

//这个this对象是operator++这个函数进行自加的当前对象，再将当前对象的数据拷贝到这个临时对象

n++;

//对this他的成员进行自加相当于this->++n;

returntemp;

//返回临时对象

//因为返回的是一个临时对象，这个临时对象在超出作用域后就被析构掉了

//如果按引用的方式返回的话，则返回的是一个空的对象，

//那么要按值的方式返回呢

};

private:

intn;

};

intmain（）

{

numi;

cout<<"i="<

i.add（）;

cout<<"i="<

numn=i++;

cout<<"i="<

cout<<"n="<

return0;

}

#include"iostream"

usingnamespacestd;

classnum

{

public:

num（）{n=1;cout<<"无参调用构造函数"<

num（inti）{n=i;cout<<"有参调用构造函数"<

num（constnum&s）

{

this->n=s.n;cout<<"复制构造函数"<

};

//因为不会改变，别名的值，因此将之改为const的变量

~num（）{cout<<"调用析构函数"<

intget（）const{returnn;}

voidset（intx）{n=x;}

voidadd（）{++n;}

constnum&operator++（）

{

n++;

return*this;

//为什么不返回成员变量执行的自加后的对象呢

//num（n）为构造函数创建的临时对象

//将之替换为this指针，他所指向原始对象

//返回的是自加以后的原始对象，而不是临时对象

};

private:

intn;

};

intmain（）

{

numi;

//没创建一个对象都要调用构造函数来为该对象开辟内存空间

//而销毁对象则要调用析构函数来释放内存

//每一次创建对象都要牺牲一定的内存空间和一定的速度

//而且我们要执行的也只是对象的成员变量，为什么我们不返回成员变量自加后的对象呢

cout<<"i="<

numn=++i;

//将返回的原始对象赋给了新建的对象f

//因此会调用复制构造函数来执行对象i到对象n的成员值的复制

cout<<"n="<

return0;

}

运算符重载的问题:

intoperator+（）;与int&operator+（）;有什么区别?

2008-02-2912:

49提问者：

 lin1270 |浏览次数：

1665次

问题补充：

能有具体的例子说明更好!

~~~如果换成Sampleoperator+（）;与Sample&opetator+（）;呢?

其中Sample是类名...

满意回答

2008-02-2914:

07热心网友

intoperator+（）这个表明这个是重载的+运算符，因为重载的操作符需要定义成非成员函数，一般都定义为友元

所以需要返回一个对象，而

int&operator+（）应该是内置的+操作符，它只要返回一个成员变量的引用即可

基本数据类型不能重载操作符，下面举个Item类的例子说明如下：

Itemoperator+（constItem&left,constItem&right）

{Itemtemp;

temp.data=left.data+right.data;

returntemp;

}

Item&operator+（con