定一个头文件person.h包含类的声明：每行后面的注释是学习过程中的体会与思考
#include<iostream>
#ifndef PERSON_H_
#define PERSON_H_
class Person
{
private:
int ID;//只有静态的常量数据成员才可以在类中初始化,与C#不一样
std::string Name;
int Age;
double Money;
char * Address;//定义一个字符串指针成员
static int PersonNum;//定义一个静态变量记录对象的个数,静态变量要在源文件中初始化，如果没初始化会有错误，为什么？
public:
Person();//默认的构造函数
Person(int id,std::string name,int age,double m,const char* s);//带有参数的构造函数
Person(const Person & s);//定义复制构造函数
Person & operator=(const Person &p);//重载=操作符，实现深度复制
virtual ~Person();//析构函数
virtual void playway();//定义一个虚函数，通过虚函数实现多态
void GetName();
void SetPerson(int id, std::string name,int age,double m);
const Person & ComparePerson(const Person& p) const;//比较两个person的钱的大小，返回钱多的对象，括号后面的const表面函数不会修改被隐式的访问对象,参数为引用传递
const Person & ComparePersonPassValue(Person p) const;//比较两个person的钱的大小，返回钱多的对象，括号后面的const表面函数不会修改被隐式的访问对象,参数为值传递
Person operator*(double m)const;//通过成员函数来重载操作符，会隐式的传递默认的调用对象作为第一个参数，即新对象=对象*值，如果要执行值*对象，就要用下面的友元函数解决了
friend Person operator*(double m,const Person & p)//通过友元函数解决值*对象的问题，注意第一个参数为double,第二个参数为Person类型引用，同时函数定义为内联形式，内联函数可以直接在头文件中定义
{
return p*m;//会调用operator*(double m)const这个成员函数
}
friend std::ostream& operator<<(std::ostream& os,const Person &p);//友元函数重载操作符<<，便于输出类型，因为在一般情况下cout<<只能输出一些标准类型的变量
};//类声明后，有分号，与C#不同
class ManOrWomenPerson:public Person //定义ManPerson继承于Person
{
private:
unsigned int Sex;//0 标示男人，1表示女人
public:
ManOrWomenPerson(int id,std::string name,int age,double m,const char* s,unsigned int sex);//为继承的类定义一个新的带参数的构造函数
ManOrWomenPerson(const Person & p,unsigned int sex);//为继承类定义一个复制构造函数，想想复制构造函数在什么时候被调用
~ManOrWomenPerson();//析构函数
virtual void playway();//定义一个虚函数
void ShowSex();//定义一个返回性别的函数
};//这个地方分号要注意，c#中没有
#endif
Person.cpp类的实现
#include<iostream>
#include<string>
#include "person.h"
using std::cout;
int Person::PersonNum=0;
void Person::GetName()
{
cout<<"Name:"<<Name<<std::endl;
cout<<"Money:"<<Money<<std::endl;
}
Person::Person()
{
cout<<"调用了默认的构造函数"<<std::endl;
PersonNum++;
cout<<"对象个数为："<<PersonNum<<std::endl;
}
Person::Person(int id,std::string name,int age,double m,const char* s)
{
cout<<"调用了带有参数的构造函数"<<std::endl;
ID=id;
Name=name;
Age=age;
Money=m;
Address=new char[std::strlen(s)+1];//通过new分配新的空间
std::strcpy(Address,s);
PersonNum++;
cout<<"对象个数为："<<PersonNum<<std::endl;
}
Person::Person(const Person & s)
{
cout<<"调用了基类Person复制构造函数进行深度复制"<<std::endl;
ID=s.ID+1;
Name=s.Name+"1";
Age=s.Age+1;
Money=s.Money+1;
Address=new char[std::strlen(s.Address)+1];//通过new分配新的空间
std::strcpy(Address,s.Address);
PersonNum++;
cout<<"对象个数为："<<PersonNum<<std::endl;
}
Person & Person::operator=(const Person& p)//重载赋值操作运算符
{
if(this==&p) //判断是否是自己给自己赋值
return *this;
cout<<"调用了Person重载的赋值=函数进行深度复制"<<std::endl;
ID=p.ID+2;
Name=p.Name+"2";
Age=p.Age+2;
Money=p.Money+2;
/*delete [] Address; 删除一个指向不明确的指针时会报错*/
Address=new char[std::strlen(p.Address)+1];//通过new分配新的空间
std::strcpy(Address,p.Address);
return *this;
}
Person::~Person()
{
PersonNum--;
delete []Address;//释放指针所指向的内存空间及内容，与new对应，析构函数中一定要有这个，否则对象释放后，却没有释放对象中得指针成员所指向的内容，造成内存泄露
cout<<"调用了基类类Person析构函数释放了对象："<<Name<<std::endl;
cout<<"对象个数为："<<PersonNum<<std::endl;
}
void Person::SetPerson(int id,std::string name,int age,double m)
{
ID=id;
Name=name;
Age=age;
Money=m;
}
const Person& Person::ComparePerson(const Person & p) const //比较两个person的钱的大小，返回钱多的对象，括号后面的const表面函数不会修改被隐式的访问对象，参数为引用传递
{
if(p.Money>Money)
{
return p;
}
else
{
return *this;//this 是指向本对象的一个指针，*this表示对象本身，返回类型为引用，表示返回的不是对象的拷贝，而是对象本身。
}
}
const Person& Person::ComparePersonPassValue(Person p) const //比较两个person的钱的大小，返回钱多的对象，括号后面的const表面函数不会修改被隐式的访问对象，参数为值传递
{
if(p.Money>Money)
{
return p;//这里返回局部变量的地址作为引用，是有危险的，因为局部变量使用后就消失了，引用的对象将不会存在
}
else
{
return *this;//this 是指向本对象的一个指针，*this表示对象本身，返回类型为引用，表示返回的不是对象的拷贝，而是对象本身。
}
}
Person Person::operator*(double mult)const //定义成员函数重载的操作符，返回一个新的Person对象
{
Person p; //局部变量类，执行完return语句后，跳出函数体，析构函数将被调用
p.Money=this->Money*mult;//或者写为Money*mult，this作为隐式参数传递进来的,成员函数可以直接访问类的私有变量p.Money
return p;
}
std::ostream & operator<<(std::ostream& os,const Person &p)//os参数是对cout的引用，重载了<<操作符
{
os<<"对象姓名："<<p.Name<<" 财产："<<p.Money<<" 地址："<<p.Address<<std::endl;
return os;
}
void Person::playway()
{
cout<<"调用了基类Person的的动作函数"<<std::endl;
cout<<"爱好："<<"还没有"<<std::endl;
}
ManOrWomenPerson::ManOrWomenPerson(int id,std::string name,int age,double m,const char* s,
unsigned int sex):Person(id,name,age,m,s)//派生类的带参数的构造函数，会先调用基类的构造函数Person(id,name,age,m,s)在调用此构造函数，构造函数不能继承
{
Sex=sex;
cout<<"调用了派生类ManOrWomenPerson的带参数的构造函数"<<std::endl;
}
ManOrWomenPerson::ManOrWomenPerson(const Person & p,unsigned int sex):Person(p)//派生类的复制构造函数，会先调用基类的复制构造函数，构造函数不能继承
{
cout<<"调用了派生类ManOrWomenPerson的复制构造函数"<<std::endl;
/*Sex=sex; 这句什么时候会被调用，有疑问？？？？ */
}
void ManOrWomenPerson::ShowSex()
{
if(Sex==1)
cout<<"性别："<<"男"<<std::endl;
else
cout<<"性别："<<"女"<<std::endl;
}
ManOrWomenPerson::~ManOrWomenPerson()//派生类的析构函数，析构函数不能继承
{
cout<<"调用了派生类ManOrWomenPerson的析构函数"<<std::endl;
}
void ManOrWomenPerson::playway() //虚拟函数，申明的时候有virtual修饰，定义的时候不需要
{
cout<<"调用了派生类ManOrWomenPerson的的动作函数"<<std::endl;
if(Sex==1)
cout<<"爱好："<<"打游戏"<<std::endl;
else
cout<<"爱好："<<"打麻将"<<std::endl;
}
main函数的实现：
/*
Person person1;//调用默认的构造函数
person1.SetPerson(1,"xiaoming",30,1000000);
person1.GetName();//通过公用方法访问类的私有成员，//std::string s=person1.Name; 不能访问类的私有成员,但是可以访问公有的成员，c++中默认的成员是私有的，与C#中一样，成员默认也是私有的
Person person2(2,"xiaohong",60,200000);//调用带有参数的构造函数
person2.GetName();
Person person3;//
person3=person1;//给对象赋值，引用相同的成员函数地址,但是对象的成员数据值相等，存储地址不同
person1=Person(2,"xiaoqiang",60,300000);//会调用带有参数的构造函数创建临时对象，赋值后，会立即调用析构函数删除该临时对象。
person1.ComparePerson(person2);//const限定了返回的类型修饰，如果修改返回值是不允许的。参数通过引用传递
person1.ComparePersonPassValue(person2);//const限定了返回的类型修饰，如果修改返回值是不允许的。参数通过值传递*/
/*
Person person4(2,"person4",60,200000);//调用带有参数的构造函数
Person person5;
person5=person4*1.5;
person5.GetName(); //无法通过person5.Money或者person5.Name直接输出,因为私有成员只能通过成员函数放问，而在C#中可以直接这样访问属性，体现了c#属性访问器的优势
person5=1.5*person4;//会调用友元函数重载的操作
cout<<person5;//由于类重载了操作符<<，因此可以直接输出类类型的变量*/
/*
Person person6(6,"person6",80,20000000,"this is person6");
cout<<person6;
callperson1(person6);//参数按引用传递，效率较高
cout<<person6;
callperson2(person6);//按值传递参数，会导致产生临时的对象，会调用默认的复制构造函数和析构函数，由于成员中有指针变量，将释放指针变量指向的内容，导致person6中得成员指针指向的内容为乱码，
//所以要添加默认的复制构造函数，实现深度复制，不仅仅复制指针地址，而应该复制地址对应的内容
cout<<person6;
Person person7=person6;//给对象赋值，会调用复制构造函数。
cout<<person7;
Person person8;//调用默认的构造函数
person8=person6;//会调用隐式的赋值操作符，实现成员的逐个复制。产生的问题还上面一样也是浅复制，析构后会对person6的指针成员变量有影响，所以要重载类的赋值操作运算符=。
cout<<person8;*/
/*
Person* person9=new Person(9,"person9",80,9999,"this is person9");//new为对象动态分配内存空间，返回一个对象的指针，是给对象整体分配空间,会调用带有参数的构造函数
cout<<*person9; //特别注意new分配的空间，不会自动调用析构函数释放存储空间，需要显示的使用delete
Person person10(10,"person10",80,10000,"this is person10");//会调用带有参数的构造函数，自动调用析构函数释放空间
cout<<person10;
delete person9;//显示的调用析构函数，释放动态分配的空间，否则会出现内存泄露的现象*/
/*
Person person11(11,"person11",80,11111111,"this is person11");//生成一个基类对象
cout<<person11;//调用基类的<<操作符输出基类
ManOrWomenPerson person12(12,"person12",80,12121212,"this is person12",1);//生成一个派生类的对象，会先调用基类的构造函数，在调用派生类的构造函数
cout<<person12;//调用基类的<<操作符输出基类
person12.ShowSex();//调用派生类的显示性别的方法
ManOrWomenPerson person13=person12;//会先调用基类的复制构造函数
Person & rp=person12; //在引用和指针的定义中，一般情况下引用和指针必须和它指向的对象属于同一类型，但是这点在类的继承中不一样
Person * pp=&person12; //基类的引用和指针可以指向派生类,但是访问引用和指针的时候，指向的又是派生类的对象
cout<<rp;
cout<<*pp;*/
/*
Person person13(11,"person13",80,13131313,"this is person13");//生成一个基类对象
ManOrWomenPerson person14(14,"person14",80,12121212,"this is person14",1);//生成一个派生类的对象，会先调用基类的构造函数，在调用派生类的构造函数
Person & rp=person13; //在引用和指针的定义中，一般情况下引用和指针必须和它指向的对象属于同一类型，但是这点在类的继承中不一样
Person * pp=&person14; //基类的引用和指针可以指向派生类,但是访问引用和指针的时候，指向的又是派生类的对象
rp.playway();//引用的类型是基类，对象也是基类，所以会调用基类的动作函数
pp->playway();//指针的类型是基类，但是指向的对象是派生类，所以会执行派生类的动作函数
Person* person15=new Person(15,"person15",80,15151515,"this is person15");//new为对象动态分配内存空间，返回一个对象的指针，是给对象整体分配空间,会调用带有参数的构造函数
Person* person16=new ManOrWomenPerson(16,"person16",80,16161616,"this is person16",0);//new为对象动态分配内存空间,注意指针类型与对象的类型不一样
//如果基类的析构函数不是虚拟的话，将会只调用基类的析构函数
delete person16; //person16本来为派生类，我们认为应该先调用派生类的析构函数，在调用基类的析构函数，这样的顺序才是合理的，所以必须将基类的析构函数定义为虚拟的。
delete person15;*/