C++ How To Program整理(8)

@析构函数和构造函数不能继承。
@派生类可以访问基类中的非private成员
@基类的privated只能在此基类内部或其友元函数访问
@基类的protected成员，可以被基类以及它的派生类，以及基类的友元函数和派生类的友元函数访问。

#ifndef COMMISSION_H
#define COMMISSION_H

 CommissionEmployee
 {
   public:
       CommissionEmployee(const string&, const string&, const string&, double =0, double =0);
      
       void setFirstName(const string&);
       string getFirstName() const;
      
       void setLastName(const string&);
       string getLastName() const;
      
       void setSocialSecurityNumber(const string&);
       string getSocialSecurityNumber() const;
      
       void setGrossSales(double);
       string getGrossSales() const;
      
       void setCommissionRate(double);
       string getCommissionRate() const;
      
       double earning() const;
       void print() const;
      
  private:
       string firstName;
       string lastName;
       string socialSecurityNumber;
       double grossSales;
       double commissionRate;
 };
 
 #endif
 
 
 #include <iostream>
 #include "CommissionEmployee.h"
 
 using namespace std;
 
CommissionEmployee::CommissionEmployee(const string& first, const string& last, const string& ssn, double sales , double rate)
{
  firstName=first;
  lastName=last;
  socialSecurityNumber=ssn;
  grossSales=sales;
  commissionRate=rate;
}

void CommissionEmployee::setFirstName(const string &first)
{
  firstName=first;
}
string commissionRate::getFirstName() const
{
  return firstName;
}

void CommissionEmployee::setLastName(const string &last)
{
  lastName=last;
}
string commissionRate::getLastName() const
{
  return LastName;
}

void commissionRate::setSocialSecurityNumber(const string& ssn)
{
  socialSecurityNumber=ssn;
}
string commissionRate::getSocialSecurityNumber() const
{
  return socialSecurityNumber;
}

void commissionRate::setGrossSales(double sales)
{
  grossSales=(sales<0.0)?0.0:sales;
}
double commissionRate::getGrossSales( ) const
{
  return grossSales;
}

void commissionRate::setCommissionRate(double rate)
{
  commissionRate=(rate<0.0)?0.0:rate;
}
double commissionRate::setCommissionRate( ) const
{
  return commissionRate;
}

double commissionRate::earning() const
{
  return grossSales*commissionRate;
}
void commissionRate::print() const
{
  cout<<"commission employee:"<<firstName<<' '<<lastName<<"\nsocial security number: "<<socialSecurityNumber
  <<"\ngross sales:'<<grossSales
  <<"\ncommission rate:"<<commissionRate;
}

下面是派生类
#ifndef BASEPLUS_H
#define BASEPLUS_H

#include<string>
#include"CommissionEmployee.h"
using namespace std;

class BasePlusCommissionEmployee:pbulic CommissionEmployee
{
 
 public:
     BasePlusCommissionEmployee(const string&, const string&, const string&, double =0, double =0, double =0);
 
     void setBaseSalary(double);
     double getBaseSalary() const;
 
     double earnings() const;
     void print() const;
 private:
     double baseSalary;
};
#endif

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

using namespace std;

BasePlusCommissionEmployee::BasePlusCommissionEmployee(const string& first, const string& last, const string& ssn, double sales , double rate,double salary)
:CommissionEmployee(first, last, ssn, sales, rate)
{
  setBaseSalary(salary);
}

void BasePlusCommissionEmployee::setBaseSalary(double salary)
{
  baseSalary=(salary<0.0):0.0:salary;
}
double BasePlusCommissionEmployee::getBaseSalary()const
{
  return baseSalary;
}

double BasePlusCommissionEmployee::earnings()const
{

  return baseSalary+(commissionRate*grossSales);
}

void BasePlusCommissionEmployee::print() const
{

  cout<<"base salary commission employee:"<<firstName<<' '<<lastName<<"\nsocial security number: "<<socialSecurityNumber
  <<"\ngross sales:'<<grossSales
  <<"\ncommission rate:"<<commissionRate;
  <<"\n base salary:"<<baseSalary;
}

@c++要求派生类构造函数调用基类的构造函数来初始化继承到派生类中的基类的数据成员。
@派生类的成员函数不能访问基类的private成员，所以上述代码是错误的，需要把CommissionEmployee类中的数据成员改成public类型。
@在派生类的类定义中要包含基类所在的头文件（include）原因是：
 1，要使用基类的类名
 2，编译器需要知道类定义来决定对象的大小
 3，编译器能够知道派生类是否正确的使用了由基类继承而来的成员。

@protected成员既可以被基类的成员和友元访问，又可以被由基类派生的任何类的成员和友元访问。
@将基类成员改为protected会导致：
  1，派生类太依赖基类的实现，派生类应该仅依赖基类提供的服务。
  2，派生类很容易给基类的protected成员赋值。

@派生类重载基类函数后，如果要调用基类的函数，使用”基类名：：函数名 “格式。

@创建派生类的对象时，先执行基类的构造函数，然后自己执行，析构函数与此执行顺序相反，假如基类和派生类中含有其他类的对象，那么执行顺序是：
  首先执行基类中成员对象的构造函数
  然后是基类的构造函数
  第三是派生类对象的构造函数
  最后才是派生类的构造函数
  析构函数与此顺序相反。
 
@派生类不会继承基类的构造函数，析构函数和重载的赋值运算符，但是派生类的构造函数，析构函数和重载的赋值运算符能够调用基类的   构造函数，析构函数和重载的赋值运算符函数。

@当使用public基类派生类时，基类的public成员成为派生类的public成员，基类的protected成员成为派生类的protected成员
@当使用protected基类派生时，基类的public和protected成员都变成派生类的protected成员。
@当使用private基类派生时，基类的public和protected成员都成为派生类的private成员。