C++学习10——父类子类的关系

//std::string类的全名，由于没有加using namespace std;所以要写全名
class Employee{
public:
    Employee(const std::string& name,const std::string& ssn);
    const std::string& get_name() const;
    void print(std::ostream& out) const;
    void print(std::ostream& out,const std::string& msg) const;
protected:
    std::string m_name;
    std::string m_ssn;
};
Employee::Employee(const string& name,const string& ssn):m_name(name),m_ssn(ssn){
    //构造函数
}
inline const std::string& Employee::get_name() const{
    return m_name;
}
inline void Employee::print(std::ostream& out) const{
    out<<m_name<<endl;
    out<<m_ssn<<endl;
}
inline void Employee::print(std::ostream& out,const std::string& msg) const{
    out<<msg<<endl;
    print(out);//调用上一个print()函数,避免代码复制，尽量使用已有的代码写新的代码
}
//print()函数重载
class Manager:public Employee{
public:
    Manager(const std::string& name,const std::string& ssn,const std::string& title);
    const std::string title_name() const;
    const std::string& get_title() const;
    void print(std::ostream& out) const;
private:
    std::string m_title;
};
Manager::Manager(const string& name,const string& ssn,const string& title=""):Employee(name,ssn),m_title(title){   
}
inline void Manager::print(std::ostream& out) const{
    Employee::print(out);
    out<<m_title<<endl;
}
inline const std::string& Manager::get_title() const{
    return m_title;
}
inline const std::string Manager::title_name() const{
    return string(m_title+": "+m_name);
}
int main(){
    Employee bob("Bob Jones","555-44-0000");
    Manager bill("Bill Smith","666-55-1234","Important Person");
    string name=bill.get_name();//okay Manager inherits Employee
    //string title=bob.get_title();//Error--bob is an Employee!
    cout<<bill.title_name()<<'\n'<<endl;
    bill.print(cout);
    bob.print(cout);
    bob.print(cout,"Employee:");
    //bill.print(cout,"Employee:");//error hidden!
}

#include<iostream>
using namespace std;
class A{
public:
    A(ii):i(ii){cout<<"A::A()"<<endl;}
    ~A(){cout<<"A::A()"<<endl;}
    void print(){cout<<"A::print()"<<i<<endl;}
    void print(int i){cout<<i;print();}
    void set(int ii){i=ii;}
private:
    int i;
};
class B:public A{
public:
    B():A(15){
        cout<<"B::B()"<<endl;       
    }//父类的构造函数调用必须在initialize中，通过initialize给父类送参数，如果不传参数给父类，父类会调用默认构造函数。如果没有这句构造函数，会报错。初始化的顺序：声明的顺序，而非写在initialize中的顺序（父类首先被构造，之后成员变量按照写在列表里的顺序构造初始化）
    ~B(){cout<<"B::~B()"<<endl;}
    //析构的顺序与构造相反
    void print(){cout<<"B::print()"<<endl;}
    void f(){
        set(20);
        print();
    }
};
int main()
{
    B b;//B中包含A的所有东西，b初始化时，A的构造函数会被调用
    b.set(10);
    b.print();
    b.f();
    b.print(200);//报错，子类将父类中的函数隐藏
    return 0;
}
//先构造A，再构造B
//先析构B，再析构A

1. 所有的成员变量都必须在initialize中

2. 父类的初始化（构造函数调用）必须在initialize中

如果父类中有重载函数，在子类中有与其中之一相同的函数，则父类中的函数隐藏。

子类中print()函数与父类中print()函数无关