c++学习-继承

继承

#include <iostream>
using namespace std;
 
class father{
 
public:
    void getHeight(){cout<<height<<endl;}
    void getAge(){cout<<age<<endl;}
protected:
    int height,age;
};
 
class son: public father{
private:
    int weight;
public:
    void getWeight(){cout<<weight<<endl;}
    void shwo()
    {
        cout<<this->weight<<endl;
        cout<<this->height<<endl;
        cout<<this->age<<endl;
    }
};
 
int main()
{
    son one;
    one.shwo();
 
}

子类对象赋值给父类

#include <iostream>
using namespace std;
 
class father{
 
public:
    int height;
};
 
class son: public father{
public:
    int weight;
 
};
 
int main()
{
    son a;
    father b;
 
    a.height=;
    b=a;//子类赋给父类
}

父类引用指向子类对象

#include <iostream>
using namespace std;
 
class father{
 
public:
    int height;
};
 
class son: public father{
public:
    int weight;
 
};
 
int main()
{
    father *p;
    son jack;
 
    p=&jack; //父类引用指向子类对象 父类还可以作为子类的别名（虚函数）
    p->height=;
 
    cout<<jack.height<<endl;
    cout<<jack.weight<<endl;
 
}

#include <iostream>
using namespace std;
 
class father{
 
protected:
    int height;
};
 
//私有派生用的不多，因为继承的成员都变成私有的了，不可以访问
class son: private father{ //继承的父类的protected,public全部变成 private
public:
    int weight;
 
    int getHeight()
    {
        return height;
 
    }
 
    void setHeight(int x)
    {
        this->height=x;
 
    }
 
};
 
int main()
{
    son a ;
    a.setHeight();
    cout<<a.getHeight()<<endl;
}

继承中构造函数的执行顺序（先构造基类，后构造子类， 先析构子类，在析构基类）

#include <iostream>
using namespace std;
 
class father{
 
private:
    int height;
public:
    father(){cout<<"father construct"<<endl;}
    ~father(){cout<<"father destruct"<<endl;}
 
};
 
class son: public father{
public:
    int weight;
    son(){cout<<"son construct"<<endl;}
    ~son(){cout<<"son destruct"<<endl;}
 
};
 
int main()
{
    son a ;
 
    return ;
}

多重继承，以 继承的顺序进行构造

向基类构造函数传递参数

#include <iostream>
using namespace std;
 
class father{
 
public:
    int height;
    int weight;
public:
    father(int height, int weight ){
        this->height=height;
        this->weight=weight;
        cout<<"father construct"<<endl;
    }
    ~father(){cout<<"father destruct"<<endl;}
 
};
 
class son: public father{
public:
    int age;
    son(int height,int weight,int age);
    ~son(){cout<<"son destruct"<<endl;}
 
};
 
son::son(int height, int weight, int age):father(height, weight)
{
    this->age=age;
    cout<<"son construct"<<endl;
}
 
int main()
{
    son a(,,) ;
 
    cout<<a.height<<endl;
    cout<<a.weight<<endl;
cout<<a.age<<endl;
 
    return ;
}

多继承的歧义(作用域操作符)

#include <iostream>
using namespace std;
 
//class father{
//
//public:
//    int height;
//    int weight;
//public:
//    father(int height, int weight ){
//        this->height=height;
//        this->weight=weight;
//        cout<<"father construct"<<endl;
//    }
//    ~father(){cout<<"father destruct"<<endl;}
//
//};
//
//class son: public father{
//public:
//    int age;
//    son(int height,int weight,int age);
//    ~son(){cout<<"son destruct"<<endl;}
//
//};
//
//son::son(int height, int weight, int age):father(height, weight)
//{
//    this->age=age;
//    cout<<"son construct"<<endl;
//}
 
class a{
public:
    void hello(){cout<<"a hello"<<endl;}
};
 
class b{
public:
    void hello(){cout<<"b hello"<<endl;}
};
 
class c : public a, public b{
public:
    void hello(){cout<<"c hello"<<endl;}
};
 
int main()
{
 
    c i;
    i.hello(); //本类的无需
    i.a::hello(); //作用域操作符，作用域分辨
    i.b::hello();
 
    return ;
}

解决两异性（虚基类）

#include <iostream>
using namespace std;
 
class common{
public:
    void stand(){}
 
};
 
class a: virtual public common{
public:
    void hello(){cout<<"a hello"<<endl;}
};
 
class b: virtual public common{
public:
    void hello(){cout<<"b hello"<<endl;}
};
 
class c : public a, public b{
public:
    void hello(){cout<<"c hello"<<endl;}
};
 
int main()
{
 
    c i;
    i.stand();
 
    return ;
}