继承中的构造，初始化父类语法

继承中的构造，初始化父类语法：

//employee.h

#pragma once
#include<iostream>
class Employee
{
public:
	Employee();
	Employee(const long, const char*);
	virtual ~Employee(){}

	const char*getName()const;
	const long getNumber()const;
	virtual double earnings()const = 0;
	virtual void print() const = 0;
protected:
	long number;
	const char *name;
};

//employee.cpp

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

Employee::Employee()
{
	this->number = 0;
	this->name = NULL;
}

Employee::Employee(const long number, const char*name)
{
	this->number = number;
	this->name = name;
}

//pieceWorker.h
#pragma once
#include"employee.h"

class PieceWorker :public Employee
{
public:
	//PieceWorker():Employee();//错误！Employee应该在定义中
	PieceWorker();
	PieceWorker(const long number, const char*name, double wagePerPiece = 0.0, int quantity = 0);
	~PieceWorker(){}
	void setWage(double);
	void setQuantity(int);
	virtual double earnings() const;
	virtual void print() const;
private:
	double wagePerPiece;
	int quantity;
};

//pieceWorker.cpp

#include"pieceworker.h"
#include<iostream>
using namespace std;

PieceWorker::PieceWorker() :Employee()
{
	this->wagePerPiece = 0.0;
	this->quantity = 0;
}

PieceWorker::PieceWorker(const long number, const char*name, double wagePerPiece, int quantity) :Employee(number,name)
{
	this->wagePerPiece = wagePerPiece;
	this->quantity = quantity;
}
void PieceWorker::setWage(double wagePerPiece)
{
	this->wagePerPiece = wagePerPiece;
}
void PieceWorker::setQuantity(int quantity)
{
	this->quantity = quantity;
}
double PieceWorker::earnings() const
{
	return wagePerPiece*quantity;
}
void PieceWorker::print() const
{
	cout << "Number:" << number << "  Name:" << name << "  Salary:" << earnings() << endl;
}