cpp（3）多态性虚函数运算符重载

//虚函数的实例


#include<iostream>
using namespace std;


class father
{
public:
virtual void run()const{cout<<"父亲可以跑万米!\n";}
void jump()const{cout<<"父亲可以跳五个台阶!\n";}


};


class son:public father
{
public:
void run()const{cout<<"子类可以跑十万米!\n";}
void jump()const{cout<<"子类可以跳十个台阶!\n";}


};
int main()
{
father *p=new son;
p->run();
p->jump();
delete p;
return 0;
}
------------------------------------------------------


//为了让不同的拳手(对象)调用相同的出拳(名字相同的函数)产生不同的效果
//(函数运行效果)，我们将基类的beat()函数说明为virtual，也就是虚函数
//因此程序执行时会自动判断对象，从而调用不同对象中的函数，该函数
//将会覆盖基类的同名函数.。
#include<iostream>
using namespace std;
class poser
{
public:
virtual void beat()const{cout<<"一般选手的力量为260磅\n";}
protected:
int age;
};


class Ali:public poser
{
public:
void beat()const{cout<<"阿里一拳的力量为420磅!\n";}
};


class Lewis:public poser
{
public:
void beat()const{cout<<"刘易斯一拳的力量为420磅!\n";}
};


class Tyson:public poser
{
public:
void beat()const{cout<<"泰森一拳的力量为500磅!\n";}
};


class Holy:public poser
{
public:
void beat()const{cout<<"霍利菲尔德一拳的力量为350!\n";}
};


int main()
{
poser *p[5];
poser *p1;
int choice,i;
for(i=0;i<5;i++)
{
cout<<"(1)阿里(2)刘易斯(3)泰森(4)霍利菲尔德:";
cin>>choice;
switch(choice)
{
case 1:p1=new Ali;
break;
case 2:p1=new Lewis;
break;
case 3:p1=new Tyson;
break;
case 4:p1=new Holy;
break;
default:p1=new poser;
}
p[i]=p1;
p[i]->beat();
}


return 0;


}


-------------------------------------
//在不使用virtual之前，C++对重载使用静态联编
//而使用virtual之后，C++则对该函数进行动态联编，
//
//什么是联编：指将一个调用函数者连接上正确的被调用函数，这一过程叫做函数联编，一般简称为联编。
//C++中的联编分为两种，就是静态联编和动态联编。


//什么是静态联编：在未加virtual说明时，该函数是静态联编，即被调函数和调用函数者的关系以及它们
//的内存地址在编译时都已经确立好，运行时不在发生变化。


//什么是动态联编：编译程序在编译阶段并不能确切知道将要调用的函数，只是在程序执行时才能确定将要
//调用的函数，为此要确切知道该调用的函数，要求联编工作要在程序运行时进行，这种在程序运行时进行
//联编工作称为动态联编。
#include<iostream>
using namespace std;
class A
{
public:
int get(){return 1;} // 只要在前面加上virtual即virtual int get(){return 1;}即可实现动态联编
};
class B:public A
{
public:
int get(){return 2;}
};


void main()
{
while(1)
{
cout<<"(1)父类(2)子类(3)退出:";
int choice;
cin>>choice;
A *p;
bool quit=false;
switch(choice)
{
case 1:p=new A;
break;
case 2:p=new B;
break;
case 3:quit=true;
break;
}
if(quit==true)
{
break;
}
cout<<p->get()<<endl;
}
}
//不管选择1或2程序输出结果都是1


//假如我们在虚函数中没有采用指针或者引用，那么就无法实现动态联编
----------------------------------------------------------------
//三种调用虚函数的方式比较


#include<iostream>
using namespace std;
class father
{
public:
virtual void run()const{cout<<"父亲可以跑万米\n";}
};


class son:public father
{
public :
void run()const{cout<<"儿子可以跑十万米\n";}
};


class daughter:public father
{
public:
void run()const{cout<<"女儿可以跑五万米\n";}
};
void one (father);  //声明one函数，接受father类对象
void two (father*);   //声明two函数，接受father类指针
void three (father&);//声明three函数，接受father类引用


int main()
{
father*p=0;
int choice;
while(1)
{
bool quit=false;
cout<<"(0)quit(1)son(2)daughter(3)father:";
cin>>choice;
switch(choice)
{
case 0:quit=true;
break;
case 1:p=new son;//创建son对象，其首地址赋给p;
one(*p);
break;
case 2:p=new daughter;
two(p);
break;
case 3:p=new father;
three(*p);
break;
default:cout<<"请输入正确的数:";
break;
}
if(quit)
{
break; //quit起到退出死循环的作用
}
}


return 0;
}
void one(father one)
{
one.run();
}
void two(father*two)
{
two->run();
}
void three(father&three)
{
three.run();
}


------------------------------------------------------------------
//在虚函数中使用成员名限定可以强行解除动态联编
#include<iostream>
using namespace std;
class A
{
public:
virtual int get(){return 0;}
};


class B:public A
{
public:
int get(){return 1;}
};


int main()
{
B b;
B*p=&b;
cout<<p->get(); //输出1
cout<<p->A::get(); //使用成员名限定可以强行解除动态联编，输出0
return 0
}


------------------------------------------------------------------




//在C++中虚构造函数是不存在的，因此也无法声明。
//如果基类中定义了虚函数，析构函数也应说明为虚函数，这样对内存的回收会更准确
#include<iostream>
using namespace std;
class A
{
public:
A(){cout<<"创建A"<<endl;}
virtual void func(){cout<<"类A"<<endl;}
virtual ~A(){cout<<"析构A"<<endl;}
};


class B:public A
{
public:
B(){cout<<"创建B"<<endl;}
void func(){cout<<"类B"<<endl;}
~B(){cout<<"析构B"<<endl;}


};


int main()
{
A*p=new B;
p->func();
delete p;
return 0;
}


=============================================================================




//运算符重载


#include<iostream>
using namespace std;
class num
{
public:
num(){n=1;}
~num(){}
int get()const{return n;}
void set(int x){n=x;}

private:
int n;
};
int main()
{
num i;
cout<<"i:"<<i.get()<<endl;
i++;  //编译不通过
return 0;
}


---------------------------------------------------


//运算符重载


#include<iostream>
using namespace std;
class num
{
public:
num(){n=1;}
~num(){}
int get()const{return n;}
void set(int x){n=x;}
void add(){++n;}
private:
int n;
};
int main()
{
num i;
cout<<"i:"<<i.get()<<endl;
i.add();
cout<<"i:"<<i.get()<<endl;
return 0;
}
------------------------------------------------------------------------
//运算符重载
//operator在C++中是关键字，它通常和运算符连在一起再加括号说明是函数如:operator++()


#include<iostream>
using namespace std;
class num
{
public:
num(){n=1;}
~num(){}
int get()const{return n;}
void set(int x){n=x;}
void add(){++n;}
operator++(){++n;}    //重载运算符++
private:
int n;
};
int main()
{
num i;
cout<<"i:"<<i.get()<<endl;
i.add();
cout<<"i:"<<i.get()<<endl;
++i;
cout<<"i:"<<i.get()<<endl;
return 0;
}