随笔——继承与派生

//继承与派生的概念
#include<iostream>
using namespace std;
class node//基类
{
private:
    string name;//名字
    int garde;//分数
public:
    void out()
    {
        cout<<"name:"<<name<<endl;
        cout<<"garde:"<<garde<<endl;
    }
    void enter()
    {
        cout<<"name:";
        cin>>name;
        cout<<"garde:";
        cin>>garde;
    }
};
class nnode:public node//派生类
{
private:
    string deparment;//部门
public:
    void out()//重名
    {
        cout<<"deparment:"<<deparment<<endl;
    }
    void nenter()
    {
        node::enter();//基类函数调用
        cout<<"deparment:";
        cin>>deparment;
    }
};
int main()
{
    node s1;
    nnode s2;
    s1.enter();
    s1.out();
    s2.nenter();
    s2.out();//函数重名
    cout<<"-----------"<<endl;
    s2.node::out();
}
/*
派生类对象包含基类对象，写法:class 派生类名:继承方式说明符 基类名{........};
对于派生类，会继承基类的成员，函数。也就是拥有基类所有特点，但派生类的成员函
数无法访问基类的私有成员.如果派生类中函数（变量）与基类中函数（变量）重名，
访问的就是派生类中的函数（变量），这种方式叫做‘覆盖’。在派生类中调用基类函数名
的方法为:基类名::函数名。
*/

//protected可访问范围
#include<ostream>
using namespace std;
class node
{
private:
    int x;
public:
    int y;
protected:
    int z;
};
class nnode:public node
{
    void init()
    {
//        x=1;//不能访问基类的私有成员
        y=1;
        z=1;//可以访问基类的保护成员
        node f;
//        f.z=1;//错：f是新定义的类，虽然在派生类内，但不是派生类，不能访问保护成员
    }
};
int main()
{
    node a;
    nnode b;
//    int n=a.z;//错：不在派生类内，不能访问基类私有成员
//    int m=b.x;//错：不能访问b的私有成员
}
/*
公有成员>=protected（保护成员）可访问的范围>=私有成员，保护成员的可访问范围在这
两者之间，保护成员扩大的访问范围表现在：基类的保护成员可以在派生类成员函数中访
问。派生类成员函数只能访问所继承的基类的保护成员，不能访问其他基类的保护成员。
*/

//派生类的析构函数和构造函数
#include<iostream>
using namespace std;
class node
{
private:
    int x,y;
public:
    node(int a,int b)
    {
        x=a,y=b;
        cout<<"create node"<<endl;
    }
    ~node()
    {
        cout<<"delete node"<<endl;
    }
    void out()
    {
        cout<<x<<y;
    }
};
class nnode:public node
{
private:
    int z;
public:
//    nnode(){};//错:派生类使用无参函数，基类也应使用默认构造函数（无参函数），可基类中构造函数被重新定义，没有了默认构造函数
    nnode(int a,int b,int c):node(a,b),z(c)
    {
        cout<<"create nnode"<<endl;
    };
    ~nnode()
    {
        cout<<"delete nnode"<<endl;
    }
    void nout()
    {
        node::out();
        cout<<z<<endl;
    }
};
int main()
{
    nnode a(1,2,3);
    a.nout();
}
/*
在派生类生成时，先执行基类的构造函数，再执行派生类构造函数。在消亡时，先执行
派生类类的析构函数，再执行基类的析构函数
*/