7_静态成员函数_运算符重载_临时对象

F f4(4,12);
cout<<f3<<endl;
cout<<F::maxcd(9,6)<<endl;
cout<<f3+f4<<endl;
cout<<f3*f2<<endl;
return 0;
}
常量和临时值必须要用const
2.临时对象
如果对象变量只用到一次，就直接用匿名对象，编译器可以对匿名对象进行优化，减少对象的创建 ，提高效率。
bool age;
double salary;
date birth;
Person(){cout<<"创建Person对象在"<<this<<endl;}
~Person(){cout<<"释放Person对象在"<<this<<endl;}
};
bool F::operator!()const
{
return (n==0); //或者return !n;
}
int main()
{
F f1; //输出0/1
F f2(3); //3传递给第一个参数，结果是3/1
F f3(6,12); //结果是6/12
{
if(d==0) throw "分母不能为0";
if(d<0) this->d=-d,F::n=-n;
reduce();
cout<<"F("<<n<<'/'<<d<<")\n";
}
/* 静态成员函数 */
static int maxcd(int a,int b) //求最大公约数
{
if(a==0) return b;
return maxcd(b%a,a);
}
friend ostream& operator<<()
{
o<<f.n<<'/'<<f.d;
return o;
cout<<"====================="<<endl;
return 0;
}
结果是：
创建陈宗权老师
复制陈宗权
创建UC老师杨强
===================
创建咨询老师徐微微
辞退咨询老师徐微微
====================
}
/*加号运算符重载*/
friend F operator+(const F& lh,const F& rh)
{
/*匿名对象*/
return F (lh.n*rh.d+lh.d*rh.n,lh.d*rh.d);
}
F operator*(const F& rh)const //重载时，成员比友元少一个形参，成员里当前对象作 为第一个操作数
delete[] men;
men=new Tቤተ መጻሕፍቲ ባይዱrh.max];
len=rh.len;
max=rh.max;
for(uint i=0;i<len;i++)
men[i]=rh.men[i];
return *this;
}
};
int main()
辞退UC老师杨强
辞退咨询老师徐微微
辞退陈宗权
3.例子
struct date{
int year;
int month;
int day;
};
struct Person{
string name;
int age;
1.静态成员函数不属于某个对象，只是属于一个类，也不能被this调用
三目运算符 ? :不能重载
. 也不能重载
= -> [] () (类型转换) 这些运算符只能用成员函数来重载
()是个函数对象，必须是成员
#include<iostream>
using namespace std;
当默认的等号运算符不能满足需要时
拷贝对象时对象里有指针，所以要自己去重载默认的拷贝构造函数
后++可以重载
前++重载时，要多一个int参数,参数一般默认为0
例子: 强制类型转换重载函数
class F
{
int n;
int d;
public:
F(int n=0,int d=1):n(n),d(d) { }
如果可能尽量使用临时对象。临时对象会及时释放
关于匿名对象的例子：
class Teacher
{
string name;
string course;
public:
Teacher(const char* n,const char* c):name(n),course(c)
cout<<endl;
}
~Stack()
{
delete[] men;
}
/*等号运算符的重载 */
Stack& operator=(const Stack& rh)
{
if(this=&rh)
return *this; //可以自己给自己赋值
class F{
int n;
int d;
void reduce(){
int mcd=maxcd(n<0?-n:n,d)
if (mcd!=1) n/=mdc,d/=mcd;
}
public:
F(int n=0,int d=1):n(n),d(d)
~autoptr() {cout<<cnt<<':'<<endl; if(--cnt==0) delete p; }
/*重载->运算符*/
Person* operator->(){return p} //访问谁的成员，就返回谁的地址
/*重载星号运算符*/
{
/*匿名对象*/
return F (n*rh.n,d*rh.d);
}
friend F operator~(const F& f)
{
return F(f.d,f.n);
}
bool operator!()const;
};
friend F& operator--(F& f){ f.d-=f.d;return f; }
friend F operator--(F& f,int){ F old(f); f.n-=f.d; return old; }
operator double() //类型转换运算符返回类型可以省略
autoptr b=a; //t==2
autoptr c=a; //t==3
cout<<a->age<<endl;
a->name="芙蓉";
cout<<(*a).name<<endl;
}
4.单例模式
typedef string T;
{
return 1.0*n/d;
}
operator bool()
{ return n!=0; }
};
void func1(F a) { cout<<a<<endl; }
uint max_size()const
{ return max; }
uint size()const
{ return len; }
Stack& push(const T& e)
{
if(len>=max)
throw 1;
men[len++]=e;
//用临时对象来初始化一个新对象，编译器一般会优 化成直接用创建临时对象的参数来创建新对象
t2=t3; //赋值
cout<<"================="<<endl;
t2=Teacher("徐微微","咨询"); //临时对象会及时释放
return *this;
}
T pop()
{
if(len==0)
throw 0;
return men[--len];
}
void print()const
{
for(uint i=0;i<len;i++)
cout<<men[i];
{
cout<<"创建"<<course<<"老师"<<name<<endl;
}
Teacher(const Teacher& t):name(),course(t.course)
{
cout<<"复制"<<course<<"老师"<<name<<endl;