深度摸索C++对象模子(3)[VC/C++编程]

介绍
多态是一种威力强盛的计划机制,答应你担当一个抽象的public接口之后,封装相关的范例,需求付出的代价就是额外的间接性--不管是在内存的得到,或是在类的决断上,C++通过class的pointer和references来支持多态,这种程序气势就称为"面向对象".

大家好,雷神关于《深度摸索C++对象模子》笔记终于又和大家晤面了,速度慢的真是可以.好了不浪费时间了,直接进入主题.
这篇笔记主要办理了几个常常被人问到的问题.
1、C++支持多重担当吗?
2、构造和类的辨别是什么?
3、若何计划一个面向对象的模子?

C++支持多重担当（JAVA和C#不支持多重担当）,固然我想我大概一辈子用不到它这一特点（C++是雷神的业余爱好）,但至少我要知道它可以.典型的多重担当是下面这个:

//iostream 从istream 和 ostream 两个类担当.
class iostream:public istream,public ostream
{......};

构造struct和类class到底有没有辨别?VCHELP上前几天还看到一个帖子在谈论这个问题.其实构造和类真的没什么辨别,不过我们需求掌握的是什么时刻用构造好,什么时刻用类好,当然这没有严峻的规定.普通我们混合利用它们,从书上的例子,我们可以看出为什么还需求保存构造,并且书上给出了一个办法:

struct C_point{.......}; //这是一个构造
class Point
{
public:
operator C_point(){return _c_point;}
//....
private:
C_point _c_point;
//....
}

这种办法被成为组合（composition）.它将一个对象模子的全部或部份用构造封装起来,这样做的好处是你既可以在C++中利用这个对象模子,也可以在C中利用它.因为struct封装了class的数据,使C++和C都能有符合的空间筹划.

面向对象模子是有一些相彼此关的范例,通过一个抽象的base class（用来供应接口）,被封装起来.真正的子类都是通过它派生的.当然一个计划优异的对象模子还必须考虑很多的细节问题,雷神按照自己的理解写出一个面向对象模子的代码,大家可以看看,高手请给指出有没有问题.雷神先谢了.

思绪:我想要实现一个人员管理管理的对象模子,雷神一向在考虑一个人员管理的组件（当然终究它会用C#实现的一个业务逻辑对象,并通过数据库掌握对象和数据库举行交互,通过WEB form来显示界面）.这里借用一下自己的已经有的的设法,用C++先举行一下实行,由于只是为了领会面向对象的概念,我们采取面向对象的办法实现一个链表程序,并且没有汇集信息的接口.信息从mina()函数显式给出.

这个对象模子应当可以实现对人员的普通性管理,要求具有以下功效:

成立一个人员信息链表
增添、删除人员信息
显示人员信息

//*************************************************
//PersonnelManage.cpp
//成立人:雷神
//日期:2002-8-30
//版本:
//描写:
//*************************************************

#include
#include
//基类,是此对象模子的最上层父类
class Personnel
{
friend class point_list; //用来实现输出链表,以及插入或删除人员的功效.
protected:
char serial_number[15];//编号
char name[10];//名称
char password[15]//口令
Personnel *pointer;
Personnel *next_link;
public:
Personnel(char *sn,char *nm,char *pwd)
{
strcpy(serial_number,sn);
strcpy(name,sm);
strcpy(password,pwd);
next_link=0;
}
Personnel()
{
serial_number[0]=NULL;
name[0]=NULL;
password[0]=NULL;
next_link=0;
}
void fill_serial_number(char *p_n)
{
strcpy(serial_number,p_n);
}
void fill_name(char *p_nm)
{
strcpy(name,p_nm);
}
void fill_password(char *p_pwd)
{
strcpy(password,p_pwd);
}

virtual void addnew(){}
virtual void display()
{
cout<<"\n编号:"< cout<<"名字:"< cout<<"口令:"< }
};
//下面是派生的子类,为了简单些我在把子类举行了成员简化.
//思绪:由父类派生出成员子类,正式成员要求更具体的个人资料,这里省略了大部份.
//并且正式成员可以有一些系统的操作权限,这里省略了大部份.
//正式成员子类
class Member:public Personnel
{
friend class point_list;
private:
char member_email[50];
char member_gender[10];
double member_age;
public:
Member(char *sn,char *nm,char *pwd,char *em,char *gd,double ag):Personnel(sn,nm,pwd)
{
strcpy(member_email,em);
strcpy(member_gender,gd);
member_age=age;
}
Member():Personnel()
{
member_email[0]=NULL;
member_gender=NULL;
member_age=0.0;
}
void fill_email(char *p_em)
{
strcpy(member_email,p_em);
}
void fill_gender(char *p_gd)
{
strcpy(member_gender,p_gd);
}
void fill_age(double ages)
{
member_age=ages;
}

void addnew()
{
pointer=this;
}
void display()
{
Personnel::display()
cout<<"电子邮件:"< cout<<"性别:"< cout<<"年纪"< }
};

//好了,我们还需求实现一个超级成员子类和一个项目经理的子类.
//这是超级成员类
class Supermember:public Member
{
friend class point_list;
private:
int sm_documentcount;//提交的文档数
int sm_codecount;//提交的代码段数
public:
Supermember(char *sn,char *nm,char *pwd,char *em,char *gd,double ag,int dc,int cc):Member(sn,nm,pwd,gd,ag)
{
sm_documnetcount=0;
sm_codecount=0;
}
Spupermember():Member()
{
sm_documentcount=0;
sm_codecount=0;
}
void fill_documentcount(int smdc)
{
sm_documentcount=smdc;
}
void fill_codecount(int smcc)
{
sm_codecount=smcc;
}

void addnew()
{
pointer=this;
}
void display()
{
Member::display()
cout<<"提交文章数:"< cout<<"提交代码段数"< }
};

//实现友元类
class point_list
{
private:
Personnel *location;
public:
point_list()
{
location=0;
}
void print();
void insert(Personnel *node);
void delete(char *serial_number);
}
//显示链表
void point_list::print()
{
Personnel *ps=location;
while(ps!=0)
{
ps->display();
ps=ps->next_link;
}
}
//插入链表
void point_list::insert(Personnel *node)
{
Personnel *current_node=location;
Personnel *previous_node=0;
while(current_node!=0 && (strcmp(current_node->name,node->name<0)
{
previous_node=current_node;
current_node=current_node->next_link;
}
node->addnew()
node->pointer->next_link=current_node;
if(previous_node==0)
location=node->pointer;
else
previous_node->next_link=node->pointer;
}

//从链表中删除
void point_list::delete(char *serial_number)
{
Personnel *current_node=location;
Personnel *previous_node=0;
while(current_node!=0 && strcmp(current_node->serial_number,serial_number)!=0)
{
previous_node=current_node;
current_node=current_node->next_link;
}
if(current_node !=0 && previous_node==0)
{
location=current_node->next_link;
}
else if(current_node !=0 && previous_node!=0)
{
previous_node->next_link=current_node->next_link;
}
}

//这是主函数,我们显式的增添3个Supermember信息,然后在通过编号删除一个
//我们没有从成员再派生出管理成员,所以没有办法演示它,但我们可以看出要实现它并不难
//注意:此程序没有经过考证,大概会有BUG.
main()
{
point_list pl;
Supermember sm1("000000000000001","雷神","123456","lsmodel@ai361.com","男",29.9,10,10);
Supermember sm1("000000000000002","木一","234567","MY@ai361.com","男",26.5,20,5);
Supermember sm1("000000000000003","落叶夏日","345678","LYXR@ai361.com","男",24.8,5,15);
//假如我们还派生了管理人员,大概的方法以下:
//Managemember mm1("000000000000004","ADMIN","888888","webmaster@ai361.com","男",30,5,15,......);

//下面是将上面的3个人员信息加到链表中
pl.insert(&sm1);
pl.insert(&sm2);
pl.insert(&sm3);
//对应管理人员的 pl.insert(&mm1);

//下面是显示他们
//下面是显示人员列表
pl.print();

//下面是删除一个人员信息
pl.delete("000000000000001");
//我们再显示一次看看.
cout<<"\n删除后的列表:\n";
pl.print();
}

程序没有上机考证,在我的头脑里运行了一下,我想输出后果应当是这样的:

编号:000000000001
名称:雷神
口令:123456
电子邮件:lsmodel@ai361.com
性别:男
年纪:29.9
提交文章数:10
提交代码数:10

编号:000000000002
名称:木一
口令:234567
电子邮件:MY@21CN.com
性别:男
年纪:26.5
提交文章数:20
提交代码数:5

编号:000000000003
名称:落叶夏日
口令:345678
电子邮件:LYXR@163.com
性别:男
年纪:24.8
提交文章数:5
提交代码数:15

删除后的列表:

编号:000000000002
名称:木一
口令:234567
电子邮件:MY@21CN.com
性别:男
年纪:26.5
提交文章数:20
提交代码数:5

编号:000000000003
名称:落叶夏日
口令:345678
电子邮件:LYXR@163.com
性别:男
年纪:24.8
提交文章数:5
提交代码数:15

通过上面的例子,我想我们可以理解对象模子的给我们带来的好处,我们用了大量的指针和引用,来完成多态的特点.和书上的资料库的例子差别,我们多了一层,那是因为我考虑人员大概是匿名,也大概是注册的,所认为了辨别他们,用了两层来完成接口,然后全部注册的正式成员才都由Member类派生出差别的权限的人员,比方超级成员和管理人员.

最后用书上的一段话总结一下吧.P34

总而言之,多态是一种威力强盛的计划机制,答应你担当一个抽象的public接口之后,封装相关的范例,需求付出的代价就是额外的间接性--不管是在内存的得到,或是在类的决断上,C++通过class的pointer和references来支持多态,这种程序气势就称为"面向对象".