虚函数使用测试(c++)

2019独角兽企业重金招聘Python工程师标准>>>

// employ2.h
// Abstract base class employee

#ifndef EMPLOY2_H
#define EMPLOY2_H

#include <iostream.h>

class Employee{
public:
	Employee( const char *,const char * );
	~Employee();
	const char *getFirstName() const ;
	const char *getLastName() const ;

	// pure virtual function make employee abstract base class
	virtual double earnings() const = 0;                             // 带有纯虚函数的类就是一个抽象类,抽象类是不允许定义对象的
	virtual void print() const ;                                     // 虚函数的print 在后面的类可以直接继承,也可以改写
private:
	char *firstName;     //员式的first 和 last 名字
	char *lastName;
};


#endif
//employ2.cpp
// member function definitions for abstract base class employee

// Note :No definitions given for pure vitural functions

#include <string.h>
#include <assert.h>
#include "employ2.h"


Employee::Employee( const char *first,const char *last )
{
	firstName = new char[ strlen( first )+1 ];
	assert( firstName != 0 );
	strcpy( firstName,first );

	lastName = new char[ strlen( last )+1 ];
	assert( lastName != 0 );
	strcpy( lastName,last );
}


Employee::~Employee()
{
	delete [] firstName;
	delete [] lastName;
}

const char *Employee::getFirstName() const 
{
	return firstName;
}


const char *Employee::getLastName() const
{
	return lastName;
}


//print the name of the employee
void Employee::print() const
{
	cout<< firstName << ' ' << lastName;
}


// boss1.h
// boss class derived from employee

#ifndef BOSS1_H
#define BOSS1_H
#include "employ2.h"

class Boss : public Employee{
public:
	Boss( const char *,const char *,double = 0.0 );
	void setweeklysalary( double );
	virtual double earnings() const;                      //??
	virtual void print() const;

private:
	double weeklysalary;
};


#endif

// boss1.cpp
// member function definitions for class boss

#include "boss1.h"

Boss::Boss( const char *first, const char *last, double s ):Employee( first, last )
{
	setweeklysalary( s );
}

void Boss::setweeklysalary( double s)
{
	weeklysalary = s >0?s:0;
}

double Boss::earnings() const { return weeklysalary; }

void Boss::print() const
{
	cout<<"\n	Boss:";
	Employee::print();                // 调用基类的要注明作用域 ::
}

// commis1.h
// commissionworker class derived from employee

#ifndef COMMIS1_H
#define COMMIS1_H

#include "employ2.h"

class commissionworker : public Employee{
public:
	commissionworker( const char *, const char *, double = 0.0, double = 0.0, int =0 );
	void setsalary( double );
	void setcommission( double );
	void setquantity( int );
	virtual double earnings() const;
	virtual void print() const;
private:
	double salary;
	double commission;
	int quantity;
};

#endif
// commis1.cpp
// member function definitions for class commissionworker

#include <iostream.h>
#include "commis1.h"

commissionworker::commissionworker( const char *first, const char *last, double s, double c, int q )
:Employee( first, last )
{
	setsalary( s );
	setcommission( c );
	setquantity( q );
}

void commissionworker::setsalary( double s )
{
	salary = s>0? s: 0;
}

void commissionworker::setquantity( int q )
{
	quantity = q >0 ?q :0; 
}

double commissionworker::earnings() const
{ return salary + commission * quantity; }

void commissionworker::print() const
{
	cout<<"\n commission workder: ";
	Employee::print();
}

void commissionworker::setcommission( double c )
{
	commission = c >0 ? c: 0;
}
// piece1.h
// declare class piece
// derived from base class employee

#ifndef PIECE1_H
#define PIECE1_H

#include "employ2.h"
class Pieceworker : public Employee{
public:
	Pieceworker( const char *, const char *, double = 0.0,int =0 );
	void setwage ( double );
	void setquantity( int );
	virtual double earnings() const;
	virtual void print() const;
private:
	double wageperpiece;
	int quantity;
};

#endif
// piece1.cpp

// member function definitions for class pieceworker

#include <iostream.h>
#include "piece1.h"

Pieceworker::Pieceworker( const char *first, const char *last, double w, int q )
:Employee( first , last )
{
	setwage( w );
	setquantity ( q );
}

void Pieceworker::setwage( double w )
{
	wageperpiece = w>0 ? w : 0;
}

void Pieceworker::setquantity( int q )
{
	quantity = q>0 ?q:0 ;
}

double Pieceworker::earnings() const
{
	return quantity * wageperpiece;
}

void Pieceworker::print() const
{
	cout<<" \n		piece worker : ";
	Employee::print();
}
//虚函数使用测试

#include <iostream.h>
#include <iomanip.h>
#include "employ2.h"
#include "boss1.h"
#include "commis1.h"
#include "piece1.h"

void virtualviapointer ( const Employee * );
void virtualviareference( const Employee & );

int main()
{
	cout<< setiosflags( ios::fixed | ios::showpoint )
		<< setprecision (2);

	// Employee e;                              // 抽象类不允许声明对象  尽管不能实例化抽象基类的对象,但是可以声明引用抽象类的指针 
	Boss b( "John", "Smith", 800.00 );
	b.print();
	cout<<" earned $" << b.earnings();
	virtualviapointer ( &b );
	virtualviareference ( b );

	commissionworker c( "Sue", "Jones", 200.0,3.0,150 );
	c.print();
	cout<<" earned $" << c.earnings();
	virtualviapointer ( &c );
	virtualviareference ( c );

	Pieceworker p( "BOb", " Lewis" ,2.5, 200 );
	p.print();
	cout<<" earned $" << p.earnings();
	virtualviapointer ( &p );
	virtualviareference ( p );
	cout<<endl;


	return 0;
}


void virtualviapointer ( const Employee *baseclassptr )
{
	baseclassptr->print();
	cout<< " earned $ "<< baseclassptr->earnings();
}

void virtualviareference( const Employee &baseclassref )
{
	baseclassref.print();
	
	cout<< " earned $ "<< baseclassref.earnings();
}

转载于:https://my.oschina.net/delmore/blog/4294