/*
C++构造函数和运算符重载程序例案
*/
//程序1：
#include<iostream>
#include<string>
using namespace std;
class Person{
string name;
bool gender;
int age;
Person *lover;//注意这里是指针
public:
Person(const char *n,bool g)
:name(n),gender(g),age(0),lover(NULL){}
void show();
void growup(int years);
void marry(Person &p);
};
void Person::show()
{
cout<<"大家好，我是"<<(gender?"帅哥":"美女")<<name<<',';
cout<<"我今年"<<age<<"岁!";
if(lover==NULL)
cout<<"目前单身!"<<endl;
else
cout<<"爱人是"<<lover->name<<’!’<<endl;
cout<<endl;
}
void Person::growup(int years)
{
age+=years;
}
void Person::marry(Person &p)
{
lover=&p;
p.lover=this;//this表示当前对象
cout<<name<<"和"<<p.name<<"结婚"<<endl;
}
int main()
{
Person a("芙蓉",false);
Person b("春哥",true);
a.growup(19);
a.show();
Person e();//声明一个函数,所以一般不要在声明一个对象之后加括号(),放置引起歧义
//e().show();
b.marry(a);
a.show();
}
Person e()
{
string name;
bool gender;
int age;
cout<<"请出入姓名、性别和年龄:";
cin>>name>>gender>>age;
Person input(name.c_str(),gender);//类似于Person b("春哥",true);
input.growup(age);
return input;
}
//输出结果：
//大家好，我是美女芙蓉,我今年19岁!目前单身
//春哥和芙蓉结婚
//大家好，我是美女芙蓉,我今年19岁!爱人是春哥
---------------------------------------------------------------------------------------------------------------------------------
//程序2：
#include<iostream>
using namespace std;
class fraction{
int a;
int b;
public:
fraction(int m=0,int n=1):a(m),b(n){}
friend ostream &operator<<(ostream &o,const fraction &f)
{
o<<f.a<<'/'<<f.b;
return o;
}
friend fraction operator+(const fraction &A,const fraction& B)
{//这里返回值不加&，因为返回值需要复制，重新开辟空间保存，因为返回局部变量res，出了作用域就会释放，故需要复制一份
fraction res(A.a*B.b+B.a*A.b,A.b*B.b);
return res;
}
/*
//这里写成友员
friend fraction operator*(const fraction &A,const fraction& B)
{//这里返回值不加&，因为返回值需要复制，重新开辟空间保存
fraction res(A.a*B.a,A.b*B.b);
return res;
}
*/
//这里写成成员函数,可以使用类里面的成员（作为当前对象）,成员比友员少一个参数
fraction operator*(const fraction &A)
{
return fraction (a*A.a,b*A.b);//匿名对象
}
};
int main()
{
fraction x(2,3);
fraction y(3,4);
cout<<x+y<<endl;//由于这里是x+y,所加的结果是一个临时值，
//故对于重载运算符+、<<里面都必须加const 防止临时值消失
cout<<x*y<<endl;
}
---------------------------------------------------------------------------------------------------------------------------------
//3.临时对象
Teacher t1(“A”,102);
Teacher t2=t1;//将会调用拷贝构造函数
Teacher t3=Teacher (“B”,101);
//用临时对象来初始化一个新对象，编译器一般会优化成直接用创建临时对象的参数来创建新对象
//临时对象，当时创建，当时释放，所以建议使用临时对象
------------------------------------------------------------------------------------------------------------------------------程序3：
//一般情况下，一个函数可以写成成员函数，也可以写成非成员函数
//当写成成员函数时，可以少一个参数(当前对象this),如下面return !a,其实就是!(this->a)
#include<iostream>
using namespace std;
class fraction{
int a;
int b;
public:
fraction(int m=0,int n=1):a(m),b(n){}
friend ostream &operator<<(ostream &o,const fraction &f)
{
o<<f.a<<'/'<<f.b;
return o;
}
friend fraction operator~(const fraction& f);//友员，不是成员函数，必须有参数(表示哪个对象)
bool operator!()const//这里写成成员函数，故参数为空，表示当前对象
{
return !a;
//return !(this->a);
}
};
fraction operator~(const fraction &f)//因为是非成员函数，所以不需要加”类名::”
{
return fraction (f.b,f.a);
}
int main()
{
fraction f1(0,3);
cout<<f1<<endl;
cout<<!f1<<endl;
cout<<~f1<<endl;
cout<<~10<<endl;
return 0;
}
//程序4：
/*什么时候需要重载“=”，以及什么时候要写拷贝构造函数和析构函数：
当有指针成员指向动态内存时；
因为动态分配了内存所以要释放(即需要写析构函数)
*/
//注意：因为类里面有指针变量，所以必须要写拷贝构造函数；
//这是因为，如果不写，那么将调用默认拷贝构造函数，默认拷贝构造函
//只是复制，其他什么也不做，这样两个指针指向同一片空间，但是又
//因为构造了两个对象，会调用析构函数，就会使得同一片空间被释放
//两次(double free),产生错误；而自己写的拷贝构造函数，会重新
//开辟空间，这样就不会倒置错误
#include<iostream>
using namespace std;
class Stack{
int *a;//指针成员，会动态的指向内存
int max;
int len;
public:
Stack(int n):a(new int[n]),max(n),len(0){}
Stack(const Stack& s):a(new int [s.max]),max(s.max),len(s.len){}
~Stack(){delete []a;}
Stack& push(const int& m)
{
if(len>=max) throw 0/*"栈已满!"*/;
a[len++]=m;
return *this;
}
void print()const/*加const防止当前对象被修改*/
{
for(int i=0;i<len;i++)
cout<<a[i]<<' ';
cout<<endl;
}
//对“=”进行运算符重载,"="只能写成成员函数
//其中一个参数默认为当前对象的参数
//重载“=”表示动态赋值，故要重新匹配空间，保证和原来的空间大小一样
Stack &operator=(const Stack &/*引用表示不需要在传参数的时候复制*/rs)
{
delete []a;
a=new int [rs.max];
max=rs.max;
len=rs.len;
for(int i=0;i<len;i++) a[i]=rs.a[i];
//return *this;//可要可不要
}
};
int main()
{
Stack t1(10);
//注意：这里对于t2的初始化必须要在t1.push()之前
//否则如果将Stack t2(t1);放在t1.push()之后，由于已经入栈，故栈的空间已经被占用
Stack t2(t1);
t1.push(1).push(2).push(3).push(4);
t2.push(5).push(6).push(7).push(8);
t1.print();
t2.print();
Stack t3(6);
t3=t2;
t3.print();
}
//程序5：
//重载前”++”和后”++”：
//规定后”++”参数多一个(int){表示哑元},由此区别前++
#include<iostream>
using namespace std;
class F{
int a;
int b;
public:
F(int m=0,int n=1):a(m),b(n){}
F &operator++(){a+=b;return *this;}//前++,返回值有引用，新值就作为当前值用，不用copy
F operator++(int){F old(*this);a+=b;return old;}//后++,没有引用，用旧值计算并保留旧值，故 //需要copy
//注意：重载“<<”(输出运算符)时，如果写成两个参数，就表示不是成员函数，所以必//须加friend，表示友元，才能访问类里面的私有成员，同时第二个参数对于重载后”++” 和”~”的时候必须要加const
friend ostream &operator<<(ostream &o,const F &f)
{
o<<f.a<<'/'<<f.b;
return o;
}
//重载类型转换运算符，返回值可以不写(和重载运算符一致)
operator double(){return 1.0*a/b;}
operator bool(){return a;}
};
int main()
{
F f(2,3);
cout<<++f<<endl;
cout<<(f++)<<endl;//当是后++时，重载“<<”时第二个参数前必须加const
cout<<f<<endl;
cout<<double(f)<<endl;
cout<<bool(f)<<endl;
return 0;
}